WOOPS Architecture Logicielle M1 IUP ISI

publicité
M1 IUP ISI - 2005/2006
PROJET WOOPS
woopsproject.free.fr
Architecture Logicielle
V 1.1
WOOPS
IUP ISI 2005/2006
Architecture Logicielle
2/11
WOOPS
Architecture Logicielle
HISTORIQUE DES REVISIONS
Versions
Dates
Modifications
Auteurs
0.1
17/04/2017
Création du document
Nicolas Ricard
1.0
24/10/2005
Finalisation d’une première version
Nicolas Ricard
1.1
21/11/2005 Mise à jour
IUP ISI 2005/2006
Nicolas Ricard
3/11
WOOPS
Architecture Logicielle
TABLE DES MATIERES
1
INTRODUCTION .............................................................................................................. 5
2
METHODE ........................................................................................................................ 6
3
STRUCTURE LOGICIELLE ............................................................................................ 9
IUP ISI 2005/2006
4/11
WOOPS
Architecture Logicielle
INTRODUCTION
1 INTRODUCTION
1.1
Objectifs du document
Ce document décrit toute l’architecture logicielle du projet WOOPS.
1.2
Portée
Ce document est destiné à tous les membres de l’équipe de développement ainsi qu’aux
superviseurs du projet, Mr CHERBONNEAU et Mr AUBRY.
IUP ISI 2005/2006
5/11
WOOPS
Architecture Logicielle
2 METHODE
Le framework Open Source Jakarta Struts, un des standards pour le développement
d’applications Web en Java.
Struts combine deux technologies largement répandues, JSP et servlets, en une
implémentation du design pattern Modèle Vue Contrôleur.
Struts implémente l’architecture MVC côté serveur à l’aide d’une combinaison de pages JSP,
de balises, ou tags, personnalisées et de servlets Java.
Le processus Struts peut être divisé en cinq étapes fondamentales :
Une requête est envoyée depuis une page précédemment affichée.
La requête est reçue par la servlet ActionServlet, qui fait fonction de contrôleur. Celle-ci
recherche l’URI correspondant dans un fichier XML et détermine le nom de la classe Action
capable d’effectuer le traitement correspondant.
La classe Action effectue le traitement en utilisant les composants du modèle associé à
l’application.
Lorsque la classe Action a terminé le traitement, elle rend le contrôle à la servlet
ActionServlet tout en lui transmettant une clé indiquant le résultat. La servlet ActionServlet
décide, en fonction de cette clé, si le résultat doit être transmis pour présentation.
La requête est terminée lorsque la servlet ActionServlet répond en transmettant celle-ci à la
vue correspondant à la clé retournée. La vue affiche le résultat du traitement.
IUP ISI 2005/2006
6/11
WOOPS
Architecture Logicielle
De plus, l’architecture MVC présente plusieurs avantages :
Fiabilité. Les couches présentation et transaction sont clairement séparées, ce qui permet de
modifier l’aspect d’une application sans recompiler le modèle ni le contrôleur.
Réutilisation et adaptabilité. L’architecture MVC autorise l’utilisation de plusieurs vues,
accédant toutes au même programme sur le serveur, par exemple des navigateurs Web
(HTTP) ou des terminaux sans fil (WAP).
Coûts de développement et d’évolution réduits. L’architecture MVC permet de confier le
développement et la maintenance des interfaces à des programmeurs moins expérimentés.
Déploiement rapide. Les délais de développement peuvent être considérablement diminués
car les développeurs du contrôleur (programmeurs Java) se consacrent uniquement aux
transactions tandis que les développeurs des vues (programmeurs HTML et JSP) ne sont
concernés que par la présentation.
Maintenance facilitée. La séparation entre la « logique métier » (business logic) et la
présentation facilite la maintenance et l’évolution des applications Web basées sur Struts.
IUP ISI 2005/2006
7/11
WOOPS
Architecture Logicielle
Pour compléter le modèle MVC, et faciliter la gestion de la persistance, nous allons utiliser un
outil de mapping Objet/Relationnel : Hibernate.
Hibernate est un framework open source gérant la persistance des objets dans une base de
données relationnelle.
Hibernate peut être utilisé aussi bien dans un développement client lourd, que dans un
environnement J2EE complet ou dans un environnement web léger de type Tomcat (apache)
comme dans le projet WOOPS.
Dans un souci de maintenance et d’évolutivité de l’application, nous allons ajouter à ce
framework, l’utilisation du design pattern DAO via un pattern Façade.
Un DAO est un objet technique dont le rôle consiste à découpler la couche de service (métier)
de la couche d'accès aux données représentée par les DAO. Le principe d'une DAO consiste
donc à effectuer les différentes requêtes en Base afin de renvoyer à l'appelant (la couche de
service) des objets métier.
IUP ISI 2005/2006
8/11
WOOPS
Architecture Logicielle
3 STRUCTURE LOGICIELLE
L’organisation du développement se fera autour de l’utilisation d’Eclipse et de J2EE.
L’application sera découpée dans le respect des standards des Web Applications.
 src contient les sources java. Le package par défaut est src (voir nomenclature). Ce
répertoire contient aussi le fichier des libellés dynamiques (messages d’erreurs entre
autres), ainsi que le fichier de configuration d’Hibernate.
 WebContent contient les ressources « web » de l’application :
 WEB-INF, ce répertoire « technique » et propre aux Web Applications
contient le descripteur de déploiement de l’application web.xml, les différentes
bibliothèques Struts … On y trouve par ailleurs 2 sous-répertoires, lib et
classes qui contiennent l’ensemble des librairies externes (api et autres) et les
sources compilés de l’application.
 css, contient la feuille de style commune à toute l’application,
 html, ce répertoire regroupe les pages html et jsp.
 image, l’ensemble des ressources de type images sera regroupé ici,
 jscript, pour faciliter la maintenance de l’application, l’ensemble du code
JavaScript (qu’on tentera de limiter au possible pour des raisons de
compatibilité entre navigateurs).
 properties, un fichier, parametresWOOPS.properties, contiendra l’ensemble
des paramètres variable de l’application (source de données …).
 sql : Ce répertoire contient les scripts de création et d’initialisation de la base de
données.
IUP ISI 2005/2006
9/11
WOOPS
Architecture Logicielle
VUE
recupererMonObjet()
MonObjetManager
MonObjet
getMonObjet()
MonObjetDAO
getObjetPersistant()
ObjetPersistantDAO
ObjetPersistant
HIBERNATE
Requêtes
SQL
MySQL
Ressource JNDI (Pool de connexions)
Jndi/
Tomcat
S'il on veut changer de type de gestion de la persistance, il suffira de remplacer le DAO
Hibernate par autre chose. La partie Vue n'en sera pas affecté, elle est protégée par
l’utilisation de la Façade (le Manager)
L'appel au manager via la partie vue (typiquement, depuis une Action) est du style :
MonObjetManager.getInstance().getMonObjet() ; Ceci affin de respecter un autre
pattern, le Singleton, qui garantie l’unicité de l’instance du Manager au niveau de
l’application (un seul point d’entrée pour chaque donnée à chaque instant).
IUP ISI 2005/2006
10/11
WOOPS
MaPage.jsp
(vue)
Architecture Logicielle
struts-config.xml
(vue)
Classe
Form
(vue)
Classe
Action
(vue)
Classe
métier
Classe
Manager
(singleton)
Fichier de
Mapping
Hibernate
(traduction
BD/Java –
Jaava/BD)
Classe
DAO
(pattern façade)
Base
de
Données
IUP ISI 2005/2006
11/11
Téléchargement