Professional Documents
Culture Documents
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.
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 {
/**
* 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
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 > »
7
public class Male extends Person {
public Male(String fullName) {
System.out.println("Hello Mr. "+fullName);
}
}// End of class
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
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.
Cinématique
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.
• 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;
suite.addTest(new MathHelperTest("testCarre"));
return suite;
14
}
}
• 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.
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.
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
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.
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
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>
21
<test name="test.java.net.ApplicationTestSuite" />
</junit>
</target>
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.
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() {
}
25
public String getRegistreDeCommerce() {
return registreDeCommerce;
}
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>
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;
}
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;
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.*;
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();
}
}
29
}
}
}
/**
*
* @author Mounir
*/
import java.sql.*;
import org.apache.log4j.Logger;
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;
DataBaseConnection dbConn;
CreancierHibernateDao dao;
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);
}}
import junit.framework.Test;
import junit.framework.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 :
• 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…).
34
• Invocation de la méthode contenant la logique de l’action.
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
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.
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
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é.
• 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.
5. JSP
Enfin on crée la page JSP :
38
39
VII. Annexe
1. Installation de l’environnement de travail:
Installez JDK
installez netbeans
installez tomcat
installez Mysql
installez Ant
40