Le document présente un projet de développement d'application répartie utilisant des technologies Java EE, en se concentrant sur la gestion des articles dans un système GPAA. Il aborde les choix méthodologiques, les architectures logicielles, et les différentes technologies et frameworks impliqués, tout en identifiant les problématiques et les perspectives d'amélioration. Le projet vise à maîtriser plusieurs aspects du développement, y compris la conception orientée objet et l'intégration de différents composants.

1. INSTITUT SUPÉRIEUR DES ÉTUDES TECHNOLOGIQUES DE SOUSSE
1
 Réalisé par : Akid Ahmed
Tarchouni Marouene
 Encadré par: Mr Khalifa Nouri

2. 2
Choix méthodologique
Technologies Java EE
Etude architecturale
Conclusion et Perspective
Réalisation
Plan
Mise en application—Gestion des Articles
Branche Fonctionnelle
Branche Technique
Conception
Introduction

3. 3

4.  Notre projet :
Etude et mise en œuvre des technologies des applications réparties
 Proposé par: Mr. KHALIFA Nouri
 Lieu de stage: ISET Sousse
 Objectifs:
◦ Etudier et manipuler différentes architectures logicielles réparties
◦ Etudier et manipuler différentes technologies JAVA EE
◦ Maitriser les Framework les plus répondus pour le développement des applications
JAVA EE orientées Web.
◦ Maitriser une méthode de conception
◦ Mise en Application:
 Module GPAO: Gestion des articles
4

5. 5

6. 6
Choix méthodologique:
Les méthodes OO
2TUP (Two Truck Unified Process )
Les méthodes descendantes ou systémique
Les méthodes ascendantes
Les méthodes Agile
SADT, Jackson,Yourdon,…
MERISE, SART,…
OOD,HOOD, OOA,OMT, OOSE, RUP,…
ASD,RAD, XP, Scrum, …

7. 7
Méthodologie utilisée « 2TUP »:

8. 8

9. Servlet
9
Technologies Java EE et Framework:
JSP
JPA
 Frameworks
Hibernate
Spring
JSF
Flex
Blaze DS
 Composants
Et spécification
…

10. 10

11. 11
Etude architecturale:
JSP
MySQL/PostgreSQL
JDBC
JSF JDBC
JSF Hibernate
JSF JPA
JSF Spring JPA
JSF Spring Hibernate
Flex Spring Hibernate
Flex Blaze DS Spring Hibernate
JSF/flex EJB JPA/Hibernate

12. 12
Architecture en couche et Frameworks:

13. 13
 Architecture JSF:

14.  Architecture Hibernate:
14

15.  Architecture Spring:
15

16. 16
 Architecture BlazeDS:

17. 17

18. 18
 Contexte de l’application: Module GPAO
Les fonctionnalités d’une GPAO:

19.  Limites des systèmes existants:
19
Absence
d’interface
conviviale
La plupart sont
trop chargées
d’informations
Absence
d’arabisation
Absence de
gestion de
thèmes
Absence de
gestion des
images

20. 20

21. 21
AdministrateurAgent de Saisie
Agent Commercial Responsable
Super Administrateur
Application
 Identification des acteurs:

22. 22
Acteur
UC
Agent de Saisie Administrateur Agent Commercial Responsable Super Administrateur
Gestion des Articles X X
Gestion de Famille X X
Gestion de Sous Famille X X
Gestion des Unités X X
Gestion des dépôts X X
Gestions de Paramètre
de l’entreprise
X X
Gestion des utilisateurs X X
Gestion de Configuration X X
Gestions des Clients X X
Gestion des Fournisseurs X X
 Identification de cas d’utilisation:

23. 23
<<include>>
<<include>>
<<include>>
<<include>>
Agent de Saisie
Gestion famille
Gestion Sous-famille
Gestion des unités
Gestion des articles
S'authentifier
 Diagramme de cas d’utilisation:
«Agent de saisie »

24. 24
DiagrammeSequence_Création d'un article
Sélectionne pour créer d'un article
Vérification
affichage de Résultat
Erreur
Saisie les données et Valide
Affichage le formulaire d’ajout
Requête SQL
Réponse SQL
Agent de Saisie
Système BD
[Echec]
[ Succès ]
alt
Sélectionne pour créer d'un article
Vérification
affichage de Résultat
Erreur
Saisie les données et Valide
Affichage le formulaire d’ajout
Requête SQL
Réponse SQL
 Diagramme de séquence :
«Création d’article »

25. 25

26. 26
 Architecture de l’application:
• JSF – Spring - Hibernate
• Flex – Blaze DS –Spring- Hibernate
• Tomcat, JBoss, Glassfish
Serveur d’application:

27. 27
Architecture JSF –Spring-Hibernate:

28. 28
Architecture Flex–BlazeDS-Hibernate:

29. 29

30.  Pour chaque cas d’utilisation:
1. Conception d’interface.
2. Conception de la couche DAO (unique pour tous
les UC: générique).
3. Conception de la couche service.
4. Conception de la couche de persistance
(diagramme de classe).
5. Diagramme de séquence détaillé.
DANS LA SUITE:
Conception détaillée de UC: Création d’article.
30

31. 31
Conception d’interface:
«Création d’article»

32. 32
Conception de la couche persistance:

33. <<Dépendance>>
<<Dépendance>>
GenricDaoImpl
- genericDaoImpl : GenricDaoImpl
+
+
+
+
+
+
+
+
+
+
+
save ()
estSave ()
update ()
merge ()
delete ()
findById ()
load ()
findByCritere ()
count ()
findAll ()
findLazy ()
...
: void
: boolean
: void
: Article
: void
: Object
: Object
: List
: Object
: List
: List
GenricDao
- genericDao : GenricDao
+
+
+
+
+
+
+
+
+
+
+
save ()
estSave ()
update ()
merge ()
delete ()
findById ()
load ()
findByCritere ()
count ()
findAll ()
findLazy ()
...
: void
: boolean
: void
: void
: void
: Object
: Object
: List
: Object
: List
: List
HibernateDaoSupport
- hibernateDaoSupport : HibernateDaoSupport
DaoSupport
- logger : Log
33
Conception de la couche DAO: «Générique»
Conception générique:
conséquence de:
• La programmation
générique à partir de
java 5.
• HibernateDaoSupport.

34. 34
<<interface>>
ArticleService
+
+
+
+
+
+
+
+
+
save ()
estSave ()
update ()
merge ()
delete ()
findByCritere ()
count ()
findAll ()
findLazy ()
: void
: boolean
: void
: void
: void
: List
: long
: List
: List
ArticleServiceImpl
- genericDao : GenericDao
+
+
+
+
+
+
+
+
+
save ()
estSave ()
update ()
merge ()
delete ()
findByCritere ()
count ()
findAll ()
findLazy ()
: void
: boolean
: void
: void
: void
: Lis<Article>
: long
: List<Article>
: List<Article>
Conception de la couche Service:
«Création d’article »

35. 35

36. 36
Fichiers de configuration

37. 37
Réalisation JSF-PrimeFaces:

38. 38
Réalisation Flex:

39. 39

40.  Contexte
◦ ISET
◦ Plateforme JAVA EE et technologies avancées
◦ Mise en application: GPAO
 Problématiques:
◦ Volumineux
◦ Complexité de sujet (GPAO)
◦ Nouvelle méthodologie de conception: 2TUP
◦ Différents Frameworks et leur intégration
◦ Formation avancée en java ( programmation générique,
conception orientée interface, les collections, …)
◦ Autoformation des différents Frameworks.
◦ Choix délicat entre les technologies.
◦ Rédaction de rapport.
◦ Temps insuffisant (4mois).
40
Conclusion:

41. ◦ Etre méthodique et travail en groupe.
◦ Des techniques de conception avancée ( conception MVC,…)
◦ Comprendre différents types d’architecture logicielle.
◦ Maitriser à des niveaux différents des Frameworks très répandus dans
le monde JAVA EE.
◦ Maitriser concrètement la différence entre un client léger et un client
riche (RIA).
◦ Comprendre et manipulation en pratique quelques design pattern:
 DAO
 IOC
 AOP (AspectJ, SpringAOP)
◦ Comprendre l’utilité de la programmation par interface pour avoir un
couplage faible entre les couches.
◦ Comprendre la programmation en se basant sur des composants:
 Composants JSF, primefaces, etc.
 Composants Flex.
◦ Maitriser la configuration en XML et / ou avec Annotation
 Spring (beans, AOP, IOC)
 Hibernate
 Integration Spring JSF
 Integration Spring Flex
Internationalisation d’une application, programmation des thèmes
Apprentissage de:
 CSS, AJAX , ActionScript3,
41
Apports:

42.  Taux de réalisation: ≃30%
 Taux de satisfaction:….
 Perspectives:
◦ Achever l’application.
◦ Relancer des projets pour les autres modules de
GPAO.
◦ Etudier en détail les Frameworks utilisées.
◦ Etudier comment utiliser les technologies suivantes:
 Les services web et les SOA.
 Cloud.
42
Perspective:

43. 43