TP 15 - Objis

CAHIER DE TRAVAUX PRATIQUES
OB300
1/43
Sommaire
TP 01 - Installation de la JDK.
TP 02 - Ecriture d’une première classe java.
3
6
TP 03 – Installation d’Eclipse et création d’un premier projet.
8
TP 04 – La Javadoc.
TP 05 – Le packaging avec Jar
TP 06 – Implémentation d’un modèle UML
TP 07 – Mise en œuvre de l’héritage
TP 08 – Mise en œuvre de la surcharge, redéfinition et polymorphisme
TP 09 – Interface
TP 10 – JDBC
TP 11 – Collection
TP 12 – JUnit
TP 13 – Internationalisation
TP 14 – Entrée / Sortie
TP 15 – Swing
TP 16 – Log4J
13
16
19
20
21
24
26
33
35
38
39
41
43
2/43
TP 01 - Installation de la JDK
Installation de la JDK.
1. Lancer l’installateur de la JDK depuis le CD (D:\logiciels\runtime\j2sdk-1_4_2_10-windowsi586-p.exe) et suivre les étapes proposée
3/43
2. A l’issue de l’installation deux répertoires ont été créés :
•
•
C:\j2sdk1.4.2_10 : constitue le répertoire de la JDK
C:\Program Files\Java\j2re1.4.2_10 : constitue le répertoire de la JRE
Installation de la documentation de la JDK.
1. Dézipper l’archive de la documentation de la JDK du CD (D:\logiciels\runtime\ j2sdk-1_4_2doc.zip) vers le repertoire “C:\j2sdk1.4.2_10\docs”.
2. Deux entrées principales sont à connaitre :
•
C:\j2sdk1.4.2_10\docs\index.html.
Ce lien donne accès à l’ensemble de la documentation SUN.
4/43
•
C:\j2sdk1.4.2_10\docs\api\index.html
Ce lien donne accès à la description de l’ensemble des classes java.
3. Positionner la variable d’environnement JAVA_HOME à “C:\j2sdk1.4.2_10”
4. Enrichir la variable d’environnement PATH avec %JAVA_HOME%\bin afin de rendre
accessible les outils de la JDK à n’importe quel endroit de l’arborescence.
5. Vérifier l’installation en lançant la commande java –version
Cette commande doit retourner la version du JDK installée sur votre machine.
Résultat attendu : java version "1.4.2_10"
5/43
TP 02 - Ecriture d’une première classe java
Création de la classe LanceurHelloWorld.
1. A l’aide d’un éditeur de texte écrire la classe Java LanceurHelloWorld suivante et l’enregistrer
dans le fichier LanceurHelloWorld.java sous le répertoire “C:\ProjetsOB300” :
public class LanceurHelloWorld {
public static void main(String[] args) {
System.out.println("Bonjour ! ");
}
}
2. Se positionner dans le répertoire “C:\ProjetsOB300” et compiler le fichier
LanceurHelloWorld.java via la commande “javac LanceurHelloWorld.java”
3. Vérifier la présence du byte code associé : LanceurHelloWorld.class
4. Lancer le programme principal via la commande “java LanceurHelloWorld”
5. Vérifier l’affichage du résultat suivant : Bonjour !
Prise en compte des arguments de la ligne de commande.
1. Modifier le corps du main de la classe LanceurHelloWorld comme suit afin de gérer les
arguments de la ligne de commande et manipuler les commentaires.
public class LanceurHelloWorld {
/* La méthode main est statique.
Ce qui signifie qu'elle est chargée en mémoire au démarrage
de l'application et peut donc être utilisée avant la création de tout objet.
*/
public static void main(String[] args) {
//Affichage de l’argument saisi sur la ligne de commande
System.out.println("Bonjour Monsieur " + args[0]);
}
}
2. Répéter les étapes 2. et 3. précédentes.
3. Lancer le programme principal via la commande “java LanceurHelloWorld arg1” (avec
arg1=Smith par exemple)
4. Vérifier l’affichage du résultat suivant : Bonjour Monsieur Smith.
6/43
Création d’une archive java (fichier jar). (optionnel)
1. Se positionner dans le répertoire “C:\ProjetsOB300”
2. Constituer un jar contenant le bytecode de la classe LanceurHelloWorld via la commande
“jar cvf hello.jar LanceurHelloWorld.class”
3. Relire le contenu de ce jar via la commande “jar tvf hello.jar”
Remarques :
•
L’utilitaire jar de constitution d’un jar à rajouté le fichier META-INF/MANIFEST.MF
•
Ce jar constitue une unité de livraison, pouvant être incorporé dans le CLASSPATH de
la compilation et d’exécution d’un autre projet.
Création d’une archive java exécutable. (optionnel)
1. Dans le répertoire de “C:\ProjetsOB300”, créer un fichier texte nommé
manifesteHelloWorld.txt
2. Le modifier pour qu’il indique quelle est porteuse de la méthode main
Manifest-Version: 1.0
Main-Class: LanceurHelloWorld
Remarque :
•
Ce fichier doit se terminer par un retour à la ligne après ‘LanceurHelloWorld’, sinon
cette ligne ne sera pas analysée.
3. Renommer manifesteHelloWorld.txt en manifesteHelloWorld.mf.
4. Créer un jar comprenant LanceurHelloWorld.class et le fichier manifeste
manifesteHelloWorld.mf via la commande
“jar cmf manifesteHelloWorld.mf hello.jar LanceurHelloWorld.class”
5. Exécuter le jar hello.jar via la commande “java –jar hello.jar Smith”
6. Vérifier l’affichage du résultat suivant : Bonjour Monsieur Smith.
7/43
TP 03 – Installation d’Eclipse et création d’un premier projet
Installation d’éclipse
1. Dézipper l’archive “Eclipse 3.1-sdk-1.0-win32.zip” du CD vers le répertoire “C:\Program Files”.
2. Eclipse est installé à l’issue de la décompression.
3. Pour le démarrer lancer “C:\Program Files\eclipse311\eclipse\eclipse.exe” (Se créer un
raccourci sur le bureau).
Création d’un projet sous Eclipse
1. Sélectionner dans eclipse les menus suivants : File > New > Project
2. Choisir Java Project, puis Next
8/43
3. Donner le nom GestionConges à votre projet.
4. Cocher “Create separate source and output folders” pour séparer les sources du byte code,
puis Next.
5. Finish
9/43
Création d’un package
1. ClicK droit sur le dossier src su projet
2. New > Package
3. Nommer le package lanceur
10/43
Création d’une classe
4. Click droit sur le package lanceur dans lequel ajouter la classe
5. New > Class
6. Nommer la classe LanceurHelloWorld
7. Cocher la case “public static void main…” pour générer automatiquement le squelette de la
méthode main
11/43
8. Coder l’exemple suivant :
public static void main(String[] args) {
System.out.println("Hello World !");
}
Configuration d’exécution
1. Click droit sur la classe LanceurHelloWorld
2. Obtention du message suivant dans la console.
12/43
TP 04 – La Javadoc
Rédaction des commentaires javadoc
Les commentaires de la javadoc s’écrivent entre les balises /** … */
La javadoc prend en compte les balises html et différents tags (@author, @param, @return…)
que l’on peut visualiser avec ctrl + espace quand le curseur est entre les balises javadoc.
La javadoc est importante car elle permet de générer la documentation des classes, méthodes
et packages de l’application. Il faut la rédiger au moment de la création des classes
1. Positionner des commentaires javadoc
Génération de la javadoc
1. Sélectionner le projet en cours et aller dans le menu ”Project > Generate Javadoc”
2. Sélectionner la visibilité Private, afin de créer la documentation de toutes les classes de
l’application.
13/43
1. Sélectionner la librairie rt.jar qui représente l’API principale de java.
Cela permet de créer un lien vers les classes de cette API qui sont utilisées dans le projet
(toutes les classes héritent implicitement de la classe de base java.lang.Object)
14/43
1. Cocher Save the settings of this Javadoc export as an Ant script
Cela permet d’enregistrer la configuration de génération de la javadoc dans un script Ant.
Pour regénérer ultérieurement la javadoc, il suffira d’exécuter ce script (Clic droit sur le script
javadoc.xml > Run > Ant Build
2. Cocher la case Open generated index file in browser pour visualiser la doc générée.
15/43
TP 05 – Le packaging avec Jar
Création d’un composant : Packager l’application en JAR
1. Créer un dossier META-INF à la racine du projet.
Ce dossier contient les fichiers de description des composants
2. Click droit sur le projet
3. Exporter…
4. Sélectionner le projet pour lequel vous souhaiter générer la documentation javadoc
16/43
Remarque :
Le fichier jardesc permet de sauvegarder la configuration de création du JAR.
•
•
Pour recompiler l’archive JAR, il suffit ensuite de faire un clic droit sur le fichier et
sélectionner Create JAR.
Pour modifier la configuration, un clic droit sur le fichier et sélectionner Open JAR
Packager
5. Générer le fichier MANIFEST.MF qui contiendra le chemin vers la classe de démarrage
6. Sélectionner la classe de démarrage LanceurHelloWorld
17/43
Exécution du composant
7. Ouvrir un invite de commande DOS
8. Se placer dans le dossier du composant JAR
9. Exécuter le composant : java –jar gestionConges.jar
10. Obtention du résultat : Hello World !
18/43
TP 06 – Implémentation d’un modèle UML
Objectif :
•
•
•
•
Implémenter un diagramme de classes UML
Construire une classe avec ses attributs, son constructeur et ses méthodes
Utiliser les getters er setters
Manipuler les instances d’objets créées
1. Implémenter le diagramme de classes UML suivant :
Remarques :
•
Créer le package domaine afin d’y décliner les classes métiers
•
La génération des getters et des setters se fera automatiquement via l’assistant
eclipse : Click droit dans le code source > source > Generate Getters and Setters
•
En ce qui concerne le corps des différentes méthodes, se contenter pour le
moment d’une trace à l’écran :
Exemple pour la classe Employe :
public void poserConge(String dateDebut, String dateFin) {
System.out.println("Monsieur " + prenom + " " + nom +
" pose un conge du " + dateDebut + " au " + dateFin);
}
2. Créer le package lanceur.
3. Ecrire dans ce package la classe LanceurGestionConges (Classe comportant un Main) afin
d’instancier un Manager et deux Employes.
4. Tester l’invocation des différentes méthodes sur les différentes instances d’ Employe et de
Manager.
Remarque :
•
Nous substituerons ce lanceur par la suite par l’implémentation d’une classe de
test unitaire via JUnit.
19/43
TP 07 – Mise en œuvre de l’héritage
Objectif :
•
•
•
Modifier l’implémentation du diagramme de classes UML
Mise en œuvre de l’héritage
Manipuler les instances d’objets créées
1. Modifier l’implémentation du diagramme de classes UML suivant :
Remarques :
•
L’héritage à permis de factoriser des attributs communs (id, nom et prénom) et
une méthode commune (poserConge).
2. Les attributs id, nom et prénom de la classe Manager sont hérités de la classe Employe.
Ces attributs étant privés au niveau de la classe Employe, vous devez constater que leur
utilisation en direct pose un problème de compilation.
Utiliser les accesseurs publics associés pour y accéder.
3. Tester le lanceur LanceurGestionConges. Vous devez obtenir le même résultat que lors du
TP précédent.
4. Que faudrait-il faire pour pouvoir accéder en direct à ces attributs ?
5. Tester à nouveau en ayant modifié la visibilité (private, public, protected) des attributs de
la classe Employe.
6. Le constructeur de Manager doit à ce stade du développement contenir des appels aux
setters des différents attributs privés.
Modifier le constructeur de Manager afin qu’il invoque son constructeur ancêtre (celui d’
Employe) via le mot clef java super. Ceci constitue une bonne façon de faire en matière
de construction d’objets.
public Manager (String pNom, String pPrenom, int pId){
super(pNom, pPrenom, pId);
}
20/43
TP 08 – Mise en œuvre de la surcharge, redéfinition et
polymorphisme
Objectif :
•
•
•
Modifier l’implémentation du diagramme de classes UML
Mise en œuvre de la surcharge,
Mise en œuvre de la redéfinition et du polymorphisme
1. implémentation du diagramme de classes UML suivant :
Remarque :
•
Les attributs soulignés de la classe DemandeConges, correspondent à des
attributs static. Pour mémoire, ces attributs sont accessibles en dehors de toute
instanciation.
public final static String REFUS = "refus";
public final static String ACCORDE = "valide";
public final static String ATTENTE = "en attente";
2. La surcharge d'une méthode ou d’un constructeur permet de définir plusieurs fois une
même méthode/constructeur avec des arguments différents. Le compilateur choisi la
méthode qui doit être appelée en fonction du nombre et du type des arguments. Ceci
permet de simplifier l'interface des classes vis à vis des autres classes.
21/43
Surcharger les constructeurs de Employe, Manager et DemandeConges via le mot clef
java this
Exemple 1 :
public Manager (String pNom, String pPrenom, int pId){
super(pNom, pPrenom, pId);
}
public Manager (String pNom, String pPrenom){
this(pNom, pPrenom, 0);
}
public Manager (String pNom){
this(pNom, « Richard », 0);
}
public Manager (){
this(« durant », « Richard », 0);
}
Exemple 2 :
public DemandeConges(String pDateDebut, String pDateFin, String pEtatValidation) {
dateDebut
= pDateDebut;
dateFin
= pDateFin;
etatValidation = pEetatValidation;
}
public DemandeConges(String pDateDebut, String pDateFin){
this(pDateDebut, pDateFin, DemandeConges.ATTENTE);
}
3. La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de
la méthode parent (type et nombre de paramètres, la valeur de retour et les exceptions
propagées doivent être identique).
Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge.
Cette nouvelle méthode n'est pas héritée : la classe mère ne possède pas de méthode
possédant cette signature.
la redéfinition de la méthode poserConges dans la classe Manager exprime le fait que le
savoir faire métier est différent dans les deux classes :
•
•
La méthode poserConge() pour l’employé déclenche une demande avec une
attente de validation.
La méthode poserConge() pour le manager déclenche une demande qui est
automatiquement validée.
4. Redéfinir la méthode poserConger() de la classe Manager.
Exemple :
public void poserConge(String dateDebut, String dateFin) {
System.out.println("Monsieur " + getPrenom() + " " + getNom() +
" pose un conge du " + dateDebut + " au " + dateFin);
System.out.println("Etant manager, il valide ses propres conges");
}
22/43
Remarque :
On constate qu’une partie du code de poserConge() est identique dans les deux
classes Employe et Manager.
Pour éviter la duplication de code, une bonne façon de faire est la suivante :
public void poserConge(String dateDebut, String dateFin) {
super.poserConge(dateDebut, dateFin) ;
System.out.println("Etant manager, il valide ses propres conges");
}
5. Redéfinir la méthode toString() héritée de la super classe Object, afin de tracer les
caractéristiques d’un objet :
Exemple :
public String toString(){
return "Employe : " + id + ", " + prenom + ", " + nom ;
}
Remarque :
La méthode toString() est automatiquement invoquée lorsque l’on souhaite tracer un
objet.
Exemple :
Employe emp = new Employe("Smith" , " John", 2) ;
System.out.println(emp) ;
Renverra la chaîne : Employe : 2, John, Smith ;
Par défaut la méthode toString() retourne le nom de la classe d’instanciation de l’objet
suivi de sa référence.
6. Modifier le lanceur LanceurGestionConges afin de :
•
•
procéder à différentes instanciations (différents constructeurs)
tracer l’état des objets.
7. Tester le lanceur LanceurGestionConges et vérifier la redéfinition de la méthode
poserConge
23/43
TP 09 – Interface
Objectif :
•
•
•
Modifier l’implémentation du diagramme de classes UML
Création d’une interface IPersonnel
Manipulation des objets Employe et Manager par le biais de leur interface IPersonnel
On considère un acteur tiers, la classe ServicePaie, qui doit récupérer la liste de tout le personnel
à la fin de chaque mois afin d’établir les feuilles de paie de chacun.
Cet acteur considère tout type de Personnel (Employe et Manager). Il ne manipule que la méthode
consulterConges() de chacun des membres du personnel.
En conséquence, pour des raisons de sécurité, cet acteur n’a pas accès aux accesseurs des classes
Employe et Manager, ni à la méthode validerConge() de la classe Manager
1. implémentation du diagramme de classes UML suivant :
Remarque :
•
Le type Collection sera vu prochainement dans le chapitre ad hoc.
2. Créer l’interface IPersonnel dans le package domaine ayant à son contrat de service la
méthode consulterConges().
public Collection consulterConges();
Cette méthode permet de consulter les congés posés par un Employé ou par un Manager.
L’idée est que cette interface puisse être utilisée par une classe tiers ServicePaie que vous
allez implémenter.
24/43
3. Faire en sorte que la classe Employe implémente l’interface IPersonnel
Remarque :
La classe Manager, héritant de la classe Employe, est vue également de façon
implicite comme une implémentation de l’ interface IPersonnel.
L’ idée est donc qu’un objet Employe ou Manager puisse être manipulé par le biais de
son interface IPersonnel.
4. Redéfinir la méthode consulterConges()
Exemple :
public Collection consulterConges() {
System.out.println("Consultation des conges de " + prenom + " " + nom);
return null;
}
5. Créer la classe ServicePaie dans le package domaine.
Cette classe possède le savoir faire métier listerCongePersonnel
public void listerCongePersonnel(IPersonnel personnel){
personnel.consulterConges();
}
Cette méthode demande l’affichage des congés d’un membre du personnel.
6. Modifier le lanceur LanceurGestionConges afin de :
•
•
Créer une instance de ServicePaie.
Invoquer sur cette instance la méthode listerCongePersonnel en lui passant
successivement une instance d’ Employe et de Manager
7. Tester le lanceur LanceurGestionConges et vérifier le comportement.
Remarque :
Dans une application réelle, on pourra concevoir que l’ instance de ServicePaie obtient la
liste de tout le personnel à partir d’une base de données et invoque de façon itérative la
méthode listerCongePersonnel.
25/43
TP 10 – JDBC
Installation de mySQL
Installer mySQL par le biais de WAMP (Window Apache MySQL PHP).
1. Lancer l’installation de WAMP depuis l’exécutable « wamp5_1.4.4.exe » fourni sur le CD
(D:\logiciels\outils)
26/43
Démarrer les services
Démarrer PhpMyAdmin pour l’administration de la base MySQL
Création de la base de données formation
1. Saisir formation comme nom de base de données
2. Appuyer sur le bouton créer
27/43
3. Dans l’onglet SQL, zone « Emplacement du fichier texte » partir à la recherche du
script de création des tables formation.sql fourni sur le CD (D:\ distribution\Mysql)
Ajouter les pilotes de connectivité au SGBDR
Pour se connecter à une base de données, il faut utiliser des pilotes de connectivité fournis
par l’éditeur. Nous allons utiliser les pilotes Mysql.
1. Retourner sous Eclipse
2. Ajouter les pilotes dans le projet
a. Créer un dossier lib dans le projet
b. Importer le composant mysql-connector-java-3.1.7-bin.jar
i. Clic droit sur le dossier lib
ii. Importer…
iii. File System
28/43
3. Ajouter la librairie mySQL au classpath du projet
a. Click droit sur le projet
b. Propriétés
c. Sélectionner la catégorie Java Build Path
d. Onglet Librairies
e. Add JARs
29/43
Implémentation métier
1. implémentation du diagramme de classes UML suivant :
Remarque :
•
Rajout d’une méthode poserConge dans les classes Employe et Manager
acceptant en argument une demande de congés.
2. Implémenter la méthode consulterConges() afin d’aller rechercher en base tous les
congés posés par un membre du personnel identifié par son ID_employe.
"SELECT dateDebut, dateFin, etat FROM conges WHERE ID_employe='"+ id +"'"
Référez-vous au cours pour reprendre le squelette JDBC à mettre en œuvre.
Dans le parcours du recordSet se contenter pour le moment de mettre à jour et
d’afficher une instance de DemandeConges avec les dateDebut, dateFin et etat
récupérés de la base de données.
Exemple :
DemandeConges demande = new DemandeConges();
while(rs.next()){
demande.setDateDebut(rs.getString("dateDebut"));
demande.setDateFin(rs.getString("dateFin"));
demande.setEtatValidation(rs.getString("etat"));
System.out.println(demande);
}
30/43
3. Tester la méthode consulterConges() via le LanceurGestionConges sur les instances
suivantes :
Employe emp1 = new Employe("Watson", "John", 1);
Manager manager = new Manager("Homes", "Sherlock", 2);
Vous devriez obtenir un résultat similaire à celui-ci :
Consultation des conges de John Watson
DemandeConges : 2005-03-04, 2005-03-08, refus
DemandeConges : 2005-06-06, 2005-06-17, valide
DemandeConges : 2005-08-08, 2005-08-19, en attente
Consultation des conges de Sherlock Homes
DemandeConges : 2005-09-10, 2005-09-25, en attente
DemandeConges : 2005-07-01, 2005-07-15, valide
4. (Optionnel) Implémenter la méthode poserConge() afin qu’un Manager ou un
Employe puisse insérer une demande de congés en base.
Pour les opérations d’insertion, suppression et mise à jour d’un enregistrement en
base, utiliser la méthode executeUpdate de l’objet Statement
Statement st = null;
st = cn.createStatement();
int nb = st.executeUpdate(<requete SQL>) ;
avec requête SQL :
insert into conges (ID_employe, dateDebut, dateFin, etat) values (" + id + ", '" +
demande.getDateDebut() + "', '" +
demande.getDateFin() + "', '" +
demande.getEtatValidation() + ');"
Remarques :
•
L’implémentation de la méthode validerConge() du Manager se fera dans le
TP sur les Collections
•
Cette façon de coder n’est pas une bonne pratique, car nous melons à des
objets métiers des appels techniques vers une solution de persistance (Base de
données mySQL dans notre cas).
Si nous souhaitons évoluer vers une base Oracle, il faudrait adapter le code
partout ou cela est nécessaire.
Une bonne façon de faire serait de créer une couche d’abstraction intermédiaire
permettant de dissocier la couche métier de la couche technique.
Cela pourrait être fait par le biais d’une Factory et de DAO (Data Access
Object).
31/43
•
Enfin, nous constatons que chaque méthode procède à l’ouverture d’une
connexion à la base de données et à sa fermeture, opérations coûteuses.
Une bonne pratique dans ce cas serait de gérer des pools de connexions.
5. Tester la méthode poserConges() via le LanceurGestionConges sur les instances suivantes :
Employe emp1 = new Employe("Watson", "John", 1);
Manager manager = new Manager("Homes", "Sherlock", 2);
DemandeConges cg1 = new DemandeConges("2006-01-02", "2006-01-04");
DemandeConges cg2 = new DemandeConges("2006-09-09", "2006-09-14");
emp1.poserConge(cg1);
manager.poserConge(cg2);
6. Obtention des résultats suivants :
32/43
TP 11 – Collection
Objectif :
•
Manipuler les collections (insertion, parcours).
1. implémentation du diagramme de classes UML suivant :
Remarques :
•
•
Rajout d’un attribut listeEmployes de type Collection dans la classe Manager et de
ses accesseurs associés.
Ajout de la méthode fonctionnelle ajouterEmploye() dans la classe Manager.
2. Modifier la méthode consulterConges de la classe Employe afin de retourner une collection de
DemandeConges
Rappel : à ce stade du TP, la méthode se contente d’afficher les congés et de retourner null.
Collection col = new ArrayList();
….
//Ajout de la demande dans la collection à retourner
col.add(demande);
3. Tester la récupération de la Collection retournée par méthode consulterConges() via le
LanceurGestionConges.
4. (Optionnel) Implémenter la méthode ajouterEmploye (Employe e) de la classe Manager.
Cette méthode ajoute l’employé e passé en argument à la Collection listeEmploye.
public void ajouterEmploye (Employe e) {
listeEmployes.add(e);
}
33/43
5. (Optionnel) Implémenter la méthode validerConge() de la classe Manager.
Pour toutes les instances d’employés présentes dans la Collection listeEmployes, procéder à la
mise à jour de l’état des demandes de congés à «valide ».
"UPDATE conges SET etat='" + DemandeConges.ACCORDE + "' WHERE etat='" +
DemandeConges.ATTENTE + "' and ID_employe=" + emp.getId()+ ";"
6. (Optionnel) Tester la méthode validerConge () via le LanceurGestionConges sur les
instances suivantes :
Employe emp1 = new Employe("Watson", "John", 1);
Manager manager = new Manager("Homes", "Sherlock", 2);
Penser à rattacher emp1 à manager :
manager.ajouterEmploye(emp1);
7. (Optionnel) Obtention des résultats suivants :
Tous les congés de l’ ID_employe = 1 sont à valides.
34/43
TP 12 – JUnit
Le framework Junit permet d’automatiser des séquences de tests afin de vérifier la non
régression d’une application.
1. Créer un package services.test
2. Ajouter le test JUnit
a. Click droit sur le pakage test
b. New > Junit Test Case
c. Sélectionner les options comme indiqué ci-dessous.
d. Sélectionner la méthode listerCongePersonnel .
35/43
e. Génération de la classe de test suivante :
package services.test;
import junit.framework.TestCase;
public class TestServicePaie extends TestCase {
public static void main(String[] args) {
junit.textui.TestRunner.run(TestServicePaie.class);
}
/*
* Test method for 'domaine.ServicePaie.listerCongePersonnel(IPersonnel)'
*/
public void testListerCongePersonnel() {
}
}
3. Ecriture du test testListerCongePersonnel
Reprendre en partie le contenu du main du LanceurGestionConges
Exemple :
ServicePaie paie = new ServicePaie();
Employe emp1 = new Employe("Watson", "John", 1);
paie.listerCongePersonnel(emp1);
Manager manager = new Manager("Homes", "Sherlock", 2);
paie.listerCongePersonnel(manager);
Penser à appeler une méthode assertxxx, pour tester le retour escompté de la méthode.
4. Tester la classe JUnit TestServicePaie
Click droit sur la classe > Run as > JUnit Test
5. Ecrire une nouvelle classe de test unitaire JUnit TestEmploye.
Sélectionner la méthode consulterConges .
36/43
6. Génération de la classe de test suivante.
package com.services;
import junit.framework.TestCase;
public class TestEmploye extends TestCase {
public static void main(String[] args) {
junit.swingui.TestRunner.run(TestEmploye.class);
}
/*
* Test method for 'com.domaine.Employe.consulterConges()'
*/
public void testConsulterConges() {
}
}
7. Ecriture du test testConsulterConges
Exemple :
Collection listeConges;
Employe emp1 = new Employe("Watson", "John", 1);
listeConges = emp1.consulterConges();
assertTrue(listeConges.size() > 0);
Employe emp2 = new Employe("Duval", "Robert", 6);
listeConges = emp2.consulterConges();
assertFalse(listeConges.size() > 0);
Manager manager = new Manager("Homes", "Sherlock", 2);
listeConges = manager.consulterConges();
assertTrue(listeConges.size() > 0);
8. Tester la classe JUnit TestEmploye
37/43
TP 13 – Internationalisation
Objectif :
•
Externaliser au sein d’un fichier de propriétés les paramètres de connexion à la base de
données MySQL.
1. Créer le package domaine.properties
2. Créer le fichier de propriétés config.properties avec les données suivantes
########## Configuration accès SGBD ##########
sgbd.driver=com.mysql.jdbc.Driver
sgbd.login=root
sgbd.password=
3. Modifier la méthode consulterConges de la classe Employe afin de rechercher les éléments de
connexion à la base de données dans le fichier config.properties
Exemple :
ResourceBundle bundle = ResourceBundle.getBundle("domaine.properties.config");
String driver = bundle.getString("sgbd.driver");
String mysqlUser = bundle.getString("sgbd.login");
String mysqlPassword=bundle.getString("sgbd.password");
38/43
TP 14 – Entrée / Sortie
Objectif :
•
Exporter la liste des congés vers un fichier texte.
1. implémentation du diagramme de classes UML suivant :
Remarque :
•
Rajout de la méthode exporterConges dans la classe ServicePaie.
2. Ecrire la méthode exporterConges dans la classe ServicePaie afin d’exporter la liste des
congés d’un membre du personnel vers le fichier texte exportConges.txt
Indications :
•
Récupérer la liste des congés sous forme de Collection en invoquant la méthode
consulterConges sur le paramètre de type IPersonnel (Cf. diagramme UML)
•
Utiliser la classe File pour obtenir une représentation java d’un fichier texte.
•
Utiliser la classe FileWriter pour écrire dans ce fichier texte.
7. Tester la méthode exporterConges () via le LanceurGestionConges sur les instances
suivantes :
ServicePaie paie = new ServicePaie();
Employe emp1 = new Employe("Watson", "John", 1);
paie.exporterConges(emp1);
39/43
TP 15 – Swing
Objectif :
•
Création d’une IHM swing avec implémentation du modèle événementiel.
•
Implémentation du diagramme de classes UML suivant :
Création de la fenêtre principale
1. Créer un conteneur de type JFrame nommé ClickJFrame dans le package
presentation.swing
Ce conteneur supportera l’affichage d’un bouton (JBouton), d’une case à cocher
(JCheckbox) et d’un label (JLabel) (Cf. copie d’écran ci-dessus)
2. Ecrire un constructeur ClickJFrame se chargeant de la construction graphique comme
indiqué précédemment.
3. Attacher aux objets graphiques générateur d’événements (bouton et checkbox) un
gestionnaire d’événement nommé ClickListener de type ActionListener (Cf. point suivant)
40/43
Création du gestionnaire d’ événements
1. Ecrire la classe ClickListener implémentant l’interface ActionListener.
2. Ce gestionnaire d’événement va récupérer l’origine de l’événement (bouton/checbox)
dans la méthode actionPerformed et déclencher le traitement ad hoc :
•
•
Si le bouton à été clické, modifier le label pour afficher le message : « click
bouton »
Si la checkbox à été clickée, modifier le label pour afficher le message : « click
checkbox »
3. Prévoir également un constructeur de ClickListener conservant une référence vers les
objets graphiques (bouton, checkbox et label).
Création du lanceur de la fenêtre principale
1. Créer une classe LanceurSwing le package lanceur
public static void main(String[] args) {
//Création de la fenêtre de login
ClickJFrame fenetreLogin = new ClickJFrame();
fenetreLogin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Affichage de l'objet sur l'écran
fenetreLogin.setVisible(true);
}
Remarques :
•
Le fait d’instancier un ClickJFrame provoque automatiquement l’affichage du
conteneur swing associé.
•
La méthode setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE) permet de
terminer l’application lorsque l’on clique sur l’icone
l’IHM disparait mais le processus continue de tourner.
de l’IHM. Autrement
2. Tester le LanceurSwing.
41/43
TP 16 – Log4J
Objectif :
•
Utilisation de l’API Log4J.
Installation de log4J
1. Ajouter les pilotes dans le projet
a. Importer le composant log4j-1.2.11.jar
i. Click droit sur le dossier lib
ii. Importer…
iii. File System
2. Ajouter la librairie log4J au classpath du projet
b. Click droit sur le projet
c. Propriétés
d. Sélectionner la catégorie Java Build Path
e. Onglet Librairies
f. Add JARs
42/43
Implémentation de log4J
1. Récupérer le fichier log4j.xml fourni sur le CD (D:\distribution\Log4j) et le recopier à la
racine du projet GestionConges.
Ce fichier est configuré pour tracer les messages sur la console.
2. Modifier la classe Employe et rajouter des log4J dans l’ensemble des méthodes.
Indications :
•
Créer un logger statique au niveau de la classe Employe
static Logger myLogger = Logger.getLogger(Employe.class);
•
Charger, dans le constructeur de la classe Employe, la configuration Log4J
paramétrée dans le fichier log4j.xml via un DOMConfigurator.
3. Tester la génération des log sur la ConsoleAppender via le LanceurGestionConges .
4. Modifier le fichier log4j.xml pour pouvoir tracer dans un HTMLAppender
5. Tester la génération des log sur le ConsoleAppender et la HTMLAppender via le
LanceurGestionConges
43/43