1. Home
  2. Work
  3. Java
  4. Courses
  5. Project - Fundamental Period

IAM Project - Fundamental Java Students

The first step in the IAM application : the IAM Core

Introduction

The goal of this project is to make you discover how to program in Java.

This project has a good covering in the nowadays Java language usage, you will learn basic things, like creating and using the Java Developer Kit APIs, but also to persist data in databases, or executing an application on a Java application Server.

The subject of Identity Management has been chosen because it will put trainees in the Business application world, which is what they will probably do in the next years

The Identity Management software

This Identity Management software is quite basic. The main goal is to manage users of an Information System. As many basic concepts, it can be much improved, especially when you want to bring security to this management. The application will be able to :

  • Access, create and modify user information
  • Persist users data in a database (or in an XML File)
  • Be robust, capable of good performance
  • Propose a simple but efficient user interface (optional)

First Step: manage Identities

Identity information management

First of all, let's focus on the Identity Management. This feature should include

  • Means to read and store information about identities. This feature can be achieved in several ways (these means are listed from the simplest to the hardest).
    • The minimal thing is to provide a set of API to act on identities data
    • You also can do it through a SWT application thanks the GUI builder in Eclipse see : Eclipse gui builder
    • If you are used to using servlets, JSP and more generally web interface, you can do a little java web application.
    Data can be persisted by reading/writing data from/in a raw file, an xml file or a database using a JDBC connector.

As an example of an identity definition, you can look at the schema hereafter:

fig. An identity object

You can find a global activity diagram below:

Authentication management

You should differentiate Identities (what is managed) and Users (who does manage). Users can access to the application thanks to a login and a password. As users are also identities, try to optimize your code to avoid code replication

This must be done with regards to the regular security constraints concerning this kind of feature

Main actions

Your application should comport a scenario which authenticates a user, and makes him use the Identity management through predefined methods

  • Create an Identity
  • Update an Identity
  • Delete an Identity

Once accomplished, this step should have you made use the very basics of the Java language

Documentation Normalization

Being able to write a documentation at a standard and with a scientific approach is very appreciated in companies

Hereafter should be your table of content

  1. Subject description
  2. Subject analysis
    1. Major features
    2. Application Feasibility
    3. Data description
    4. Expected results
    5. Algorithms study
    6. Scope of the application (limits, evolutions)
  3. Conception
    1. Chosen algorithm
    2. Data structures
    3. Global application flow
    4. Global schema and major features schema
  4. Console operations description
    1. <One section by operation>
  5. Configuration instructions
  6. Commented Screenshots
  7. Bibliography

Content summary of the part 1

To give you more indications about what you have to do to achieve this practical assignment, here is a summary, including the evaluation percentage of each item

Goal Technical content Evaluation
First level : defining a Java Object and use it in an application
This is what we should have seen during the first courses: the goal is to initiate you to the Java ecosystem: manipulate basics of the language as much as discovering java tools such as Eclipse To achieve this point you should have:
  • A Java project in Eclipse, containing what will be your core treatments (you could say your application logic)

  • In this Java project, you have to define your own package (remember the good practice) to write your first Java Object: it has to be the Identity object defined in this document, please re-read the specification to find how to implement the Identity.

    You also should be able to run some tests on this object :

    • Instantiate an Identity
    • Store information in it
    • Test its method
 15
Second level : Find a way to persist a POJO
This is the most common problem in computer science, for achieving this part fully, you must be able to store a list of Identity in an XML file or in a Data Base To achieve this point you should have:
  • The previous point totally achieved
  • If you chose the database connection, you should be able to connect to the database through a JDBC connection, manipulate the PreparedStatement and the Connection object, to read and record from / to the database
  • If you chose the XML File persistence, you should use at least the DOM API to parse your XML file and read/write from/to the xml file.
40
Level three: Be professional

This point will stand for all the Quality and Documentation in the project, all your classes should contain appropriate javadoc and comments (a tool evaluating your code quality will be used)

You also must provide a technical description of your architecture, this documentation should be in a standard format : odt, pdf, doc, docbook, dita, epub. This document is called Technical Specification

You should provide a user guide on how to use the "public" part of your program. The public part of your program can either be a GUI or a set of APIs depending if you achieved to make a working GUI. This document is called the User guide. This user guide should be readable by someone who doesn't know about your program internal architecture.

 To achieve this point you should have:
  • A document indicating what your program is doing and how it is wired inside (what kind of APIs). Do not hesitate to provide schemas in this documentation, this is the Technical Specification document
  • A document indicating how your program should be used, this is the User Guide
  • You must export your javadoc in a jar called javadoc.jar, and put it in your project in a folder named "javadoc"
  • The preceding requirement implies that you comment well your code, and especially the javadoc.
35
Attendance 10
Total 100
Bonus points
Make everything configurable: This configuration will avoid hardcoded parameter like connection strings or file path. This is always bad in any application To achieve this point you should have:
  • A global configuration class, which can read a configuration property set from a file on the filesystem (so the path to this file is hardcoded or given as an application parameter)
  • Your configuration must be based on a standard format like properties or XML
  • Try to list everything variable in your application and parameter it inside your configuration file
10
Do a GUI allowing to use your Identity APIs as well as your serializers/deserializers. To achieve this point you should have:
  • A GUI that can run as a desktop application, or a web server (prefer the web server)
  • This point should be made after you did the other elements listed above. I will not take it in account for the evaluation if you have not already made what is really required before.
20

To the second step: Extending Identity

Our Identities are rather poor. Indeed, to be closer to a real use, we should add a possibility to extend the Identity definition

You should add to the identity fields a data structure allowing to store attributes and their values dynamically

In addition to that, you will construct an address definition according to this spec, and add it to the Identity fields. As an Identity can have several addresses, choose the appropriated data structure to hold these addresses