Sie sind auf Seite 1von 40

Université IBN Zohr

ENSA – AGADIR
Année universitaire
2009 – 2010
Master 2 GLRI

Cours JEE
Préparé par M. Mounir NAJAHI

1
Table des matières
TABLE DES MATIERES ................................................................................................................................................2
INTRODUCTION GENERALE .....................................................................................................................................4
I. DESIGN PATTERNS ...............................................................................................................................................5
1. PATTERN (EN FRANÇAIS MODELE)............................................................................................................................5
2. DESIGN PATTERN (MOTIFS OU MODELES DE CONCEPTION).......................................................................................5
3. COMMENT UTILISER LES DESIGN PATTERNS ............................................................................................................5
4. EXEMPLES................................................................................................................................................................6
a. Singleton: ..........................................................................................................................................................................6
b. Design Pattern Dao: ..........................................................................................................................................................7
c. MVC & MVC2 .................................................................................................................................................................8
• Principe .............................................................................................................................................................................8
• Cinématique ......................................................................................................................................................................9
• MVC model 2....................................................................................................................................................................9
• Dans la pratique.................................................................................................................................................................9
• Conclusion ......................................................................................................................................................................10
II. ARCHITECTURE 3 TIERS ..............................................................................................................................11
1. COUCHE PRESENTATION ........................................................................................................................................11
2. COUCHE METIER: ...................................................................................................................................................11
3. COUCHE PRESENTATION : ......................................................................................................................................12
III. TESTS UNITAIRES AVEC JUNIT ..................................................................................................................13
1. INTRODUCTION ......................................................................................................................................................13
2. ECRIRE LES TESTS UNITAIRES AVEC JUNIT.............................................................................................................13
3. EXEMPLE: ..............................................................................................................................................................14
4. QUELQUES REGLES DE BONNE CONDUITE AVEC JUNIT:..........................................................................................15
IV. ANT ......................................................................................................................................................................16
1. INTRODUCTION ......................................................................................................................................................16
2. FICHIER DE CONFIGURATION XML DE ANT ...........................................................................................................16
3. INSTALLATION DE ANT ..........................................................................................................................................16
4. EXECUTION DE ANT PAR LIGNE DE COMMANDE .....................................................................................................17
• Liste des principales options de Ant..................................................................................................................17
5. FICHIER BUILD.XML ...............................................................................................................................................17
6. PROPRIETES DE ANT: .............................................................................................................................................17
7. PRIORITE D’UTILISATION DES PROPRIETES .............................................................................................................18
8. UTILISATION DES PROPRIETES ANT ........................................................................................................................18
9. PROPRIETES PREDEFINIES DE ANT ..........................................................................................................................18
10. GROUPES DE FICHIERS........................................................................................................................................18
11. CIBLES ...............................................................................................................................................................19
12. TACHES ..............................................................................................................................................................19
IV.12.1 Tâches Ant de gestion des fichiers.........................................................................................................19
IV.12.2 Tâche Ant pour la gestion des archives.................................................................................................19
IV.12.3 Tâche de gestion de l'exécution de Ant..................................................................................................19
IV.12.4 Tâches Ant de gestion des propriétés ....................................................................................................20
IV.12.5 Tâches Ant de compilations Java ..........................................................................................................20
IV.12.6 Autres tâches Ant...................................................................................................................................20
13. EXEMPLE: ..........................................................................................................................................................21
V. HIBERNATE.......................................................................................................................................................24
1. INTRODUCTION ......................................................................................................................................................24
2. PREMIER PROJET HIBERNATE:................................................................................................................................24
a. Installation.......................................................................................................................................................................24
b. Création de la base de données........................................................................................................................................24
c. Création de la classe métier (Java Bean) .........................................................................................................................24
d. Création du fichier de mapping Creancier.hbm.xml........................................................................................................26
2
e. Création du fichier de configuration hibernate.cfg.xml...................................................................................................27
f. Création de la classe HibernateUtil .................................................................................................................................28
g. Création de l’interface CreancierDao ..............................................................................................................................28
h. Création de l’implémentation CreancierHibernateDao....................................................................................................28
i. Test de la classe CreancierHibernateDao ........................................................................................................................30
• Création de la classe DataBaseConnection auxilière pour les tests unitaire ....................................................................30
• Création du la classe du test unitaire CreancierHibernateDaoTest ..................................................................................31
• Création du test suite:......................................................................................................................................................32
• Exécution en utilisant Ant: ..............................................................................................................................................33
VI. STRUTS 2 ............................................................................................................................................................34
1. DÉFINITION ............................................................................................................................................................34
2. ARCHITECTURE GÉNÉRALE: ...................................................................................................................................34
3. CONFIGURATION :..................................................................................................................................................35
A) TELECHARGER STRUTS2 ....................................................................................................................................35
B) FICHIER DE CONFIGURATION WEB.XML ..............................................................................................................35
C) FICHIER DE CONFIGURATION STRUTS.XML .........................................................................................................36
j. La balise constant :..........................................................................................................................................................36
k. La balise package : ..........................................................................................................................................................37
4. ACTION ..................................................................................................................................................................37
5. JSP.........................................................................................................................................................................38
VII. ANNEXE..............................................................................................................................................................40
1. INSTALLATION DE L’ENVIRONNEMENT DE TRAVAIL:..............................................................................................40

3
Introduction générale
Java Enterprise Edition, ou Java EE (anciennement J2EE), est une spécification pour la
technologie Java de Sun plus particulièrement destinée aux applications d’entreprise. Dans ce
but, toute implémentation de cette spécification contient un ensemble d’extensions au
framework Java standard (JSE, Java Standard Edition) afin de faciliter la création d’applications
réparties.
En génie logiciel, une application web est une application réseau basée sur un serveur et un
client, dont la communication est basée sur l'appel de liens hypertextuels. Le serveur a pour
nom serveur web, le réseau a pour nom Internet ou Intranet, le client est un Navigateur web
navigateur Web.
Les applications web sont populaires pour de nombreuses raisons :
L’ubiquité du navigateur web (client, client léger) présent sous de nombreux OS ».
La capacité de mettre à jour et maintenir des applications web sans distribuer ni installer
autre chose que le navigateur web.
Des applications web sont employées pour implémenter des webmails, des ventes au détail en
ligne, des ventes aux enchères en ligne, des forums de discussion, des blogs, MMOG, et
beaucoup d'autres fonctions.
Dans les premières applications client-serveur, chaque application devait avoir son propre
logiciel client qui servait d'interface et devait être installé sur l'ordinateur de chaque utilisateur.
Une mise à jour de la partie serveur de l'application induisait souvent une mise à jour des
applications clientes installées sur de multiples postes, engendrant des coûts importants et
réclamant du temps.
Au contraire, les applications web génèrent dynamiquement des pages web dans un format
compatible avec la plupart des navigateurs web (HTML/XHTML). Les scripts clients, notamment
en JavaScript, sont souvent utilisés pour ajouter des éléments dynamiques à l'application. On
parle alors de DHTML (dynamic HTML). Chaque page individuelle peut être un document
dynamique ou statique, mais la succession de pages peut créer une interactivité, car les saisies
de formulaire de l'utilisateur sont envoyées au serveur. Durant une session, le browser
interprète et affiche les pages, agissant comme un client universel pour chaque application
web.
La dernière pratique apparue est AJAX qui permet d'augmenter l'interactivité avec l'utilisateur
en permettant de mettre à jour seulement une partie d'une page web, rendant facultatif le
rechargement de la page. On peut dès lors créer des applications plus proches des applications
de bureau classiques.
Une application web, de par l'utilisation du réseau internet, est multiplateforme, partageable,
et ne peut s'exécuter que dans le navigateur web, par opposition aux applications
informatiques.
L’objectif de ce cours est de présenter des bonnes pratiques à suivre pour le développement
des applications Web sous la norme JEE.

4
I. Design Patterns
1. Pattern (en français modèle)
Un pattern (modèle) est une façon de faire, une manière d'arriver à l’objectif fixé. Les patterns
vous permettent d’utiliser des principes basés sur l’habileté des précurseurs en la matière. Les
modèles sont une façon excellente de capturer et transporter l’habileté.
Lorsque votre habileté a employé certaines méthodes communes seront maîtrisées, vous vous
rendrez compte que ces méthodes pourraient être réutilisé dans plusieurs contextes.
Les Patterns, sont apparus bien avant l’apparition de l’informatique, étaient utiliser en
architecture. Les modèles architecturaux peuvent servir et inspirer les personnes qui
occuperont les bâtiments.
Le Pattern font référence aux modèles standardisés d’implémentation de certaines taches à
réaliser… Les écrivains documentent ces modèles, en aidant à standardiser ces modèles. Ils
assurent aussi que la sagesse accumulée d'une habileté est disponible aux futures générations
des praticiens.

2. Design Pattern (motifs ou modèles de conception)


Un Design Pattern est un modèle de conception, il utilise des classes et leurs méthodes dans
un langage orientée objet, Java dans notre cas. Les Design Patterns permettent de mettre en
application des concepts spécifiques sans pour autant avoir à passer beaucoup de temps sur la
méthode de développement à employer pour arriver à un objectif. Ils permettent donc de
simplifier votre réflexion en réutilisant des principes de base de la conception, cela aura donc
pour effet de rendre votre programme plus lisible lors de phase de maintenance par exemple.
Les Design Patterns sont tout simplement des architectures de classes permettant d'apporter
une solution à des problèmes fréquemment rencontrés lors des phases d'analyse et de
conception d'applications. Ces solutions sont facilement adaptables (donc réutilisables), elles
sont utilisables sans aucun risques dans la grande majorité des langages de programmation
orientée objet.
Les Design Patterns sont fiables. Ils ont une architecture facilement compréhensible et
identifiable pour les développeurs. Cela améliore donc la communication et la compréhension
entre développeurs.
L’assimilation des concepts des Design Patterns impose de maîtriser les concepts de base et
avancés. Il faut donc maîtriser plus précisément les notions suivantes :
 Concepts de POO (Programmation Orientée Objet)
 Diagramme des classes UML

3. Comment utiliser les Design Patterns


Les principaux auteurs des Design Patterns (Erich Gamma, Richard Helm, Ralph Johnson et
John Vlissides), en ont dégagés 23 principaux, sont plus connus sous le nom du : « Gang Of
Four ».
On retrouve une classification en 3 catégories :
 Creational Patterns (Les Patterns de création)
 Abstract Factory, Builder, Factory Method, Prototype, Singleton

 Structural Patterns (Les Patterns de structure)


 Adapter, Bridge, Composite, Decorator, Façade, Flyweight, Proxy

 Behavioral Patterns (Les patterns de comportement)


5
 Chain of Resp., Command, Interpreter, Iterator, Mediator,
Memento, Observer, State, Strategy, Template Method, Visitor
Pour plus de détails sur un des Design Patterns, vous pouvez consulter le site
www.dofactory.com.
Les Design Patterns qu’ils ont créés sont considérés comme la base de tous les autres, à partir
desquelles d’autres patterns pourront ensuite être construits.

4. Exemples
a. Singleton:
Le singleton est une classe dont on veut s’assurer qu’une seule et unique instance de celle-ci
est créée pendant toute la durée d’exécution de votre application.
Ce Design Pattern est très facile à utiliser et souvent utilisé, cependant beaucoup de personnes
l’utilisent mal.
Pour s’assurer de l’unicité de l’instance du singleton, il faut tout d’abord penser à limiter les
accès aux constructeurs (le plus souvent « private » ou « protected », cependant si vous
utilisez ce deuxième cela ne certifie pas l’unicité de l’instance si vous hérité votre singleton).
Si vous n’avez pas de constructeur, il vous faut donc un autre moyen pour retourner une
instance de votre classe. Pour cela vous devrez implémenter une méthode « static » qui par
convention s’appellera : getInstance().

Vous pouvez utiliser le pattern Singleton dans le cas d’un objet de connexion à une base de
données
Voici un exemple de code du corps d’un singleton (votre classe ne doit pas obligatoirement porté
le nom « Singleton ») :
/**
* Exemple d'implémentation d'un singleton.
* Cet exemple ne fait rien.
*/

Singleton {

/** L'instance statique */


Private Singleton instance;

/**
* Récupère l'instance unique de la class Singleton.
* Remarque : le constructeur est rendu inaccessible
*/
Public static Singleton getInstance() {
if (null == instance) { // Premier appel
instance = new Singleton();
}
return instance;
}

/**
* Constructeur redéfini comme étant privé pour interdire
* son appel et forcer à passer par la méthode getInstance()
*/
private Singleton() {
}

6
Main:
package designpatterns;
/**
*
* @author NAJAHI
*/
public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
Singleton s = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s);
System.out.println(s2);
if (s==s2) {
System.out.println("meme reference");
}
else {
System.out.println("deux objets differents");
}
}

}
Résultat :
designpatterns.Singleton@19821f
designpatterns.Singleton@19821f
meme reference

b. Design Pattern Dao:

Ce design patterns est utilisé généralement lorsqu’on a une classe de base et n classes qui
héritent de cette classe.
Exemple :
Supposons une application java à laquelle on fournit le « nom » et le « sex » d’une personne.
Si le « sex »est masculin l’application doit afficher « Bonjour M. <Nom> », sinon « Bonjour
Mme <Nom > »

public class Person {


// name string
public String name;
// gender : M or F
private String gender;
public String getName() {
return name;
}

public String getGender() {


return gender;
}
}// End of class

7
public class Male extends Person {
public Male(String fullName) {
System.out.println("Hello Mr. "+fullName);
}
}// End of class

public class Female extends Person {


public Female(String fullNname) {
System.out.println("Hello Ms. "+fullNname);
}
}// End of class

public class SalutationFactory {


public static Person getPerson(String name, String gender) {
if (gender.equals("M"))
return new Male(name);
else if(gender.equals("F"))
return new Female(name);
else
return null;
}
}// End of class

public class Main {


public static void main(String[] args) {
Person p = SalutationFactory.getPerson("Mounir", "M");
}
}

c. MVC & MVC2

Le Model-View-Controller (MVC) est un modèle de conception logicielle très répandu et fort


utile. Créé dans les années 80 par Xerox PARC pour Smalltalk-80, il est aujourd’hui fortement
recommandé dans l’univers J2EE. Néanmoins il faut retenir que c’est un modèle de conception,
et il est donc indépendant du langage de programmation.

Principe
 Un modèle à trois couches

Le MVC est un modèle de conception qui repose sur la volonté de séparer les données, les
traitements et la présentation. Ainsi l’application se retrouve segmentée en trois composants
essentiels :

• le modèle
• la vue
• le contrôleur

Chacun de ces trois composants a un rôle bien défini.

Le modèle représente les données et les règles métiers. C’est dans ce composant que
s’effectuent les traitements liés au coeur du métier. Les données peuvent être liées à une base
de données, des EJBs, des services Web, … Il est important de noter que les données sont
indépendantes de la présentation. En d’autres termes, le modèle ne réalise aucune mise en
forme. Ces données pourront être affichées par plusieurs vues. Du coup le code du modèle est
factorisé : il est écrit une seule et unique fois puis réutilisé par chaque vue.

8
La vue correspond à l’IHM. Elle présente les données et interagit avec l’utilisateur. Dans le
cadre des applications Web, il s’agit d’une interface HTML, mais n’importe quel composant
graphique peut jouer ce rôle.

Le contrôleur, quant à lui, se charge d’intercepter les requêtes de l’utilisateur, d’appeler le


modèle puis de rediriger vers la vue adéquate. Il ne doit faire aucun traitement. Il ne fait que
de l’interception et de la redirection.

Cinématique

• L’utilisateur émet une requête


• Le contrôleur intercepte la requête de l’utilisateur
• Le contrôleur détermine quelle partie du modèle est concernée et quelle vue y est
associée
• Le modèle traite les interactions avec les données, applique les règles métier et renvoie
les données au contrôleur
• Le contrôleur sélectionne la vue et lui renseigne les données
• La vue présente les données à l’utilisateur

MVC model 2

Le MVC très pratique, peut se révéler lourd à mettre en place. Ceci à cause de la multitude de
contrôleur à implémenter. Afin de simplifier la réalisation d’un tel modèle, une nouvelle version
a été introduite : le MVC2. C’est exactement le même modèle de conception à la différence
qu’il n’y a plus qu’un seul contrôleur qui se charge de rediriger la requête vers le bon
traitement.

Dans la pratique
 Avantages

9
A l’époque des applications Web, il n’est pas rare que le développeur soit tenté de mettre du
code de traitement dans les composants de présentation (JSP, PHP, …). Certains composants
facilitent même ce genre de développement!! Le MVC impose cette séparation.

Comme précisé plus haut, plusieurs vues peuvent utiliser le même modèle. Ce qui représente
un gain en coût de développement important.

Le modèle est totalement indépendant de la vue. Si l’application a besoin d’un nouveau mode
d’accès, le modèle restera inchangé. Il suffit juste de changer la partie IHM.

Le modèle étant totalement autonome, il peut être modifié beaucoup plus facilement. En effet
si le mode de persistance des données change ou bien si des règles métier évoluent, il suffit de
modifier seulement le modèle. La vue n’a pas besoin d’être modifiée dans ce cas.

Deux équipes peuvent travailler en parallèle. Une équipe d’infographistes peut travailler sur les
vues et en même temps une équipe de développeurs peut travailler sur le modèle et le
contrôleur. Cet aspect nécessite tout de même une bonne communication entre les deux
entités.

Les trois couches doivent être réellement indépendantes et ne doivent communiquer que par
des interfaces. Dans ce cas l’application sera très modulaire et n’importe quelle couche pourra
être interchangée sans conséquence pour les autres.

Le contrôleur permet une très grande souplesse dans l’application. C’est lui qui assemble
différentes parties du modèle avec une vue à partir d’une requête. S’il est maitrisé à la
perfection, la factorisation des vues est envisageable. L’architecte peut alors s’amuser à en
surprendre plus d’un développeur!!

 Inconvénients

Le MVC se révèle trop complexe pour de petites applications. Le temps accordé à l’architecture
peut ne pas être rentable pour le projet.

Même si le code est factorisé, le nombre de microcomposant n’en est pas moins augmenté.
C’est le prix à payer pour la séparation des 3 couches. Et toutes les personnes qui font de la
gestion de configuration comprendront que le nombre important de fichiers représente une
charge non négligeable dans un projet.

Conclusion

Le MVC favorise le développement et la maintenance du code. Sur de gros projets et/ou avec
de grandes équipes de développements, l’application d’un tel modèle de conception se révèle
très performant. Il existe aujourd’hui des frameworks très avancés qui se basent sur le MVC ou
le MVC2. L’utilisation de ces frameworks facilite sa mise en place et cadre sa réalisation.

Pour les personnes qui souhaitent mettre en place une application MVC2 en J2EE, struts 2 se
révèle très adapté.

10
II. Architecture 3 tiers
L'architecture 3-tier ou architecture à trois niveaux est l'application du modèle plus
général qu'est le multi-tiers. L'architecture logique du système est divisée en trois niveaux ou
couches :
• couche présentation
• couche métier
• couche accès aux données
C'est une extension du modèle client/serveur.

1. Couche présentation
Elle correspond à la partie de l'application visible et interactive avec les utilisateurs. On parle
d'Interface Homme Machine. En informatique, elle peut être réalisée par une application
graphique ou textuelle. Elle peut aussi être représentée en HTML pour être exploitée par un
navigateur web ou pour être utilisée par un téléphone portable.
On conçoit facilement que cette interface peut prendre de multiples facettes sans changer la
finalité de l'application. Dans le cas d'un système de distributeurs de billets, l'automate peut
être différent d'une banque à l'autre, mais les fonctionnalités offertes sont similaires et les
services identiques (fournir des billets, donner un extrait de compte, etc.).
Toujours dans le secteur bancaire, une même fonctionnalité métier (par exemple, la
commande d'un nouveau chéquier) pourra prendre différentes formes de présentation selon
qu'elle se déroule sur Internet, sur un distributeur automatique de billets ou sur l'écran d'un
chargé de clientèle en agence.
La couche présentation relaie les requêtes de l'utilisateur à destination de la couche métier, et
en retour lui présente les informations renvoyées par les traitements de cette couche. Il s'agit
donc ici d'un assemblage de services métiers et applicatifs offerts par la couche inférieure.

2. Couche métier:
Elle correspond à la partie fonctionnelle de l'application, celle qui implémente la « logique », et
qui décrit les opérations que l'application opère sur les données en fonction des requêtes des
utilisateurs, effectuées au travers de la couche présentation.
Les différentes règles de gestion et de contrôle du système sont mises en œuvre dans cette
couche.
La couche métier offre des services applicatifs et métier à la couche présentation. Pour fournir
ces services, elle s'appuie, le cas échéant, sur les données du système, accessibles au travers
des services de la couche inférieure. En retour, elle renvoie à la couche présentation les
résultats qu'elle a calculés.

11
3. Couche d’accès aux données :
Elle consiste en la partie gérant l'accès aux gisements de données du système. Ces données
peuvent être propres au système, ou gérées par un autre système. La couche métier n'a pas à
s'adapter à ces deux cas, ils sont transparents pour elle, et elle accède aux données de
manière uniforme (couplage faible).
Ces données sont pérennes, car destinées à durer dans le temps, de manière plus ou moins
longue, voire définitive.
Les données peuvent être stockées indifféremment dans de simples fichiers texte, ou
eXtensible Markup Language (XML), ou encore dans une base de données. Quel que soit le
support de stockage choisi, l'accès aux données doit être le même. Cette abstraction améliore
la maintenance du système.
Les services sont mis à disposition de la couche métier. Les données renvoyées sont issues
du/des gisements de données du système.
Pour une implémentation « native », le motif de conception (en anglais design pattern) à
implémenter dans cette couche est le Data Access Object (DAO). Ce dernier consiste à
représenter les données du système sous la forme d'un modèle objet. Par exemple un objet
pourrait représenter un contact ou un rendez-vous.
La représentation du modèle de données objet en base de données (appelée persistance) peut
s'effectuer à l'aide d'outils tels que Hibernate.

12
III. Tests unitaires avec Junit
1. Introduction
JUnit est un framework de tests unitaires pour le langage Java créé par Kent Beck et Erich
Gamma. Les tests unitaires permettent de vérifier si le comportement de chaque méthode de
chaque classe Java est bien celui désiré. JUnit fournit donc un cadre de développement et
d’exécution pour ce type de tests.
JUnit est particulièrement adapté aux développeurs souhaitant faire du développement dirigé
par les tests (Tests Driven Development) dont la particularité majeure est de développer le
test unitaire avant le code lui-même. On décrit donc, par l’écriture d’un test unitaire, le
comportement attendu d’une classe et ce n’est qu’à partir de ce moment que l’on commence à
écrire le code de cette classe de façon à ce qu’elle passe le test. Si les tests sont correctement
écrits et complets, on s’assure donc de développer des classes sans erreurs et répondant
exactement à nos besoins.
JUnit est également un outil particulièrement utile pour réaliser des tests de non-régressions
du fait qu’il permet d’avoir des tests automatisés et rejouables. En ré-exécutant les suites de
tests après une correction, une modification ou une évolution du code, on peut s’assurer qu’il
n’y a pas eu d’effets de bords sur le comportement du logiciel qui était déjà codé.
Enfin, on peut noter que la mise en place de tests unitaires permet d’améliorer les conditions
de “transmissibilité” d’un code du développeur/auteur vers un autre développeur, en
sécurisant les interventions d’un novice dans le code : cette démarche participe à un apport
organisationnel, libérant, dans une certaine mesure, le développeur/auteur des tâches de
maintenance.

2. Ecrire les tests unitaires avec JUnit


Dans les méthodes de test unitaire, les méthodes testées sont appelées et leur résultat est
testé à l’aide d’assertions :

• assertEquals(a,b)
Teste si a est égal à b (a et b sont soit des valeurs primitives, soit des objets possédant une
méthode equals)

• assertTrue(a) et assertFalse(a)
Testent si a est vrai resp. faux, avec a une expression booléenne.

• assertSame(a,b) et assertNotSame(a,b)
Testent si a et b référent au même objet ou non.

• assertNull(a) et assertNotNull(a)
13
Testent si a est null ou non, avec a un objet

3. Exemple:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package net.backend.util;

/**
*
* @author NAJAHI
*/
public class MathHelper {
public static double carre (double d) {
return d * d;
}
}

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package test.java.net;
import junit.framework.*;
import net.backend.util.MathHelper;
/**
*
* @author NAJAHI
*/
public class MathHelperTest extends TestCase {
public MathHelperTest(String text){
super (text);
}
@Override
protected void setUp() {
// ce code est executé avant l'appel de chaque fonction de test de cette classe
}
@Override
protected void tearDown() {
// ce code est executé après l'appel de chaque fonction de test de cette classe
}
public void testCarre() {
double d = MathHelper.carre(2.0);
assertEquals("La fonction carre n'a pas pu fournir le bon resultat pour la valeur
2", d, 4.0);
}

package test.java.net;

import junit.framework.Test;
import junit.framework.TestSuite;

public class ApplicationTestSuite extends TestSuite {

public static Test suite(){


TestSuite suite = new TestSuite();

suite.addTest(new MathHelperTest("testCarre"));
return suite;

14
}
}

4. Quelques règles de bonne conduite avec JUnit:


• Ecrire les test en même temps que le code.
• Tester uniquement ce qui peut vraiment provoquer des erreurs.
• Exécuter ses tests aussi souvent que possible, idéalement après chaque changement de
code.

• Ecrire un test pour tout bogue signalé (même s’il est corrigé).
• Ne pas tester plusieurs méthodes dans un même test : JUnit s’arrête à la première erreur.
• Attention, les méthodes privées ne peuvent pas être testées !

15
IV. Ant
1. Introduction
Apache Ant est un projet du groupe Apache-Jakarta. Son but est de fournir un outil écrit en
Java pour permettre la construction d'applications (compilation de programmes et exécution
d'autres tâches).
Ant, comparativement à d'autres outils de type «make», a la particularité d'être indépendant
de toute plate-forme (Unix, Linux, Windows...). Il devient donc un outil fort intéressant dans le
cas où on doit développer une application sur plusieurs plates-formes ou encore migrer une
application d'une plate-forme vers une autre.
Ant repose sur un fichier de configuration au format XML. Ant fournit par défaut un groupe de
tâches courantes représentées sous forme d'objet en langage Java. Ant fournit également la
possibilité de créer ses propres objets Java pour exécuter des tâches plus spécifiques et non
fournies avec l'application de base.

2. Fichier de configuration XML de Ant


Pour en faire une brève description, le fichier de configuration d’Ant fonctionne de la façon
suivante. Le fichier contient un ensemble de cibles (target). Chaque cible contient une ou
plusieurs tâches. Certaines cibles peuvent être dépendantes d'autres cibles pour être
exécutées.

3. Installation de Ant
Puisque Ant repose sur la technologie Java, il faut d'abord installer le JDK. Ant s'installe sur la
majorité des plates-formes.
Sur Windows, il suffit de :
Dézipper à l'endroit désiré le fichier téléchargé ce qui cré un répertoire nommé jakarta-ant-
version .
Ajouter le chemin complet au répertoire bin de Ant (situé dans le répertoire «jakarta-ant-
version») à la variable système PATH. Ceci vous permettra de pouvoir facilement appeler Ant
n'importe ou dans l'arborescence du système
Ajouter une variable d'environnement ANT_HOME qui pointe sur le répertoire jakarta-ant-
version créé lors de la décompression du fichier
S'assurer que la variable d'environnement JAVA_HOME pointe sur le répertoire contenant le
JDK.
Dans certain cas, il peut s'avérer nécessaire d'ajouter à la variable d'environnement
CLASSPATH, les fichiers jar contenus dans le répertoire lib de Ant.
Pour d'autres plates-formes, vous pouvez consulter la documentation d'installation sur le site
ant.apache.org.
Note : Sous Windows XP et autres version de Windows, vous pouvez ajouter des variables
d'environnement en effectuant un clic droit de la souris sur l'icône d'ordinateur situé sur le
bureau de Windows et en choisissant «Propriétés» dans le menu contextuel. Dans la fenêtre
«Propriétés système» qui s'affiche, cliquer sur l'onglet «Avancé». Dans cet onglet, cliquer sur
le bouton «Variables d'environnement».

16
4. Execution de Ant par ligne de commande
Voici la syntaxe de base pour utiliser Ant en mode ligne de commande : ant [options] [cible]
Par défaut, Ant recherche un fichier nommé build.xml dans le répertoire courant. Si il trouve ce
fichier, il exécute la cible par défaut.

• Liste des principales options de Ant


Ant possède plusieurs options dont voici les principales :

• -buildfile : Pour préciser le nom du fichier de configuration si différent de build.xml


• -quiet : Pour obtenir un résumé d'informations lors de l'exécution
• -verbose : Pour obtenir un maximum d'informations lors de l'exécution
• -version : Pour afficher la version de Ant
• -projecthelp : Pour afficher les cibles définies avec leurs descriptions
• -D[nom]=[valeur] : permet de définir une propriété et de lui assigner une valeur

5. Fichier build.xml
Comme son suffixe l'indique, c'est un fichier de type XML. Il doit donc commencer (comme
tout fichier XML valide) par l'en-tête <?XML version="1.0" ?>.
L'élément racine du fichier XML est <project>.
Celui-ci peut contenir les attributs suivants :
• name : Pour préciser le nom du projet.
• default : Pour préciser la cible par défaut à exécuter.
• basedir : Pour préciser le répertoire qui servira de référence pour localiser de façon
relative les autres répertoires.
À ce stade, on pourrait créer un fichier build.xml minimal qui ressemblerait à ceci :
<?xml version="1.0" ?>
<project name="mon premier projet" default="compile" basedir=".">
</project>
Ceci est du XML valide, mais le fichier ne fonctionnerait pas encore correctement, car il lui
manque la description de la cible compile définie dans l'attribut default.
Note : Comme tout fichier XML, vous pouvez ajouter des commentaires dans votre fichier
build.xml de la façon suivante :
<!-- Exemple de commentaire -->

6. Propriétés de Ant:
Il est possible d'ajouter des propriétés dans le fichier build.xml en utilisant la balise
<property>. La balise project est donc souvent suivie de balises property.
Voici les attributs de la balise property
• name : Permet de définir le nom de la propriété
• file : Permet de préciser le nom d'un fichier qui contient la définition d'un ensemble de
propriétés. Ceci permet d'éviter de se retrouver avec une liste considérable de balise
property en début de fichier. Le fichier en question porte habituellement l'extenssion
.properties
17
• location : Permet de définir un fichier avec son chemin

7. Priorité d’utilisation des propriétés


Ant priorise toujours la première valeur de propriété qu'il rencontre. Par exemple, si vous créez
un fichier build.xml contenant une propriété nommée version avec une valeur «1.0» et que
vous appelez ensuite Ant à partir de la ligne de commande avec -Dversion=1.1, Ant utilisera
alors 1.1 comme valeur pour la propriété version puisque la propriété définie dans la ligne de
commande est exécutée par Ant avant de lire le fichier build.xml.

8. Utilisation des propriétés Ant


Pour utiliser une propriété définie dans le fichier build.xml, on doit utiliser la syntaxe suivante :
${nom_de_propriete}
Par exemple, si vous avez défini votre propriété «version» de la façon suivante :
<property name="version" value="1.0" />
vous pourrez vous servir de cette propriété de cette façon :
${version}

9. Propriétés prédéfinies de Ant


Il existe quelques propriétés prédéfinies dans Ant et utilisables dans vos fichiers build.xml. En
voici la liste :
• basedir : Même chose que l'attribut du même nom dans la balise project.
• ant.file : Représente le chemin absolu du fichier build en cours de traitement.
• ant.java.version : Représente la version de la JVM qui exécute Ant.
• ant.project.name : Représente le nom du projet en cours d'utilisation.

10. Groupes de fichiers


Ant possède une balise <fileset> qui permet de définir un groupe de fichiers qui devront être
utilisés dans une tâche.
Voici la liste des propriétés de la balise <fileset>
dir : Permet de définir le répertoire racine de l'ensemble de fichiers
includes : Permet de définir une liste de fichiers à inclure
excludes : Permet d'indiquer une liste de fichiers à exclure
Exemple :
<fileset dir="abc" includes="**/*.java" />
ou encore
<fileset dir="abc">
<include name="**/*.java" />
</fileset>
Note : L'expression **/ permet de préciser d'inclure tous les sous répertoires du répertoire
défini dans l'attribut dir. *.java permet de spécifier d'inclure tous les fichiers portant
l'extension.java.

18
11. Cibles
Dans Ant, les cibles sont représentées par la balise <target>. Tel que décrit en introduction de
ce document, une cible est regroupement de tâches à réaliser dans un ordre défini.
Voici la liste des attributs de la balise target :
• name : Pour indiquer le nom de la cible.
• description : Pour indiquer une courte description de la cible.
• if : Permet de préciser une condition d'exécution.
• unless : Permet présicer une condition d'exécution en se basant sur l'inexistence de la
définition d'une propriété.
• depends : Permet de spécifier une liste des cibles dont dépend la cible.

12. Taches
Tel que décrit brièvement en introduction, une tâche est une unité de traitement représentée
par un objet en langage Java. Ant fournit par défaut une série de tâches pour l'exécution de
traitements standards.

voici une liste des principales tâches :

IV.12.1 Tâches Ant de gestion des fichiers


• chmod : Modifier les droits d'un fichier
• concat : Permet de concaténer une série de fichiers pour en former un seul
• copy : Copier un fichier
• delete : Supprimer un fichier
• get : Obtenir un fichier depuis une URL
• mkdir : Créer un répertoire
• move : Déplacer ou renommer un fichier
• tempfile : Générer un nom pour un fichier temporaire
• touch : Modifier la date de modification du fichier avec la date courante

IV.12.2 Tâche Ant pour la gestion des archives


• cab : Créer une archive cab de type Microsoft
• ear : Créer une archive contenant une application J2EE
• gunzip : Décompresser une archive
• gzip : Compresser dans une archive
• jar : Créer une archive de type jar
• tar : Créer une archive de type tar
• unjar : Décompresser une archive de type jar
• untar : Décompresser une archive de type tar
• unwar : Décompresser une archive de type war
• unzip : Décompresser une archive de type zip
• war : Créer une archive de type war
• zip : Créer une archive de type zip

IV.12.3 Tâche de gestion de l'exécution de Ant


• ant : Exécuter un autre fichier de build

19
• antcall : Exécuter une cible
• fail : Arreter l'exécution de Ant
• parallel : Exécuter une tâche en parallèle
• record : Enregistrer les traitements de l'exécution dans un fichier journal
• sequential : Exécuter une tâche en séquentielle
• sleep : Faire une pause dans les traitements

IV.12.4 Tâches Ant de gestion des propriétés


• available : Définir une propriété si une ressource existe
• condition : Définir une propriété si une condition est vérifiée
• pathconvert : Définir une propriété avec la conversion d'un chemin de fichier spécifique
à un OS
• property : Définir une propriété
• tstamp : Initialiser les propriétés DSTAMP, TSTAMP et TODAY avec la date et heure
courante
• uptodate : Définir une propriété en comparant la date de modification de fichiers

IV.12.5 Tâches Ant de compilations Java


• java : Exécuter une application dans la JVM
• javac : Compiler des sources Java
• javadoc : Générer la documentation du code source
• rmic : Générer les classes stub et skeleton nécessaires à la technologie rmi
• signjar : Signer un fichier jar

IV.12.6 Autres tâches Ant


• apply : Exécuter une commande externe appliquée à un ensemble de fichiers
• cvs : Gérer les sources dans CVS
• cvspass : Ajouter des entrée à un fichier .cvspass
• dependset : Définir des dépendances entre fichiers
• echo : Afficher un message
• exec : Exécuter une commande externe
• genkey : Générer une clé dans un trousseau de clé
• get : Obtenir une ressource à partir d'une URL
• mail : Envoyer un courrier électronique SMTP
• replace : Remplacer une chaîne de caractères par une autre
• splash : Afficher un Splash screen
• sql : Exécuter une requête SQL
• style : Appliquer une feuille de style XSLT à un fichier XML
• taskdef : Ajouter une tâche au projet courant
• typedef : Définir un nouveau type de données
• XmlValidate : Vérifier la validité d'un fichier XML

20
13. Exemple:
<project name="JEEProject" default="war" basedir="." >
<description>
JEEProject
</description>

<property environment="env"/>
<property name="resources" location="resources"/>
<property name="src" location="src/java"/>
<property name="classes" location="WEB-INF/classes"/>
<property name="lib" location="WEB-INF/lib"/>
<property name="dependency_jars" location="dependency_jars"/>
<property name="test" location="test/java"/>
<property name="testlib" location="test/testlib"/>

<target name="init">
<tstamp/>
<delete dir="${classes}"/>
<mkdir dir="${classes}"/>
<delete dir="dist"/>
<mkdir dir="dist"/>
</target>

<path id="project.class.path" >


<pathelement path="${env.classpath}"/>
<fileset dir="${lib}">
<include name="**/*.jar"/>
</fileset>
<fileset dir="${dependency_jars}">
<include name="**/*.jar"/>
</fileset>
<pathelement location="${src}"/>
<pathelement location="${classes}"/>
</path>

<path id="test.class.path" >


<pathelement path="${env.classpath}"/>
<fileset dir="${testlib}">
<include name="**/*.jar"/>
</fileset>
<pathelement location="${test}"/>
<pathelement location="${classes}"/>
</path>

<target name="compile" depends="init" description="compile the source " >


<echo message="compiling files"/>
<javac srcdir="${src}" destdir="${classes}" classpathref="project.class.path"/>
<echo message="copying other src xml and property files to classes"/>
<copy toDir="${classes}">
<fileset dir="${src}">
<include name="**/*.properties"/>
<include name="**/*.xml"/>
</fileset>
</copy>
</target>

<target name="compile-tests" depends="compile" description="compile unit tests " >


<echo message="compiling unit tests files"/>
<javac srcdir="${test}" destdir="${classes}" classpathref="test.class.path"/>
</target>

<target name="test" depends="compile-tests">


<junit>
<classpath refid="test.class.path" />
<classpath refid="project.class.path" />
<formatter type="brief" usefile="false" />

21
<test name="test.java.net.ApplicationTestSuite" />
</junit>
</target>

<target name="war" depends="compile" description="Builds application war file">


<war webxml="WEB-INF/web.xml" destfile="dist/stock.war">
<fileset dir=".">
<exclude name="src/"/>
<exclude name="dist/"/>
<exclude name="dependency_jars/"/>
<exclude name="db_build/"/>
<exclude name="**.xml"/>
</fileset>
</war>
</target>
</project>

22
23
V. Hibernate
1. Introduction
Hibernate est un projet open source visant à proposer un outil de mapping entre les objets et
des données stockées dans une base de données relationnelle. Ce projet ne repose sur aucun
standard mais il est très populaire notamment à cause de ses bonnes performances et de son
ouverture avec de nombreuses bases de données.
Le site officiel http://www.hibernate.org contient beaucoup d'informations sur l'outil et propose
de le télécharger ainsi que sa documentation.

2. Premier projet Hibernate:


a. Installation
Pour utiliser Hibernate, il suffit de télécharger hibernate-3.x.x.jar et le mettre dans la
bibliothèque de votre projet.
b. Création de la base de données
Sous MySql créez la base de données ainsi que les différentes tables de votre projet.
CREATE DATABASE gestionBudgetaire;
USE gestionBudgetaire;

CREATE TABLE `creancier` (


`id` int(10) NOT NULL auto_increment,
`denomination` varchar(256) NOT NULL,
`formeJuridique` varchar(256) NOT NULL,
`nomContact` varchar(256) default NULL,
`registreDeCommerce` varchar(256) default NULL,
`identifiantFiscal` varchar(256) default NULL,
`cnss` varchar(256) default NULL,
`tel` varchar(256) default NULL,
`fax` varchar(256) default NULL,
`email` varchar(256) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Téléchargez le driver mysql (mysql-connector-java-3.x.x-bin.jar) et mettez le dans la
bibliothèque de votre projet.
c. Création de la classe métier (Java Bean)
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package net.backend.vo;
import java.io.Serializable;
/**
*
* @author Mounir
*/
public class Creancier implements Serializable {
private Integer id;
private String denomination;
private String formeJuridique;
private String registreDeCommerce;
private String IdentifiantFiscal;
private String cnss;
private String tel;
private String fax;
private String email;
24
private String nomContact;

public Creancier() {
}

public String getIdentifiantFiscal() {


return IdentifiantFiscal;
}

public void setIdentifiantFiscal(String IdentifiantFiscal) {


this.IdentifiantFiscal = IdentifiantFiscal;
}

public String getCnss() {


return cnss;
}

public void setCnss(String cnss) {


this.cnss = cnss;
}

public String getDenomination() {


return denomination;
}

public void setDenomination(String denomination) {


this.denomination = denomination;
}

public String getEmail() {


return email;
}

public void setEmail(String email) {


this.email = email;
}

public String getFax() {


return fax;
}

public void setFax(String fax) {


this.fax = fax;
}

public String getFormeJuridique() {


return formeJuridique;
}

public void setFormeJuridique(String formeJuridique) {


this.formeJuridique = formeJuridique;
}

public Integer getId() {


return id;
}

public void setId(Integer id) {


this.id = id;
}

public String getNomContact() {


return nomContact;
}

public void setNomContact(String nomContact) {


this.nomContact = nomContact;
}

25
public String getRegistreDeCommerce() {
return registreDeCommerce;
}

public void setRegistreDeCommerce(String registreDeCommerce) {


this.registreDeCommerce = registreDeCommerce;
}

public String getTel() {


return tel;
}

public void setTel(String tel) {


this.tel = tel;
}
}

d. Création du fichier de mapping Creancier.hbm.xml


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="net.backend.vo.Creancier" table="creancier">
<id
name="id"
type="integer"
column="id"
length="10"
>
<generator class="native" />
</id>
<property
name="denomination"
type="string"
column="denomination"
length="256"
/>
<property
name="formeJuridique"
type="string"
column="formeJuridique"
length="256"
/>
<property
name="nomContact"
type="string"
column="nomContact"
length="256"
/>
<property
name="registreDeCommerce"
type="string"
column="registreDeCommerce"
length="256"
/>
<property
name="identifiantFiscal"
type="string"
column="identifiantFiscal"
length="256"
/>
<property
name="cnss"
type="string"

26
column="cnss"
length="256"
/>
<property
name="tel"
type="string"
column="tel"
length="256"
/>
<property
name="fax"
type="string"
column="fax"
length="256"
/>
<property
name="email"
type="string"
column="email"
length="256"
/>
</class>
</hibernate-mapping>

e. Création du fichier de configuration hibernate.cfg.xml


<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.useUnicode">true</property>
<property name="connection.characterEncoding">UTF-8</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property
name="connection.url">jdbc:mysql://localhost:3306/GestionBudgetaire</property>
<property name="connection.username">root</property>
<property name="connection.password">agadir</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="current_session_context_class">thread</property>
<property
name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFacto
ry</property>
<mapping resource="net/backend/vo/Creancier.hbm.xml"/>
</session-factory>
</hibernate-configuration>

27
f. Création de la classe HibernateUtil
package net.backend.persistence;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.Session;

public class HibernateUtil {

private static SessionFactory sessionFactory;

public static void createSessionFactory() {


sessionFactory = new Configuration().configure().buildSessionFactory();
}

public static Session getSession() {


return sessionFactory.openSession();
}

}
g. Création de l’interface CreancierDao
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package net.backend.persistence;

/**
*
* @author Mounir
*/
import net.backend.vo.Creancier;
import java.util.List;

public interface CreancierDao {


public List getAllCreanciers();
public Creancier getCreancier(Integer id);
public void update(Creancier creancier);
public void insert(Creancier creancier);
public void delete(Integer id);
}
h. Création de l’implémentation CreancierHibernateDao
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package net.backend.persistence;

/**
*
* @author Mounir
*/

import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import net.backend.vo.*;

public class CreancierHibernateDao implements CreancierDao{


private List<Creancier> creancierList;
private Creancier creancier;

28
public List getAllCreanciers() {
Session session = HibernateUtil.getSession();

try {
session.beginTransaction();
creancierList = session.createQuery("from Creancier").list();
return creancierList;
} catch (HibernateException e) {
throw e;
} finally {
session.close();
}
}

public Creancier getCreancier(Integer id) {


Session session = HibernateUtil.getSession();
try {
session.beginTransaction();
Query q = session
.createQuery("from Creancier as c where c.id
=:creancierid");
q.setInteger("creancierid", id);
return (Creancier) q.uniqueResult();
}finally {
session.close();
}
}
public void insert(Creancier creancier) {
Session session = HibernateUtil.getSession();
Transaction tx=null;
try {
tx = session.beginTransaction();
session.save(creancier);
tx.commit();
} catch (RuntimeException e) {
if(tx != null) tx.rollback();
throw e;
} finally {
session.close();
}
}
public void update(Creancier creancier) {
Session session = HibernateUtil.getSession();
Transaction tx = null;
try {
tx=session.beginTransaction();
session.update(creancier);
tx.commit();
}catch (RuntimeException e) {
if(tx != null) tx.rollback();
throw e;
} finally {
session.close();
}
}
public void delete(Integer id) {
Session session = HibernateUtil.getSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
creancier = (Creancier)session.get(Creancier.class, id);
session.delete(creancier);
tx.commit();
} catch (RuntimeException e) {
if(tx != null) tx.rollback();
throw e;
} finally {
session.close();

29
}
}
}

i. Test de la classe CreancierHibernateDao


Création de la classe DataBaseConnection auxilière pour les tests unitaire
package test.java.net;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author Mounir
*/
import java.sql.*;
import org.apache.log4j.Logger;

public class DataBaseConnection {


Connection conn;
Statement st;
ResultSet rs;
public DataBaseConnection(){
try{
Class.forName("com.mysql.jdbc.Driver").newInstance();
String url = "jdbc:mysql://localhost:3306/gestionBudgetaire";
conn = DriverManager.getConnection(url, "root", "agadir");
st = conn.createStatement();
}
catch (ClassNotFoundException ex) {System.out.println(ex.getMessage());}
catch (IllegalAccessException ex) {System.out.println (ex.getMessage());}
catch (InstantiationException ex) {System.out.println (ex.getMessage());}
catch (SQLException ex) {System.out.println (ex.getMessage());}
}
public ResultSet getSelection(String sql) {
try {
rs = st.executeQuery(sql);
}
catch (SQLException ex)
{
logger.fatal(ex.getMessage());
}
return rs;
}
public int getNumberOfRecords(String sql) {
rs = getSelection(sql);
int i = 0;
try {
while (rs.next())
i++;
}
catch (SQLException ex)
{
logger.fatal(ex.getMessage());
}
return i;
}
public void execute(String sql) {
try {
st.executeUpdate(sql);
//conn.commit();
}
catch (SQLException ex){
logger.fatal(ex.getMessage());
}
}}

30
Création du la classe du test unitaire CreancierHibernateDaoTest
package test.java.net;

import java.util.List;
import java.sql.*;
import junit.framework.*;
import org.apache.log4j.Logger;
import net.backend.persistence.CreancierHibernateDao;
import net.backend.persistence.HibernateUtil;
import net.backend.vo.Creancier;

public class CreancierHibernateDaoTest extends TestCase {

DataBaseConnection dbConn;
CreancierHibernateDao dao;

public CreancierHibernateDaoTest(String text){


super (text);
HibernateUtil.createSessionFactory();
}
@Override
protected void setUp() {
dbConn = new DataBaseConnection();
dao = new CreancierHibernateDao();
deleteAllCreanciers();
setUpRecord();
}
@Override
protected void tearDown() {
dbConn = null;
dao = null;
}

private void deleteAllCreanciers() {


String sql = "DELETE FROM creancier";
dbConn.execute(sql);
}

private void setUpRecord() {


String sql="INSERT INTO `creancier`
(`id`,`denomination`,`formeJuridique`,`nomContact`," +
"`registreDeCommerce`,`identifiantFiscal`,`cnss`,`tel`,`fax`,`email`)
VALUES " +
"(1,'BRIMO','Personne
Physique','ALAMI','0001','123654','100011','066000000'," +
"'028000000','mail@mail.com')";
dbConn.execute(sql);
}

public void testGetAllCreanciers() {


logger.debug("*******************Starting
testGetAllCreanciers*******************");
int i = 0;
List creanciers = dao.getAllCreanciers();
assertEquals(creanciers.size(), 1);
Creancier c = (Creancier) creanciers.get(i);
assertEquals(c.getDenomination(), "BRIMO");
}
public void testGetCreancier() {
Creancier c = dao.getCreancier(1);
assertEquals(c.getDenomination(), "BRIMO");
}
public void testInsertCreancier() {
logger.debug("*******************Starting testInsertCreancier*******************");
Creancier c = new Creancier();
c.setId(2);
c.setCnss("1234");

31
c.setDenomination("NAJAHI");
c.setEmail("mail@mail.com");
c.setFax("028823456");
c.setFormeJuridique("Personne physique");
c.setIdentifiantFiscal("0987");
c.setNomContact("Mounir NAJAHI");
c.setRegistreDeCommerce("4565");
c.setTel("028846789");
dao.insert(c);
String sql = "SELECT * FROM creancier";
int numberOfRecords = dbConn.getNumberOfRecords(sql);
assertEquals(numberOfRecords, 2);
}
public void testUpdateCreancier() {
logger.debug("*******************Starting testInsertCreancier*******************");
Creancier c = dao.getCreancier(1);
c.setDenomination("NAJAHI Soft");
dao.update(c);
assertEquals(c.getDenomination(), "NAJAHI Soft");
}
public void testDeleteCreancier() {
logger.info("*******************Starting testDeleteCreancier*******************");
dao.delete(1);
String sql = "SELECT * FROM creancier";
int numberOfRecords = dbConn.getNumberOfRecords(sql);
assertEquals(numberOfRecords, 0);
}}

Création du test suite:


package test.java.net;

import junit.framework.Test;
import junit.framework.TestSuite;

public class ApplicationTestSuite extends TestSuite {

public static Test suite(){


TestSuite suite = new TestSuite();

suite.addTest(new CreancierHibernateDaoTest("testGetAllCreanciers"));
suite.addTest(new CreancierHibernateDaoTest("testInsertCreancier"));
suite.addTest(new CreancierHibernateDaoTest("testUpdateCreancier"));
suite.addTest(new CreancierHibernateDaoTest("testDeleteCreancier"));
return suite;
}}

32
Exécution en utilisant Ant:
test:
Testsuite: test.java.net.ApplicationTestSuite
Tests run: 4, Failures: 0, Errors: 0, Time elapsed: 1,218 sec

33
VI. Struts 2
1. Définition
Apache Struts2 est un framework de développement d’applications web de seconde
génération implémentant le design pattern modèle-vue-contrôleur (MVC).

Apache Struts2 est un framework élégant, extensible pour la création d’applications web Java.

Contrairement à ce que peut indiquer le nom, Struts 2 n’est pas une continuation de Struts 1
mais une fusion entre les frameworks Struts 1 et WebWork.

Struts 2 est créé pour répondre aux faiblesses de Struts 1 et particulièrement le fort
couplage des actions avec le framework et l’obligation de re-décrire un javabean pour
récupérer un formulaire.

La première version stable (2.0.6) est disponible depuis fin février 2007.

2. Architecture générale:
Struts2 est un framwork basé sur le modèle MVC :

• Le FilterDispatcher joue le rôle du Contrôleur.

• L’action joue le rôle du Model

• Le Result joue le rôle de la Vue.

Le cycle de vie standard de Struts 2 est définit par le schéma ci-dessous :

• Une fois le « dispatcher filter » passé, la requête est soumise aux intercepteurs. Ces
derniers ont pour rôle d’effectuer des pre/post traitements sur la requête (gestion des
exceptions, upload de fichier, validation…).

• L’action est instanciée, peuplée puis le formulaire est validé.

34
• Invocation de la méthode contenant la logique de l’action.

• Délégation de l’affichage à la vue.

3. Configuration :
a) Télécharger Struts2
Pour utiliser le framework Struts2, il faut d’abord le télécharger.

Par la suite, il faut mettre les fichiers jar ci-après dans le répertoire lib de votre application.

• struts2-core.jar

• xwork.jar

• ognl.jar

• freemarker.jar

• commons-logging.jar

b) Fichier de configuration web.xml


La configuration minimale du fichier web.xml pour un projet Struts 2 est la suivante :

35
Les éléments les plus importants dans le fichier web.xml sont filter et filter-mapping utilisés
pour la configuration du FilterDispatcher.

Le FilterDispatcher est la servlet de base du framework Struts 2, il permet de traiter toutes les
requêtes en entrée, il permet l'accès aux éléments de base (ConfigurationManager,
ActionMapper, ObjectFactory …) du framework pour traiter les requêtes.

c) Fichier de configuration struts.xml

Le fichier struts.xml permet de configurer le mapping entre l'URL et l'implémentation de


l'action. Ce fichier doit être dans le dossier src.

Le fichier struts.xml peut contenir les balises suivantes: constant, package, include,
et bean.

j. La balise constant :

Struts 2 permet de définir des constantes dans le ficher de configuration struts.xml, ces
constantes peuvent être aussi définies dans le fichier de configuration struts.properties.

Il faut juste faire attention à l'ordre de chargement des fichiers de configuration de Struts car
une constante définie dans un fichier peut être 'overiden' dans un autre fichier chargé après.
36
L'ordre de chargement des fichiers de configuration est le suivant:

• web.xml

• default.properties dans Struts JAR

• struts.properties dans WEB-INF/classes

• struts-plugin.xml dans chaque plug-in JAR

• struts.xml dans WEB-INF/classes

k. La balise package :

La configuration de l'application peut être fragmentée en package. On peut par exemple créer
un package pour chaque module de l'application ou par chaque fonctionnalité.

La synthaxe est la suivante:

<package name=”test” extends=”struts-default” abstract=”false” namespace=”/tests” >



</package>

• name: nom du package, il doit être unique.

• extends: un package peut extends un autre package, ce qui permet d'accéder à toutes
les propriétés du package parent.

• abstract: si le package est abstract il ne peut pas être accédé à partir d'une URL, il est
juste utilisé pour l'organisation de la configuration.

• namespace: indique le chemin depuis laquelle les actions vont être accessibles.

Il est recommandé d'étendre le package par défaut struts-default pour ne pas être obliger à
redéfinir des intercepteurs nécessaire pour le fonctionnement de Struts 2.

4. Action
La seule contrainte pour les actions, avec Struts 2, est le fait qu’elles doivent implémenter au
moins une méthode du type 'no-argument' qui doit retourner un String ou un objet Result, si
non on peut utiliser la méthode execute ().

Avec Struts 2, il n'est pas obligatoire d'hériter d'une action générique, mais les actions peuvent
hériter de la classe générique ActionSupport qui implémente la méthode execute().

37
La classe ActionSupport implémente plusieurs interface telles que Action, Validateable
et ValidationAware interfaces.

Ci-après un exemple d’action Struts2 :

5. JSP
Enfin on crée la page JSP :

38
39
VII. Annexe
1. Installation de l’environnement de travail:
Installez JDK

Ajoutez le chemin C:\Program Files\Java\jdk1.6.0_02\bin au PATH

installez netbeans

installez tomcat

installez Mysql

installez Ant

Ajoutez le chemin du répertoire bin de Ant au path.

Settez dans variable d’environnement ANT_HOME le chemin du repertoire d’installation Ant.

Optionnellement, settez dans la variable d’environnement JAVA_HOME le chemin où le JDK a


été installé

40