Tiers Web dans J2EE:

Frameworks JSF et Spring MVC pour Securite

Pr R.ALAOUI

1
Plan
- Introduction
- Architecture MVC
- Servlet 3.0
- Bibliothèques de tags JSTL
- Framework JSF
- Utilisation d’Ajax avec JSF
- JSF et sécurité
- Framework Spring
- Injection des dépendances (Ioc) avec Spring
- Couplage Fort-faible et Integration de Spring ds une Application

2
Plan
- Présentation et historique

- Servlet 3.0

- bibliothèques de tags Java Standard Tag Library (JSTL):

Core , XML, FMT (internationalisation), FUNCTION et SQL

- JavaServer Face (JSF): les pages Facelets, composants JSF

- Contexts and Dependency Injection (CDI)

- Utilisation d’Ajax

- Sécurité 3
Introduction
- La création de pages dynamiques permet d’afficher de façon optimisée les informations
de l’application en mêlant des contenus statiques comme des images, animations ou
autres.

- Les architectures Java EE étudiées reposent sur le modèle de conception ou patron de

conception (design pattern) MVC pour Modèle Vue Contrôleur.

- La couche ou tiers Web permet de réaliser la logique applicative des projets Web.
Ainsi, la couche Web concerne les parties V et C du modèle de conception.

4
Tiers Web dans J2EE

5
Une application Web Java EE est composée de fichiers appelés ressources et d’un
descripteur de déploiement facultatif : /WEB-INF/web.xml.

Les ressources regroupent:

- les parties statiques (JavaScript, CSS, images...)
- les parties dynamiques (classes, Servlets, pages Web...).

La couche Web est nécessaire pour l’interaction entre les utilisateurs et les
applications. Avec l’arrivée des technologies Web 2.0, les applications dialoguent avec
plusieurs composants et les résultats affichés sont de plus en plus évolués et complexes.

En effet, le tiers Web mélange plusieurs technologies comme HTML / XHTML, CSS,
JavaScript mais également JSP, EL et JSTL, et utilise couramment le design pattern
Modèle Vue Contrôleur.
6
HyperText Markup Language (HTML) est actuellement le langage le plus utilisé sur le
Web. Ce langage de création des pages ne respecte pas une syntaxe stricte et peut donc
devenir illisible et mal interprété par les navigateurs.

Extended HyperText Markup Language (XHTML), sorti après HTML, propose une
version HTML mais de façon stricte afin de respecter les normes XML. En effet, les
documents XHTML doivent être valides (respecter des règles) et bien formés (être
conformes à une grammaire).

Cascading Style Sheets (CSS) est un langage de styles utilisé pour la mise en
page des documents XHTML. Ce langage permet de séparer le contenu du document
(XHTML) et la présentation (CSS).

7
Architecture MVC
L’architecture MVC sépare la logique métier de l’affichage. Dans ce modèle, un composant
est chargé de recevoir les requêtes (Servlets), un autre traite les données (Classes) et
un troisième gère l’affichage (JSP ou autres).

Si l’interfaçage entre ces trois

composants est clairement
défini, il devient plus simple
de modifier un composant
sans toucher aux deux autres.

8
Architecture MVC
● Modèle : Le modèle englobe la logique métier et les données sur lesquelles il
opère. Toute classe Java qui manipule les données peut jouer le rôle du modèle et de
nombreuses applications Web utilisent uniquement des Servlets ordinaires (ou des classes
avec JDBC pour manipuler les bases de données).

● Vue : Lorsque la requête courante est traitée, la logique de présentation est réalisée par
une vue spécifique.

● Contrôleur : Le composant contrôleur reçoit les requêtes des clients, les traite et les
transmet aux composants chargés de traiter les données. Les Servlets sont les composants
dont la structure est la plus adaptée. Une Servlet est conçue pour recevoir les requêtes
des clients et leur retourner une réponse, ce qui est précisément le rôle du contrôleur.
9
Tiers Web
Le tiers Web peut être configuré de façon statique à l’aide d’un fichier XML sans nécessiter
une recompilation du code source.
Ce fichier XML nommé web.xml est placé dans le répertoire /WEB-INF du projet Java EE, et
appelé descripteur de déploiement de l’application.

10
Servlet 3.0
L’API Servlet a subi de nombreuses évolutions et améliorations depuis qu’elle est apparue.

La première de ces évolutions est maintenant placée dans l’API JSP (Java Server Pages).

Une deuxième API est née à partir des évolutions de JSP : JSTL (Java Server Tag Libraries).

Depuis la spécification Servlet 3.0, il est possible de se passer de fichier web.xml pour
déclarer un servlet:
Annoter la classe du servlet par l’annotation @WebServlet

11
Les bibliothèques de tags Java Standard Tag Library (JSTL)
Il existe de nombreuses librairies de tags (utilisables à partir de balises XML) proposées pour
la technologie JSP Java.

Les responsables Java EE se sont aperçus que de nombreux développeurs dépensaient

beaucoup d’énergie pour créer de nouvelles balises répondant souvent aux mêmes besoins.
Ces actions avaient des syntaxes et des noms différents mais accomplissaient pratiquement
la même chose.

Le but de JSTL (JavaServer page Standard Tag Library) est de standardiser un certain
nombre d’actions.

JSTL est donc un ensemble de tags personnalisés permettant : de réaliser des opérations de
structure (conditions, itérations...), de gérer les langues, d’exécuter des requêtes SQL et
d’utiliser le langage XML.

12
Les bibliothèques de tags Java Standard Tag Library
La librairie de balises JSTL contient plusieurs bibliothèques pouvant être utilisées dans des
pages JSP ou JSF. Ces librairies sont proposées en standard et nécessitent les déclarations :
Bibliothèque Déclaration JSP Déclaration JSF Préfixe
utilisé
Core <%@ taglib uri= xmlns:c="http://java.sun <c:/>
"http://java.sun.com/jsp/ .com/jsp/jstl/core"
jstl/core" prefix="c" %>
XML <%@ taglib uri= xmlns:xml="http://java.sun <x:/>
"http://java.sun.com/ .com/jsp/jstl/xml"
jsp/jstl/xml" prefix="x" %>
Internationalisation <%@ taglib uri= xmlns:fmt="http://java.sun <fmt:/>
i18n et formatage "http://java.sun.com/jsp/ .com/jsp/jstl/fmt"
des expressions jstl/fmt" prefix="fmt" %>
Bases de données <%@ taglib uri= xmlns:sql="http://java.sun <sql:/>
"http://java.sun.com/jsp/ .com/jsp/jstl/sql"
jstl/sql" prefix="sql" %>
Fonctions <%@ taglib uri= xmlns:fn="http://java.sun. <fn:/>
"http://java.sun.com/jsp/ com/jsp/jstl/fn"
jstl/functions"
13
prefix="fn" %>
Les bibliothèques de tags Java Standard Tag Library
Avant une utilisation dans une page JSP ou JSF, la bibliothèque doit être importée et définir
le préfixe pour les balises.
Par exemple, la déclaration suivante en début de page JSP
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
permet d’utiliser par la suite des balises préfixées par la lettre c comme
<c:forEach var="etudiant" begin="0" items="${etudiants.rows}">.

Avec c:forEach : permet de réaliser une boucle sur une collection d’objets.

Même chose pour JSF

xmlns:c="http://xmlns.jcp.org/jsf/core">

14
Les bibliothèques de tags Java Standard Tag Library
1. La bibliothèque Core
La bibliothèque Core permet de manipuler les variables, de réaliser des tests
conditionnels ou de réaliser des itérations.
La bibliothèque Core est présentée de façon non exhaustive :
● <c:set/> : permet de positionner une valeur à une variable.
● <c:out/> : permet d’afficher la valeur d’une variable ou expression.
● <c:if/> : permet de réaliser un test conditionnel sur une expression.
● <c:when/> : permet de réaliser l’alternative à la conditionnelle <c:if/>.
● <c:choose/> : permet de réaliser une conditionnelle multiple.
● <c:when/> : permet de réaliser l’alternative à la conditionnelle <c:choose/>.
● <c:otherwise/> : permet de réaliser l’alternative à la conditionnelle <c:choose/>.
● <c:forEach/> : permet de réaliser une boucle sur une collection d’objets.
● <c:import/> : permet d’importer une ressource.
● <c:redirect/> : permet de réaliser une redirection d’URL.

15
Les bibliothèques de tags Java Standard Tag Library
2. La bibliothèque XML
La bibliothèque XML propose les mêmes services que la bibliothèque Core mais sur
les fichiers au format XML.
● <x:out/> : permet d’afficher le contenu d’une expression XML.
● <x:set/> : permet de stocker le résultat d’une évaluation XML dans une variable.
● <x:parse/> : permet de parser un document XML.
● <x:transform/> : permet d’appliquer une feuille de style XSLT sur un document XML.
● <x:if/>, <x:choose/>, <x:when/>, <x:otherwise/>, <x:forEach/> : permet de réaliser les
mêmes actions que la bibliothèque Core.
● <x:param/> : permet de passer un paramètre à une balise utilisatrice.

16
Les bibliothèques de tags Java Standard Tag Library
3. La bibliothèque FMT
La bibliothèque de formatage FMT permet de gérer les sites multilingues avec le mécanisme
d’internationalisation et de formater l’affichage des dates, nombres, chiffres à virgules et
pourcentages:
● <fmt:message/> : permet d’afficher un message internationalisé dans un fichier de
propriétés.
● <fmt:param/> : permet de passer un paramètre à la balise <fmt:message/>.
● <fmt:bundle/> : permet de déterminer le fichier de langues ou traduction (resouce bundle) à
utiliser.
● <fmt:setLocale/> : permet de changer la locale courante afin de changer dynamiquement la
langue.
● <fmt:formatNumber/> : permet de formater une valeur numérique dans la locale choisie.
● <fmt:parseNumber/> : permet de parser la chaîne.
● <fmt:formatDate/> : permet de formater les dates et heures utilisées en fonction de la locale.

17
Les bibliothèques de tags Java Standard Tag Library
4. La bibliothèque SQL
La bibliothèque SQL permet d’interagir avec une base de données à partir de requêtes. Elle
permet d’accéder à un SGBD à partir des pages Web. La bibliothèque SQL est présentée de
façon non exhaustive :
● <sql:query/> : permet de réaliser une requête vers une base de données.
● <sql:update/> : permet d’exécuter les statements INSERT, UPDATE et DELETE.
● <sql:transaction/> : permet de réaliser une transaction pour les requêtes SQL.
● <sql:setDataSource/> : permet de configurer une Data Source pour l’accès au SGBD.

18
Les bibliothèques de tags Java Standard Tag Library
5. La bibliothèque FUNCTION
La bibliothèque FUNCTION est utilisée avec le langage d’expression EL pour le
formatage des chaînes. La bibliothèque FUNCTION est présentée de façon non exhaustive :
● <fn:contains/> : permet de vérifier la présence d’une chaîne dans une autre chaîne.
● <fn:endsWith/> : permet de vérifier la présence d’une chaîne en fin de chaîne.
● <fn:startsWith/> : permet de vérifier la présence d’une chaîne en début de chaîne.
● <fn:indexOf/> : retourne l’index de la première occurrence trouvée dans une chaîne.
● <fn:escapeXml/> : permet d’échapper les caractères XML.
● <fn:join/> : permet de joindre tous les éléments dans un tableau de chaînes.
● <fn:length/> : permet de retourner la longueur d’une chaîne.
● <fn:replace/> : permet de remplacer une chaîne par une autre chaîne.
● <fn:split/> : permet de découper une chaîne en tableau à partir d ’un séparateur.
● <fn:toLowerCase/> : permet de mettre une chaîne en minuscules.
● <fn:toUpperCase/> : permet de mettre une chaîne en majuscules.
● <fn:trim/> : permet d’enlever les espaces du début et de fin dans une chaîne.
19
Rôle de Framework
Le framework facilite la mise en ouvre des fonctionnalités de son domaine d'activité:
Il permette au développeur de se concentrer sur les tâches spécifiques de l'application à
développer et de laisser au Framework les tâches techniques récurrentes :
l'architecture de base de l'application
l'accès aux données
l'internationalisation
la journalisation des événements (logging)
la sécurité (authentification et gestion des rôles)
le paramétrage de l'application
...
Framework JavaServer Faces (JSF)
- JSF est un framework Java EE utilisé pour le développement d’applications Web:
Permet de simplifier le développement d’applications Web basée sur Java EE

- JSF a été créé par un groupe de consortiums comme Sun Microsystems, Oracle

- JSF permet de :
Créer des interfaces utilisateur riches
Développer des traitements efficaces
Faciliter le développement et la réutilisation du code.

21
Constituants de JSF
JSF est constitué principalement de:
- Un ensemble d'APIs pour la représentation et la gestion des composants, de leur état, des
évènements, de la validation des entrées et la conversion des sorties, l'internationalisation
et l'accessibilité ainsi que la navigation inter-vues

- Deux jeux de composants standards (affichage de texte, saisie de texte, tables, zone à
cocher, etc.) : html et core

-Deux bibliothèques de balises JSP (une pour chaque jeu de composants) pour permettre
l'utilisation des JSPs pour la construction de vues JSF

- Un modèle évènementiel côté serveur

-Les Managed-Beans : qui forment la couche contrôle de JSF

- Langage d'expressions (abrégé en EL) (Unified Expression Language) unifié pour JSF et JSP
22
2.0. Il permet de lier les composants aux managed-beans
JavaServer Faces (JSF)
JSF est un framework MVC2 découpant les couches Vue, Contrôleur et Modèle.

JSF implémente l’architecture MVC2 :

- Le modèle est représenté par la couche Managed Bean associée à un EJB (ou toute unité de persistance),
- La vue est représentée par les pages XHTML et
- Un contrôleur unique par la Servlet FacesServlet livrée avec JSF.
FacesServlet intercepte les requêtes HTTPs et organise leurs traitements.

23
JavaServer Faces (JSF)
Lorsque nous utilisons l’attribut value des composants dans les vues avec le langage
Expression Language (EL), nous sollicitons le moteur JSF pour qu’il nous renvoie les
informations demandées.

Accès à un ManagedBean

L’annotation @javax.faces.bean.ManagedBean remplace

et rend optionnelle la déclaration du Bean managé
dans le fichier faces-config.xml. Au démarrage de
l’application, JSF parse toutes les classes annotées par
@ManagedBean et référence ces classes de façon
dynamique. 24
Les classes managées JSF (JSF - Managed Beans)
Un Managed Bean (Bean géré) est un POJO (une classe qui ne dérive d'aucune autre classe et qui n'implémente
ni une interface ni une quelconque classe spécifique) qui respecte les spécifications des Java Bean.

La portée ou durée d’accès d’un Managed Bean est définie à l’aide d’une annotation :
● @RequestScoped : utilisée par défaut et gére la portée du traitement de la requête et de la réponse associée.
Ainsi, les valeurs des attributs saisis seront conservées par le Managed Bean le temps de la requête.

● @SessionScoped : les attributs du Managed Bean ou de l ’objet lié (Backing Bean) sont conservés
dans la session utilisateur et restent donc accessibles pendant toute la durée de la session (30 minutes par
défaut).
● @ViewScoped : les attributs du Managed Bean sont accessibles uniquement dans la vue. Lorsque l’utilisateur
navigue vers une autre page ou vue, les informations sont perdues.

● @ApplicationScoped : les attributs du Managed Bean sont accessibles dans toutes les pages de l’application
mais de façon partagée pour tous les utilisateurs.
●…
25
Un Managed bean respecte les contraintes suivantes:
- La classe Managed Bean doit être annotée par @javax.faces.model.ManagedBean ou son équivalent dans le
descripteur de déploiement XML faces-config.xml.
- La classe doit avoir une portée ( par défaut la portée d'un Managed Bean est @RequestScoped).
- La classe doit être publique, non finale et non abstraite.
- La classe doit fournir un constructeur public sans paramètre qui sera utilisé par le conteneur pour créer les
instances.
- La classe ne doit pas définir de méthode finalize() .
- Pour être liés à un composant, les attributs doivent avoir des getters et des setters publics.

Exemples
@ManagedBean
@SessionScoped
public class UserBean {
@ManagedProperty(value="Camil")
private String firstName;
@ManagedProperty(value="OMARA")
private String lastName;

getters et des setters

….
26
Les Managed Beans CDI
Les Managed Beans sont reconnaissables par l'annotation @ManagedBean.

Les Managed Beans sont assez limités et JSF, dans sa dernière version, définit un modèle de
Managed bean plus flexible, qu'on peut appelé Managed Bean CDI (Contexts and
Dependency Injection).

Managed Bean CDI est lié à un context (comme, par exemple, la requête en cours, la session
actuelle du navigateur, ou même le cycle de vie du contexte de l'utilisateur).

Managed Bean CDI utilise la même syntaxe d'annotation que les Managed Beans sauf
qu'on @Named en lieu et place de l'annotation @ManagedBean.

27
Backing Beans JSF
Si le Managed Bean contient les données des formulaires présentes dans une vue (en général une vue est
associée à un Managed Bean) on l'appelle Backing Bean
Les Backing beans gèrent l'interaction entre la Vue (UI) et le Modèle.
Le terme "Backing Bean" définit un Managed Bean associé à une page web
Exemple: une vue - si le nom de la vue est login.xml le Backing Bean Associé portera le nom Login.java -); sa
portée est au niveau d'une requête.

Un Backing Bean n'est pas intégré dans la logique

métier de l'application; c'est de la responsabilité
du Backing Bean de mettre en relation les vues et
la logique métier.

Les Backing Beans font appel à

des EJB Stateles ou State-full et des classes Java
ordinaires pour effectuer les traitements qui ne
sont pas liés directement à l'interface utilisateur.

Le langage EL permet d'échanger des informations

entre les Backing Bean et les facelets correspondants 28
Exemple - Backing bean JSF

29
30
31
Les pages Facelets
Facelets est un langage déclaratif qui dérive de HTML et XML utilisé pour écrire des pages
web XHTML par JSF

Dans les premières versions de JSF (versions 1.X de JSF ) : JSP est utilisé pour la couche Vue
du modèle MVC. JSP était utilisé avec les langages Expression Language (EL) et JSTL.

Dans les versions récentes de JSF, JSF Facelets s’articule sur une bibliothèque de templates
XHTML proposant les services suivants :
● L’utilisation de XHTML pour la création de pages Web.
● Le support compatible des librairies de tags JSF et JSTL.
● Le support du langage Expression Language (EL).

32
Les pages Facelets
Facelets facilite la conception de templates et de composants composites sous forme
d'arborescence.

Avec Facelets on peut se servir aussi des balises de HTML5 et les tags spécifiques aux
composants composés (voir paragraphes sur les composants Composés).

Avec la technologie Facelets, nous pouvons gérer la navigation de façon implicite en

réduisant le code et en facilitant la mise en place du routage entre les pages.

33
Les pages Facelets
La déclaration des balises Facelets est réalisée en utilisant une déclaration de type namespace
(espace de noms) de la même manière que les librairies JSTL.
La librairie de tags Facelets est définie par l’URL http://java.sun.com/jsf/facelets et préfixée
par ui: <html xmlns:ui="http://java.sun.com/jsf/facelets"/>
La liste suivante présente toutes les balises Facelets disponibles :
● <ui:component/> : permet de créer un composant.
● <ui:debug/> : permet d’activer le débogage.
● <ui:define/> : définie le contenu devant être inséré dans la page par le moteur de template.
● <ui:decorate/> : permet de gérer les contenus dans les pages.
● <ui:fragment/> : permet d’ajouter un fragment dans la page.
● <ui:include/> : permet d’utiliser un contenu dans les pages XHTML.
● <ui:insert/> : permet d’insérer du contenu dans le moteur de template.
● <ui:param/> : permet de passer des paramètres dans un fichier inclus.
● <ui:repeat/> : permet de réaliser une boucle itérative à la manière de la balise <c:forEach/>.
● <ui:remove/> : permet d’enlever un contenu de la page.
34
● <ui:composition/> : permet de définir une composition utilisant un modèle.
Les pages Facelets
Le tableau ci-dessous présente toutes les librairies pour les pages Facelets PDL utilisées avec JSF
Bibliothèque Déclaration JSF Préfixe utilisé
Core JSTL <html xmlns:c="http://java.sun.com/jsp/jstl/core"/> <c:/>
(conditionnelles,boucles...)
Internationalisation <html xmlns:fn= <fn:/>
i18n et formatage "http://java.sun.com/jsp/jstl/functions"/>
des expressions JSTL
Les composants <html <h:/>
HTML JSF xmlns:h="http://java.sun.com/jsf/html"/>
Core JSF (conditionnelles, <html <f:/>
boucles...) xmlns:f="http://java.sun.com/jsf/core"/>
Moteur de template Facelets <html <ui:/>
xmlns:ui="http://java.sun.com/jsf/facelets"/>
Définition des composants <html xmlns:composite= <composite:/>
composites "http://java.sun.com/jsf/composite"/>

35
Configurer une application JavaServer Faces
Au démarrage de l’application, JSF vérifie l’existence du
fichier /META-INF/faces-config.xml dans chaque fichier JAR accessible par le contexte.

JSF charge également chaque fichier qui se termine par l’extension .faces-config.xml
(exemple, /META-INF/config.faces-config.xml)

36
Sécurité
- Java EE propose plusieurs mécanismes pour sécuriser des applications.
La sécurité repose sur les notions d’utilisateurs et de rôles.
Chaque rôle est associé à des permissions d’accès aux ressources.
- La plateforme Java EE s’occupe alors du contrôle d’accès aux ressources en fonction
du rôle de l’utilisateur.

- Un utilisateur authentifié est alors associé à un ou plusieurs rôles, liés à un ou plusieurs

groupes.

- L’utilisateur réalise ainsi l’authentification par identifiant et mot de passe dans une
interface. L’accès est vérifié avec le principe Java Authentification and Authorization Service
(JAAS).

37
Spring Framework Architecture
le coeur de Spring Framework 3 est composé d'un
ensemble d'une vingtaine de modules qui sont regroupés
en plusieurs grandes parties :
•Spring Core Container : regroupe les modules de base
pour mettre en œuvre le conteneur
•AOP and Instrumentation : permet de mettre en œuvre
l'AOP
•Data Acces/Integration : regroupe les modules d'accès
aux données
•Web : regroupe les modules pour le développement
d'applications web
•Test : propose des fonctionnalités pour les tests
automatisés avec Spring

Ces différents modules manipulent les concepts :

- Ioc (ou l'inversion de contrôle)
- AOP (ou la programmation par aspect)
- SpEL (ou le Spring Expression Langage)
Injection des dépendances avec Spring
• L’injection des dépendance, ou l’inversion de contrôle est un
concept qui intervient généralement au début de l’exécution de
l’application.

• Spring IOC commence par lire un fichier XML qui déclare quelles
sont les différentes classes à instancier et d’assurer les dépendances
entre les différentes instances.

• Quand on a besoin d’intégrer une nouvelle implémentation à une

application, il suffirait de la déclarer dans le fichier xml de beans
spring.
Rappels de quelque principes de conception

- Une application qui n’évolue pas meurt.

- Une application doit être fermée à la modification et ouverte à l’extension.

- Une application doit s’adapter aux changements

- Efforcez-vous à coupler faiblement vos classes.

- Programmer une interface et non une implémentation

- Etc…
Ioc (l'inversion de contrôle) ou
Injection de dépendances
Le concept de l'Ioc (ou l'inversion de contrôle) :
Permet de faire de l'injection de dépendance dans un programme et ainsi de gérer
le cycle de vie des beans

Rappel un bean et un objet java contenant des propriétés ainsi que des
getters/setters pour ces attributs).

Il est possible de faire Ioc en deux manières différentes :

- Par fichier de configuration
- Par annotations.
Ioc (l'inversion de contrôle) ou Injection de dépendances
 Couplage Fort
et
Couplage faible
Couplage fort
- Quand une classe A est lié à une classe B, on dit que la classe A est fortement couplée à la
classe B.
- La classe A ne peut fonctionner qu’en présence de la classe B.
- Si une nouvelle version de la classe B (soit B2), est crée, on est obligé de modifier dans la
classe A.
- Modifier une classe implique:
◦ Il faut disposer du code source.
◦ Il faut recompiler, déployer et distribuer la nouvelle application aux clients.
◦ Ce qui engendre un cauchemar au niveau de la maintenance de l’application
Exemple de couplage fort

package pres; package metier; package dao;

import metier.MetierImpl; import dao.DaoImpl; public class DaoImpl {
public class Presentation { public class MetierImpl { public double getValue(){
private static MetierImpl metier; private DaoImpl dao; return(5);
public static void main(String[] args) { public MetierImpl() { }
metier=new MetierImpl(); dao=new DaoImpl();
System.out.println(metier.calcul()); }
}} public double calcul(){
double nb=dao.getValue();
return 2*nb;
}}
Problèmes du couplage fort
- Dans l’exemple précédent, les classes MetierImpl et DaoImpl sont liées par un couplage
fort. De même pour les classe Presentation et MetierImpl
- Ce couplage fort n’a pas empêché de résoudre le problème au niveau fonctionnel.

- Mais cette conception ne garantit pas la propriété : une application doit être fermée à la
modification et ouverte à l’extension.

En effet, la création d’une nouvelle version de la méthode getValue() de la classe DaoImpl,

va nous obliger d’éditer le code source de l’application aussi bien au niveau de DaoImpl et
aussi MetierImpl.

- Nous allons voir que nous pourrons faire mieux en utilisant le couplage faible.
Couplage Faible
- Pour utiliser le couplage faible, nous devons utiliser les interfaces.
- Considérons une classe A qui implémente une interface IA, et une classe B qui implémente
une interface IB.
- Si la classe A est liée à l’interface IB par une association, on dit que le classe A et la classe B
sont liées par un couplage faible.
- La classe B peut fonctionner avec n’importe quelle classe qui implémente l’interface IA.
- Avec le couplage faible, nous pourrons créer des application fermée à la modification et
ouvertes à l’extension.
Exemple de coupage faible

package metier;
public interface IMetier {
public double calcul();}
package metier;
import dao.IDao; package dao;
public class MetierImpl public interface IDao {
implements IMetier { public double getValue();
private IDao dao; }
public double calcul() { package dao;
double nb=dao.getValue(); public class DaoImpl implements IDao {
return 2*nb; } public double getValue() {
// Getters et Setters return 5;
} }}
Injection des dépendances
Injection par instanciation statique
import metier.MetierImpl;
import dao.DaoImpl;
public class Presentation {
public static void main(String[] args) {
DaoImpl dao=new DaoImpl();
MetierImpl metier=new MetierImpl();
metier.setDao(dao);
System.out.println(metier.calcul());
}
}
Injection des dépendances
Injection par instanciation dynamique par réflexion:
Fichier texte de configuration : config.txt
ext.DaoImp import java.io.*;import java.lang.reflect.*;
metier.MetierImpl import java.util.Scanner; import metier.IMetier;
import dao.IDao;
public class Presentation {
public static void main(String[] args) {
try {
Scanner scanner=new Scanner(new File("config.text"));
String daoClassname=scanner.next();
String metierClassName=scanner.next();
Class cdao=Class.forName(daoClassname);
IDao dao= (IDao) cdao.newInstance();
Class cmetier=Class.forName(metierClassName);
IMetier metier=(IMetier) cmetier.newInstance();
Method meth=cmetier.getMethod("setDao",new
Class[]{IDao.class});
meth.invoke(metier, new Object[]{dao});
System.out.println(metier.calcul());
} catch (Exception e) { e.printStackTrace(); }}}
Injection des dépendances avec Spring.
- L’injection des dépendance, ou l’inversion de contrôle est un concept qui intervient
généralement au début de l’exécution de l’application.

- Spring IOC commence par lire un fichier XML qui déclare quelles sont différentes classes à
instancier et d’assurer les dépendances entre les différentes instances.
dépendances entre les différentes instances.

- Quand on a besoin d’intégrer une nouvelle implémentation à une application, il suffirait de

la déclarer dans le fichier xml de beans spring.
Injection des dépendances dans une application java standard
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd" >
<beans>
<bean id="d" class="dao.DaomImpl2"></bean>
<bean id="metier" class="metier.MetierImpl">
<property name="dao" ref="d"></property>
</bean>
</beans>
Injection des dépendances dans une application java standard

package pres;
import metier.IMetier;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Presentation {
public static void main(String[] args) {
ClassPathXmlApplicationContext context=new
ClassPathXmlApplicationContext(new String[]{"spring-ioc.xml"});
IMetier metier=(IMetier) context.getBean("metier");
System.out.println(metier.calcul());
}
}
Ioc (l'inversion de contrôle)
Je vais illustrer la manière par fichier de configuration dans les exemples suivants :
public class Personne implements Humain{
private String nom;
private String prenom;

public String getNom() {

return nom; }
public void setNom(String nom) {
this.nom = nom; }
public String getPrenom() {
return prenom;}
public void setPrenom(String prenom) {
this.prenom = prenom;}
}

Je commence par créer une première classe Personne implémentant

l'interface Humain. Cette classe est un bean possédant deux propriétés :
Nom & Prénom ainsi que leur getters et setteurs.
Ioc (l'inversion de contrôle)
public class Voiture {
Je crée ensuite une deuxième
classe que je nomme Voiture et
qui possède une marque, un
modèle et un conducteur qui
est de type Humain.
Jusque ici Spring n'intervient en
rien.
}
private String marque;
private String modele;
private Humain conducteur;
public void rouler() {
System.out.println(conducteur.getNom()+()+conducteur.getPrenom()+
"roule dans sa "+ marque +" "+ modele + "et c'est cole "); }
public String getMarque() {
return marque;}
public void setMarque(String marque) {
this.marque = marque;}
public String getModele() {
return modele;}
public void setModele(String modele) {
this.modele = modele;}
public Humain getConducteur() {
return conducteur;}
public void setConducteur(Humain conducteur) {
this.conducteur = conducteur;}
 Ioc (l'inversion de contrôle)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

<bean id="moi" class="monProjet.Personne">

<property name="nom" value = " hassani" > </property>
<property name= "prenom" value = " said" > </property>
</bean>
<bean id="ma voiture" class="monProjet.Voiture">
<property name="marque" value = " audi" > </property>
<property name= "modele" value = " A5" > </property>
<property name= « conducteur" ref = "moi" > </property>
</bean>
</bean>

C'est dans un fichier à part que Spring va agir, nomme ici bean-conf.xml et indique à
Spring comment instancier les classes et comment les injecter.
Ioc (l'inversion de contrôle)
Une fois tout cela en place, je fini par créer une classe Main dans laquelle on
réunit tout cela et que l'on exécute.
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//on donne le context d'application (fichier de configuration) à Spring
ApplicationContext context=new FileSystemXmlApplicationContext("bean-conf.xml");

//on génere une factory à partir de ce contexte

BeanFactory beanfactory=context;
//on récupere notre bean a partir son id donné dans le fichier de configuration
Voiture maVoiture=(Voiture)beanfactory.getBean("maVoiture");
//on appelle une des méthode
maVoiture.rouler();

}
}
Spring Conteneur léger et Conteneur lourd
Spring est un conteneur « léger »: une infrastructure similaire à un serveur
d'applications J2EE, prend en charge :
- la création d’objets
- la mise en relation d’objets par l’intermédiaire d’un fichier de configuration
Spring propose un framework qui utilise de simples POJO pour développer des
applications plutôt que d'utiliser des EJB complexes dans un conteneur.
Framework Spring
Spring est un framework Java généralement utilisé avec la norme J2EE mais ce
n'est pas une obligation.

Spring: un framework libre & open-source (avec la License Apache 2.0).

Il est identifié comme étant un conteneur léger,
c-à-d n'ayant pas besoin de toute la structure d'un serveur d'application Java.

L'intérêt principal de Spring est de faciliter la programmation en Java avec

les POJO (Plain Old Java Object) c'est à dire les objets Java classique.

Spring possède son propre plugin Eclipse du nom de STS (Spring Tool Suite).
Celui-ci permet d'intégrer efficacement Spring dans l'environement de développement.
Spring MVC
- Spring MVC est un pur framework MVC 2 dont la configuration repose sur spring.
- Depuis spring 2.5, il est fortement basé sur les annotations.
- Dans une application web avec spring MVC, on retrouve :
Un descripteur de déploiement web jee (web.xml)
Des contextes sring (spring-servlet.xml)
web.xml
<servlet>
<servlet-name>spring</servlet-name>
<servlet-
class>org.springframework.web.servlet.DispatcherServlet
</servlet-class>
….
spring-servlet.xml
C'est un contexte spring classique auquel se rajoute les
éléments mvc.
…
<!-- Activation des annotations -->
<context:annotation-config />
<!-- Configure la technologie de templating -->
<bean id="jspViewResolver" class="...InternalResourceViewResolver">
<property name="viewClass" value="...JstlView" /> 60
<property name="prefix" value="/WEB-INF/jsp/" /> …
Le modèle MVC type 1 (MVC)
Dans ce modèle, chaque requête est traitée par un contrôleur sous la forme d'une servlet.
Celle-ci traite la requête, fait appel aux éléments du model si nécessaire et redirige la requête vers une JSP qui
se charge de créer la réponse à l'utilisateur.

61
Le modèle MVC 2
Le modèle MVC2 propose de n'utiliser qu'une seule servlet comme contrôleur.
Cette servlet se charge d'assurer le workflow des traitements en fonction des requêtes http reçues.
Cette servlet gère toutes les requêtes à traiter en fonction d'un paramétrage généralement sous la forme d'un fichier au
format XML.

62
Framework Spring
Spring permet d'organiser une application Web selon le patron de conception MVC2 :

DispatcherServlet : cette partie est fournie par Spring. La servlet reçoit les requêtes HTTP et dirige le
traitement vers le contrôleur correspondant à l'URL de la requête (mapping) ;
Contrôleur : il la charge du choix du traitement à déclencher et des informations à afficher en fonction des
entrées.

Modèle : il contient la partie « métier ». Dans notre cas, il sera implémenté par des DAO (Data Access Object
ou Objet d'accès aux données) ;

Vue : c'est la partie d'interface avec l'utilisateur. Dans notre cas, il s'agit des JSP (JavaServer Pages) ;
Spring Security
Spring security est un framework qui permet :
- Mettre en place une mécanique d'authentification
- Définir une politique d'autorisation
- Se connecter à presque tous les systèmes de gestion d'utilisateurs
- D'être sûr d'adhérer aux standards J2EE

La configuration se fait via un contexte spring que l'on ajoute dans le web.xml.
….
<param-name> contextConfigLocation </param-name>
<param-value>/WEB-INF/spring-context.xml,/WEB-INF/spring-security.xml</param-value>
64
La configuration spring-security.xml :
…
<http>
<intercept-url pattern="/**" access="ROLE_USER" />
<form-login />
<logout />
</http>

<authentication-manager>
<authentication-provider>
<user-service>
<user name="test" password="user" authorities="ROLE_USER" />
</user-service>
</authentication-provider>
</authentication-manager>

</beans:beans>

Cette configuration impose que l'utilisateur est authentifié et a

le ROLE_USER.
Si on accède à n'importe quelle page du site, on a donc le
formulaire :

65
Intégration de Spring Web MVC
Spring Web MVC est un module pour le développement d’application Web ou d’API Web.

Spring embarque son propre conteneur avec les services dont elle a besoin. Donc une
application Spring Web MVC n’a pas besoin d’un serveur d’application Java EE complet
comme Wildfly, GlassFish ou TomEE.

Spring Web MVC peut s’exécuter dans un conteneur Web plus léger
comme Tomcat ou Jetty qui offre le service minimal dont une application Spring Web MVC à
besoin tel que:
le lancement d’un serveur HTTP
la possibilité de déléguer le traitement des requêtes au code de l’application.

66
Intégration de Spring Boot
Spring Boot est une solution destinée à l’infrastructure logicielle Java Spring qui réduit la
complexité de la configuration de nouveaux projets Spring.

Spring Boot définit une configuration de base incluant toutes les bibliothèques
pertinentes, ce qui facilite la création de nouveaux projets.

Les caractéristiques de Spring Boot :

- l’intégration directe d’applications de serveur Web/de conteneur comme Apache Tomcat
ou Jetty sans utiliser de fichiers WAR (Web Application Archive)

- la configuration simplifiée de Maven grâce à des POM (Project Object Models) « Starter »

Spring Boot est un projet conçu pour simplifier considérablement la configuration des
applications basées sur le Spring Framework.
67