`un carnet d\`adresse en Java populaire

Institut de la Francophonie pour l’Informatique
RAPPORT DU PROJET
GÉNIE LOGICIEL AVANCÉ
Sujet : « Implémentation d'un carnet d'adresse en Java »
Réalisé par:
 NGUYEN Van Tho
 KASEREKA KABUNGA Selain
Hanoï, Décembre 2012
TABLE DES MATIERES
TABLE DES MATIERES ....................................................................................................... 2
1.
INTRODUCTION ............................................................................................................. 3
2.
SPECIFICATION DE L'APPLICATION ....................................................................... 3
3. LES EXIGENCES FONCTIONNELLES ET NON FONCTIONNELLES DE
L'APPLICATION ..................................................................................................................... 4
3.1. Exigences fonctionnelles ..................................................................................... 4
a.
Diagramme de cas d’utilisation ........................................................................... 5
3.2. Les exigences non-fonctionnelles de l’application ....................................... 6
4.
LA CONCEPTION ........................................................................................................... 7
4.1. Diagramme de classe ............................................................................................... 7
4.2. Diagramme de séquence ......................................................................................... 7
5.
a.
Création d’un contact ............................................................................................ 8
b.
Rechercher un contact ......................................................................................... 8
c.
Modifier un contact ................................................................................................ 9
d.
Supprimer un contact............................................................................................ 9
IMPLEMENTATION ET TEST .................................................................................... 10
5.1. Solution technique .................................................................................................. 10
a.
Le choix de la plate forme de développement ................................................ 10
b.
Le choix du langage de programmation .......................................................... 10
c.
La base de données .......................................................................................... 10
5.2. Le test d’acceptation .............................................................................................. 10
6.
CONCLUSION ............................................................................................................... 13
7.
CODE SOURCE ............................................................................................................ 14
1. INTRODUCTION
C’est dans le cadre du cours de Génie logiciel avancé que nous avons réalisé
ce travail. Le but poursuivi est de revoir les concepts de la modélisation avec
UML et la programmation orientée - objet avec Java et aussi de se familiariser
à l'environnement de développement intégré (IDE) « libre » (Open Source)
ECLIPSE.
Jadis les notions de gestion par les technologies de l'information et de la
communication n'existaient pas, la gestion d'informations était totalement
manuelle et plusieurs désavantages de cette façon de faire se sont vite fait
remarquer par plusieurs indices. Nous pouvons citer le gaspillage de temps
dans la gestion, la sécurité des informations non garantie, les erreurs dans les
calculs rendant ainsi le résultat biaisé, etc.
Cet outil que nous développons n'est qu'un petit programme qui permet à un
utilisateur de gérer ses contacts grâce à un carnet d’adresse.
2. SPECIFICATION DE L'APPLICATION
Le projet que nous concevons et réalisons dans ce travail est un gestionnaire
de carnet d’adresse. Les entrées de ce carnet sont : le nom de la personne,
ses numéros de téléphone et ses adresses (travail et domicile).
Ce gestionnaire fournit à l'utilisateur les fonctionnalités suivantes:

Créer une nouvelle personne;

Chercher et afficher tous les numéros de téléphone et l’adresse d'une
personne étant donné que son nom est entré à partir du clavier;

Supprimer une personne de la liste étant donné que son nom est entré
à partir du clavier;

Chercher et modifier les numéros de téléphone et l’adresse d'une
personne étant donné que son nom est entré à partir du clavier;

Afficher la liste de toutes les personnes enregistrées dans la base de
données (nom, numéros de téléphone, adresses).
3. LES EXIGENCES FONCTIONNELLES ET NON FONCTIONNELLES
DE L'APPLICATION
3.1. Exigences fonctionnelles
Notre application se base sur plusieurs exigences fonctionnelles que nous
pouvons décrire dans le tableau ci-dessous :
EF 1.0
Ajouter une personne
EF 5.1
Le système doit demander de saisir des informations sur la personne
EF 5.2
Le système doit enregistrer la personne
EF 5.3
Le système doit attribuer un identifiant à cette personne
EF 2.0
Rechercher une personne
EF 2.1
EF 2.2
Le système doit demander de saisir le nom de la personne à
chercher
Le système doit permettre de vérifier une personne
EF 3.0
Modifier une personne
EF 3.1
Le système doit permettre de modifier une personne
EF 3.2
Le système doit permettre d’enregistrer les nouvelles informations
sur la personne
EF 4.0
Supprimer une personne
EF 4.1
Le système doit permettre de supprimer une personne
EF 4.2
Le système doit demander la confirmation de suppression
EF 5.0
Afficher
EF 5.1
Le système doit permettre d’afficher une personne
EF 5.2
Le système doit permettre d’afficher toute les personnes
Tableau 1. Tableau des exigences fonctionnelles
a. Diagramme de cas d’utilisation
Ci-dessous nous présentons le diagramme de cas d’utilisation pour montrer
l’interaction entre l’utilisateur (gestionnaire de carnet d’adresse) et le système :
Figure 1. Diagramme de cas d’utilisation
Ci-dessous nous présentons le tableau des relations dans le diagramme de
cas d’utilisation :
Type
1.Erreur ! Include
Signet
non
défini.
2.Erreur ! Include
Signet
non
défini.
3.Erreur ! Association
Signet
non
défini.
4.Erreur ! Include
Signet
non
défini.
5.Erreur ! Association
Signet
non
défini.
6.Erreur ! Association
From
To
Afficher une
Rechercher une personne
personne (Use Case) (UseCase)
Modifier une
Rechercher une personne
personne (Use Case) (UseCase)
Gestionnaire (Actor)
Modifier une personne
(UseCase)
Supprimer une
Rechercher une personne
personne (Use Case) (UseCase)
Gestionnaire (Actor)
Afficher toutes les
personnes (UseCase)
Gestionnaire (Actor)
Afficher une personne
Signet
non
défini.
7.Erreur ! Association Gestionnaire (Actor)
Signet
non
défini.
8.Erreur ! Association Gestionnaire (Actor)
Signet
non
défini.
9.Erreur ! Association Gestionnaire (Actor)
Signet
non
défini.
(UseCase)
Supprimer une personne
(UseCase)
Ajouter une personne
(UseCase)
Ajouter une personne
(UseCase)
Tableau 2. Les relations dans le diagramme de cas d’utilisation
3.2. Les exigences non-fonctionnelles de l’application
Ci-dessous nous présentons un tableau qui présente les exigences non
fonctionnelles, leur description et leur numéro d’exigence fonctionnelle
utilisées.
Description
EF utilisée
ENF 1.0 Le taux pour qu’un échec survienne lors Toutes les exigences
d’une opération sur le système doit être
très faible soit 0.0001%
ENF 2.0 Le système doit être disponible durant Toutes les exigences
toutes les opérations
ENF 3.0 En cas de défaillance, le système ne Toutes les exigences
devra pas causer de dommages
matériels
ENF 4.0 En cas d’erreurs venant de l’utilisateur, Toutes les exigences
les données ne doivent subir aucun
changement,
la
disponibilité
des
données doit être garantie.
ENF 5.0 Le système doit avoir au plus 3 Toutes les exigences
secondes comme temps de réponse à
une opération.
Tableau 3. Tableau des exigences non fonctionnelles
4. LA CONCEPTION
4.1. Diagramme de classe
Voici le diagramme de classe de notre application :
Figure 2. Diagramme de classe
4.2. Diagramme de séquence
Dans ce point nous présentons les opérations qui se font sur le système via le
diagramme de séquence :
a. Création d’un contact
Figure 3. Diagramme de séquence pour la création d’un contact
b. Rechercher un contact
Figure 4. Diagramme de séquence pour la recherche d’un contact
c. Modifier un contact
Figure 4. Diagramme de séquence pour la modification d’un contact
d. Supprimer un contact
Figure 5. Diagramme de séquence pour la suppression d’un contact
5. IMPLEMENTATION ET TEST
5.1. Solution technique
a. Le choix de la plate forme de développement
Pour implémenter notre application nous avons utilisé Eclipse IDE, qui est un
environnement de développement intégré libre extensible, universel et polyvalent,
permettant potentiellement de créer des projets de développement mettant en œuvre
n'importe quel langage de programmation.
b. Le choix du langage de programmation
Le langage utilisé pour l’implémentation de cette application est le langage java. Ce
langage complètement orienté objet. Java permet et pousse à développer les
applications d'une façon orientée objet et permet d'avoir une application bien
structurée, modulable, maintenable beaucoup plus facilement et efficace.
c. La base de données
Comme signifié dans les pages précédentes nous avons utilisé SQLite qui est un
formidable moteur de base de données, ne nécessitant pratiquement aucune
administration, portable (tous systèmes) et accessible de pratiquement tous les
langages (C, C++, Java, Python...). Contrairement à mySQL, SQLite ne nécessite
pas la mise en place d'un service.
La structure de notre table est la suivante :
Nom des champs
id
name
Type
INTEGER PRIMARY KEY
TEXT
home_phone
work_phone
TEXT
TEXT
home_address
work_address
TEXT
TEXT
5.2. Le test d’acceptation
Dans cette partie nous soumettons à notre programme un jeu de données pour le
tester. Ces opérations englobent l’ensemble d’opérations qui seront faites par
l’utilisateur (gestionnaire pour notre cas).

Enregistrer un contact
Grace a cette interface l’utilisateur a la possibilité de saisir les informations sur le
contact et les enregistrer.
Signalons aussi que l’utilisateur doit remplir tous les champs obligatoires avant
d’enregistrer. Cette fenêtre montre un exemple ou l’utilisateur click sur enregistrer
sans respecter cette condition :

Rechercher un contact
A partir ce cette interface l’utilisateur écrit une partie ou l’intégralité du nom a
chercher dans son carnet d’adresse :

Sélectionner un contact
6. CONCLUSION
Dans ce document nous présentons le logiciel que nous avons réalisé. Ce
programme permet de gérer un carnet d’adresse. Pour la partie modélisation nous
avons utilisé UML. Les opérations, dans ce petit logiciel, sont faites en interaction
avec sqlite3. Pour tester le bon fonctionnement des méthodes nous avons utilisé
JUnit. Ce programme marche très bien et répond aux exigences décrites dans le
cahier de charge.
Cependant, ce programme peut être amélioré dans l’avenir pour permettre la prise
en charge par exemple de plus de deux numéros de téléphone et deux adresses
pour un contact enregistré dans le système, la prise en charge des groupes ou
catégorie des contacts.
7. EXTRAIT DU CODE SOURCE
Dans ce point nous présentons un extrait du code source de l’application
/**
* get connection to sqlite database
* @return connection
*/
private Connection getConnection(){
Connection connection = null;
try {
Class.forName(SQLITE_DRIVER);
connection = DriverManager.getConnection(DB_NAME);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return null;
} catch (SQLException e) {
e.printStackTrace();
return null;
}
return connection;
}
/**
* delete a person
* delete a person from database and from model data
* @param id of person
* @param index
* @return boolean
*/
public boolean delete(int id, int index){
Connection connection = getConnection();
if(connection == null){
//error handle
return false;
}
PreparedStatement preparedStatement;
try {
preparedStatement = connection.prepareStatement( "DELETE FROM " +
"person WHERE id = ?");
preparedStatement.setInt(1, id);
preparedStatement.execute();
preparedStatement.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
}finally{
try {
connection.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//remove this person from model data
persons.remove(index);
//update jtable UI
fireTableRowsDeleted(index, index);
//fireTableDataChanged();
return true;
}
/**
* update information for a person
* @param person
* @param index : index of person in model data
* @return boolean
*/
public boolean update(Person person, int index){
Connection connection = getConnection();
if(connection == null){
//error handle
return false;
}
PreparedStatement preparedStatement;
try {
preparedStatement = connection.prepareStatement( "UPDATE " +
"person set name = ?, home_phone = ? , work_phone = ?, home_address =
?, work_address = ?" +
" WHERE id = ?");
preparedStatement.setString(1, person.getName());
preparedStatement.setString(2, person.getHomePhone());
preparedStatement.setString(3, person.getWorkPhone());
preparedStatement.setString(4, person.getHomeAddress());
preparedStatement.setString(5, person.getWorkAddress());
preparedStatement.setInt(6, person.getId());
preparedStatement.execute();
preparedStatement.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
}finally{
try {
connection.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//update model data
persons.set(index, person);
//update jtable UI
fireTableRowsUpdated(index, index);
//fireTableDataChanged();
return true;
}
public boolean insert(Person person){
if (person == null){
return false;
}
Connection connection = getConnection();
if(connection == null){
//error handle
return false;
}
PreparedStatement preparedStatement;
try {
preparedStatement = connection.prepareStatement( "INSERT INTO " +
"person(name, home_phone, work_phone, home_address, work_address)"
+
"VALUES (?, ?, ?, ?, ?)");
preparedStatement.setString(1, person.getName());
preparedStatement.setString(2, person.getHomePhone());
preparedStatement.setString(3, person.getWorkPhone());
preparedStatement.setString(4, person.getHomeAddress());
preparedStatement.setString(5, person.getWorkAddress());
preparedStatement.execute();
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
return false;
}finally{
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
persons.add(person);
fireTableRowsInserted(persons.size() - 1, persons.size() - 1);
//fireTableDataChanged();
return true;
}
/**
* get a list of Person, if searchName is empty, return all
* if searchName is not empty, return all the persons whose name contains searchName
* @param searchName
* @return list of Person
*/
public List<Person> getPersons(String searchName){
List<Person> persons= new ArrayList<Person>();
Connection connection = getConnection();
if(connection == null){
//error handle
return null;
}
PreparedStatement preparedStatement;
try {
String sql = "SELECT * FROM person ";
if(!searchName.isEmpty()){
sql += " WHERE name like '%" + searchName + "%'";
}
preparedStatement = connection.prepareStatement(sql);
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
int id = resultSet.getInt("id");
System.out.println(id);
String name = resultSet.getString("name");
String homePhone = resultSet.getString("home_phone");
String workPhone = resultSet.getString("work_phone");
String homeAddress = resultSet.getString("home_address");
String workAddress = resultSet.getString("work_address");
Person person = new Person(name, homePhone, workPhone, homeAddress,
workAddress);
person.setId(id);
persons.add(person);
}
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
return null;
}finally{
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
return persons;
}