Vous êtes sur la page 1sur 100

Spring Framework 2.

5 Training Kit

Naoufel EL HAJ Walid MELLOULI Spring Framework 2.5 12/19/2009

Table des matires 2

Spring Framework 2.5

Table des matires 3

Table des matires

A propos des auteurs................................................................................ 6 Atelier 1 - Spring IDE................................................................................. 8


Installation ........................................................................................................................................................... 8 Projet de nature Spring ..................................................................................................................................... 10 Fichier de configuration Spring ......................................................................................................................... 13 Application Spring HelloWorld .......................................................................................................................... 16 Ajout des librairies Spring.............................................................................................................................. 17 Excution du code ......................................................................................................................................... 21 Refactoring ........................................................................................................................................................ 22

Atelier 2 - Inversion of Contrle (IoC) ...................................................... 25


Principe .............................................................................................................................................................. 25 Exemple dutilisation ......................................................................................................................................... 27 Amlioration .................................................................................................................................................. 31

Atelier 3 - Programmation Oriente Aspect (AOP) .................................. 36


Principe .............................................................................................................................................................. 36 Lexique .............................................................................................................................................................. 37 Exemple dutilisation ......................................................................................................................................... 38

Atelier 4 - JPA manag par Spring ........................................................... 44


Principe .............................................................................................................................................................. 44 Exemple dutilisation ......................................................................................................................................... 44 Cration du projet java .................................................................................................................................. 44 Gnration des Entits JPA ........................................................................................................................... 51 Couche DAO................................................................................................................................................... 53 Couche Mtier ............................................................................................................................................... 55 Configuration du projet ................................................................................................................................. 56 Excution du projet ....................................................................................................................................... 60 Spring Framework 2.5

Table des matires 4

Atelier 5 - Spring MVC ............................................................................ 62


Principe .............................................................................................................................................................. 62 Exemple dutilisation ......................................................................................................................................... 63 Ajout dun contrleur .................................................................................................................................... 66 Configuration du DispatcherServlet ........................................................................................................ 67 Fichier de configuration ................................................................................................................................ 68 Ajout de la requte (page redirect.jsp) ......................................................................................................... 72 Ajout de la vue............................................................................................................................................... 72 Excution de lapplication ............................................................................................................................. 73

Atelier 6 - Intgration Spring dans JSF ..................................................... 76


Principe .............................................................................................................................................................. 76 Exemple dutilisation ......................................................................................................................................... 76 Cration dun projet web JSF de nature Spring : ........................................................................................... 76 Configuration de web.xml ............................................................................................................................. 79 Configuration de faces-config.xml................................................................................................................. 80 Cration de la classe Etudiant ....................................................................................................................... 80 Cration de applicationContext.xml .............................................................................................................. 81 Cration dune page web .............................................................................................................................. 81 Excution ....................................................................................................................................................... 82

Atelier 7 - Spring Security ....................................................................... 84


Principe .............................................................................................................................................................. 84 Exemple dutilisation ......................................................................................................................................... 86 Configuration du web.xml ............................................................................................................................. 87 Configuration de app-security.xml ................................................................................................................ 88 Une configuration de base ............................................................................................................................ 89 Configuration avec JDBC provider ................................................................................................................. 90 Authentification par formulaire .................................................................................................................... 91 Test de lapplication ...................................................................................................................................... 92

Spring Framework 2.5

Table des matires 5

Atelier 8 - Spring .NET............................................................................. 95


Principe .............................................................................................................................................................. 95 Exemple dutilisation ......................................................................................................................................... 95 Cration du projet ......................................................................................................................................... 95 Configuration de Spring.Net .......................................................................................................................... 96 Ajout des classes............................................................................................................................................ 98 Dfinition des objets ..................................................................................................................................... 99 Rcupration de lobjet ............................................................................................................................... 100 Excution ..................................................................................................................................................... 100

Spring Framework 2.5

A propos des auteurs 6

A propos des auteurs

Naoufel EL HAJ lve ingnieur en Gnie Logiciel lInstitut


National des Sciences Appliques et de Technologie de Tunis. Passionn par le dveloppement web, il a contribu au dveloppement des plusieurs sites web en Java J2EE, PHP et flash pour des entreprises et des associations Tunisiennes (en freelance). Certifi SCJP, ASP.NET, WCF et CCNA. Membre du club LibertySoft et MIC lINSAT.

Walid MELLOULI

lve ingnieur en Gnie Logiciel lInstitut National des Sciences Appliques et de Technologie de Tunis. Certifi SCJP, SCWCD, ASP.Net et WCF et CCNA. Contributeur Sourgeforge.net, dveloppeur du firewall open source BadTuxWall Linux Firewall. Membre du club LibertySoft et MIC lINSAT. Citation Be the master of your computer, not the slave

Spring Framework 2.5

Atelier 1: Spring IDE

Spring Framework 2.5

Atelier 1 - Spring IDE 8

Atelier 1 - Spring IDE


Spring IDE est un plug-in qui permet de faciliter le travail avec Spring Framework dans Eclipse. Il offre des fonctionnalits comme par exemple des wizards de gnration des fichiers de configuration de Spring, l'autocompltion dans ces fichiers (XML), visualisation graphique des beans Spring et de leurs dpendances, etc.

Installation
Afin dinstaller Spring IDE dans Eclipse, il est recommand dutiliser la fonctionnalit intgre de mise jour de loutil. Cette dernire est disponible par lintermdiaire du menu Help/ Install New Software :

Dans lcran correspondant, une liste de sites de mise jour est propose. Le site de Spring IDE 2.2 doit tre alors ajout par lintermdiaire du bouton Add. Entrez ensuite lURL du site comme cest indiqu dans la figure suivante :

Spring Framework 2.5

Atelier 1 - Spring IDE 9

Spring IDE offre une approche modulaire concernant ses diffrentes fonctionnalits. Il est ainsi possible de ninstaller que les fonctionnalits souhaites. Nous allons slectionner tous les modules :

Tableau 0-1. Modules disponibles dans Spring IDE 2.2

Module

Groupe

Description

Spring IDE Core

Core

Spring IDE AOP Extension

Extensions

Spring IDE OSGI Extension Spring IDE Security Extension Spring IDE Web Flow Extension

Extensions Extensions Extensions

Core Correspond au cur du greffon fournissant les diffrents outils relatifs afin de faciliter la mise en uvre de Spring dans Eclipse. Fournit un support pour lespace de nommage AOP de Spring ainsi que la configuration daspects AspectJ par annotation. Fournit un support pour les dveloppements utilisant Spring Dynamic Modules dans un environnement OSGi. Fournit un support pour Spring Security 2.0. Met disposition tous les outils afin de faciliter le dveloppement dapplications Spring Web Flow dans Eclipse. Spring Framework 2.5

Atelier 1 - Spring IDE 10

Spring IDE Autowire Extension


Spring IDE JavaConfig Extension Spring IDE AJDT Integration Spring IDE Mylyn Integration

Extensions (Incubation)
Extensions (Incubation) Integrations Integrations

Fournit un outil afin de supporter les configurations automatiques (autowiring) dans Spring. Fournit un support de loutil JavaConfig de Spring.
Met disposition les briques relatives lintgration de Spring IDE avec AJDT. Met disposition les briques relatives lintgration de Spring

Acceptez ensuite les termes de la licence. Eclipse commence alors tlcharger les diffrents fichiers correspondant puis propose leur installation. Il convient alors de choisir le bouton Install all pour les installer. A la fin de linstallation, Eclipse proposera un redmarrage afin que les modules soient pris en compte. Une fois le redmarrage est termin, les diffrents modules seront prsents.

Projet de nature Spring


Spring IDE dfinit la notion de projet de nature Spring afin de marquer les projets utilisant Spring et contenant des fichiers de configuration XML relatifs. Deux approches sont possibles afin de spcifier une nature Spring un projet Java : La premire peut tre ralis la cration du projet et consiste la cration dun projet de type Spring par lintermdiaire du menu contextuel New/Other puis la slection de llment Spring Project sous la rubrique Spring .

Spring Framework 2.5

Atelier 1 - Spring IDE 11

Spring Framework 2.5

Atelier 1 - Spring IDE 12

La nature Spring peut galement tre ajoute manuellement par lintermdiaire du menu contextuel accessible partir du nom du projet. Il suffit de slectionner llment Add Spring Project Nature dans la rubrique Spring Tools :

Spring Framework 2.5

Atelier 1 - Spring IDE 13

Fichier de configuration Spring


Il est noter quil est galement possible de crer un fichier de configuration Spring par lintermdiaire du menu New Other et choisir Spring Bean Configuration File sous la rubrique Spring :

Spring Framework 2.5

Atelier 1 - Spring IDE 14

Attribuez ensuite un nom au fichier de configuration :

Spring Framework 2.5

Atelier 1 - Spring IDE 15

Cet lment permet de crer un squelette minimal pour un fichier de configuration Spring, savoir la balise beans avec les diffrents espaces de nommage. Le wizard de cration permet de slectionner les espaces de nommage inclure et si lutilisateur souhaite ajouter le fichier un ensemble de configuration :

Les principales facilits offertes dans ldition dun fichier XML de configuration de Spring sont les suivantes : Support relatif la recherche des classes pour lattribut class de la balise bean avec la compltion des diteurs Eclipse :

Spring Framework 2.5

Atelier 1 - Spring IDE 16

Support relatif la dtection des proprits utilisables pour un bean dans lattribut name de la balise property avec la compltion ; Support relatif la recherche des identifiants de beans pour un rfrencement de beans dans lattribut ref de la balise property.

Ces fonctionnalits offrent un gain important de productivit lors lu dveloppement dapplications Spring puisquelles permettent dafficher les erreurs de la configuration XML avant de lancer lapplication correspondante.

Application Spring HelloWorld


Crez un projet de nature Spring comme cest dj dcrit. Cliquez-droit sur le package src et crer un nouveau package org.insat.test et une classe HelloWorld :

Spring Framework 2.5

Atelier 1 - Spring IDE 17

Insrez le code suivant la classe HelloWorld :


package org.insat.test; public class HelloWorld { String message; public void setMessage(String message){ this.message = message; } public void display(){ System.out.println(message); } }

La classe HelloWorld contient lattribut message et la mthode setter setMessage() . Au lieu dattribuer la valeur du message directement, nous allons linject travers le fichier de configuration quon a dj vu. La classe HelloWorld dispose aussi de la mthode display() qui permet dafficher le message. Crez alors le fichier de configuration bean configuration nomm beans.xml comme cest dcrit dans la section Fichier de configuration Spring . Insrez le code suivant au fichier de configuration beans.xml .
<?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-2.5.xsd"> <bean id="helloWorld" class="org.insat.test.HelloWorld"> <property name="message" value="Hello GL INSAT"></property> </bean> </beans>

Lattribut i d de llment bean est utilis comme nom logique du bean et lattribut class spcifie la classe correspondante. Llment property permet de donner la valeur Hello GL INSAT lattribut message . Ajout des librairies Spring Pour excuter le code, il nous faut les librairies suivantes : Spring.jar (disponible sous ~\spring-framework-2.5.6.SEC01\dist) Commons-logging.jar (disponible sous ~\spring-framework-2.5.6.SEC01\lib)

Pour ajoutez ces librairies ajoutez un dossier lib la racine du projet et y mettre les jars ncessaires.

Spring Framework 2.5

Atelier 1 - Spring IDE 18

Cliquez-droit sur le projet puis aller vers build path -> configure build path et suivez les instructions suivantes :

Spring Framework 2.5

Atelier 1 - Spring IDE 19

Spring Framework 2.5

Atelier 1 - Spring IDE 20

Spring Framework 2.5

Atelier 1 - Spring IDE 21

Slectionnez enfin les 2 jars (spring.jar et commons-logging.jar). Excution du code Nous allons maintenant afficher le message inject travers le fichier de configuration. Crez la classe Main et y insrer le code suivant :
package org.insat.test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class Main { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld"); helloWorld.display(); } }

Nous avons instanci le IoC container avec le fichier de configuration beans.xml. La mthode getBean() permet de localiser la classe helloWorld. Enfin la mthode display() permet dafficher le message.

Spring Framework 2.5

Atelier 1 - Spring IDE 22

Arborescence finale du projet

Refactoring
Spring IDE sintgre parfaitement dans les mcanismes de refactoring mis disposition par lenvironnement de dveloppement Eclipse Cet aspect offre notamment la possibilit de garder une synchronisation entre les entits et leurs configurations relatives dans Spring la suite dun renommage ou un dplacement. Il permet aussi bien de visualiser les impacts sur les fichiers de configuration de Spring. Nous allons tester cet aspect en changeant le nom de la classe HelloWorld . Cliquez-droit sur la classe HelloWorld puis Refactor -> Rename :

Spring Framework 2.5

Atelier 1 - Spring IDE 23

Changez le nom de la classe et cliquez sur Next :

Spring Framework 2.5

24

Atelier 2: Inversion of Contrle (IoC)

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 25

Atelier 2 - Inversion of Contrle (IoC)


Principe
L'inversion de contrle est un motif de conception logicielle (design pattern) commun tous les frameworks, devenu populaire avec l'adoption des conteneurs dits "lgers". Cette notion fait partie des principes de la programmation oriente aspect. Selon le mcanisme du design pattern, ce n'est plus l'application qui appelle les fonctions d'une librairie, mais un framework qui, l'aide d'une couche abstraite mettant en uvre un comportement propre, va appeler l'application en l'implmentant. L'inversion de contrle s'utilise par hritage de classes du framework ou par le biais d'un mcanisme de plug-in.

L'ide principale est que les modules de hauts et bas niveaux doivent dpendre d'interfaces, et non les modules dpendre les uns des autres. Les modules drivent des interfaces. L'inversion de contrle les rend donc indpendants entre eux. L'utilisation d'une interface permet de s'abstraire de la source de donnes. Ainsi les composants ou les services, qui sont des composants distants, forment des entits autonomes et rutilisables sans avoir modifier l'ensemble des codes sources. Ce motif de conception dcoupe l'application en plusieurs blocs de code indpendants, pris en charge par l'API fournie avec le framework. L'application gre l'IHM et le traitement, et le framework prend en charge l'excution de ce traitement. Au lieu d'appeller une classe pour excuter une action, un plug-in de n'importe quel utilisateur injecte l'implmentation dans l'instanciation. Ce modle autorise plusieurs implmentations de classes diffrentes. L'inversion de contrle la plus connue est linjection de dpendances (Dependency Injection). Il existe trois types d'injection de dpendances : L'injection par constructeurs : Ce type d'injection se fait sur le constructeur, c'est--dire que le constructeur dispose de paramtres pour directement initialiser tous les membres de la classe. L'injection par mutateurs (setters) : Ce type d'injection se fait aprs une initialisation l'aide d'un constructeur sans paramtre puis les diffrents champs sont initialiss grce des mutateurs. L'injection d'interface : Cette injection se fait sur la base d'une mthode, elle est plus proche de l'injection par mutateurs, enfin la diffrence se rsume pouvoir utiliser un autre nom de mthode que ceux du "design pattern bean". Pour cela, il faut utiliser une interface afin de dfinir le nom de la mthode qui injectera la dpendance. Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 26

Injection de dpendances : A dpend directement de B

A dpend de linterface I, et B est une implmentation de linterface I => Diminuer le couplage

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 27

Exemple dutilisation
Dans cet atelier, nous allons appliquer linversion de contrle en utilisant le framework spring. Crer un projet Spring laide du plugin eclipse Spring IDE (voir Atelier Spring IDE). Ajouter les jars suivants votre application : spring.jar prsent dans \SPRING_HOME\dist commons-logging.jar prsent dans \SPRING_HOME\ lib\jakarta-commons aspectjweaver.jar prsent dans \SPRING_HOME\ lib\aspectj aspectjrt.jar prsent dans \SPRING_HOME\ lib\aspectj cglib-nodep-2.1_3.jar prsent dans \SPRING_HOME\ lib\cglib Avec SPRING_HOME dsigne le chemin dinstallation du framework spring.

Soit lexemple suivant : un tudiant est caractris par sa filire. Donc soit la classe Etudiant contenant un attribut Filiere. Filiere est une interface implmente par deux classes : FiliereGL et FiliereRT. Ci-dessous le diagramme de classe correspondant cet exemple :

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 28

Voici la classe Etudiant :


package org.insat.ioc; public class Etudiant { private Filiere filiere; public Etudiant() { } public Etudiant(Filiere filiere) { this.filiere = filiere; } public void setFiliere(Filiere filiere) { this.filiere = filiere; } public Filiere getFiliere() { return filiere; } public void maFiliere(){ filiere.afficherFiliere(); } }

Voici le code de linterface Filiere et ses deux implmentations FiliereGL et FiliereRT:


package org.insat.ioc; public interface Filiere { public void afficherFiliere(); }

package org.insat.ioc; public class FiliereGL implements Filiere { @Override public void afficherFiliere() { System.out.println("Je suis un GLien :) Vive GL!"); } }

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 29

package org.insat.ioc; public class FiliereRT implements Filiere { @Override public void afficherFiliere() { System.out.println("Je suis un RTien :) Vive RT!"); } }

Nous allons dclarer linstanciation de la classe Etudiant et lui attribuer une instance dune implmentation de Filiere, dans le fichier de dfinition des beans beans.xml de Spring. Nous allons le faire par ces diffrentes mthodes :

L'injection par mutateurs (setters) : Dans ce qui suit, nous allons modifier la rfrence de lobjet Filiere de la classe Etudiant en utilisant une injection par mutateur, le contenu de beans.xml est le suivant :
<?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-2.5.xsd"> <bean id="filiereGL" class="org.insat.ioc.FiliereGL" /> <bean id="filiereRT" class="org.insat.ioc.FiliereRT" /> <bean id="etudiant" class="org.insat.ioc.Etudiant"> <property name="filiere"> <ref local="filiereGL" /> </property> </bean> </beans>

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 30

L'injection par constructeur: Dans ce qui suit, nous allons modifier la rfrence de lobjet Filiere de la classe Etudiant en utilisant une injection par constructeur, le contenu de beans.xml est le suivant :
<?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-2.5.xsd">

<bean id="filiereGL" class="org.insat.ioc.FiliereGL" /> <bean id="filiereRT" class="org.insat.ioc.FiliereRT" /> <bean id="etudiant" class="org.insat.ioc.Etudiant"> <constructor-arg index="0" type="org.insat.ioc.Filiere" > <ref local="filiereGL"/> </constructor-arg> </bean> </beans>

On ajoute lattribut index dans la balise constructor-arg pour identifier lordre de cet argument dans la liste des arguments du constructeur, et lattribut type pour expliciter le type de largument (utile dans le cas de surcharge de constructeur). Cest deux attributs, index et type, sont facultatifs et utiliss lorsquil y a dambigut.

Le programme principal est le suivant :


package org.insat.main; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class EtudiantApp { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Etudiant etudiant = (Etudiant)context.getBean("etudiant"); etudiant.maFiliere(); } }

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 31

Lexcution de ce programme:

Amlioration Si nous voulons amliorer notre programme par lajout dun Map contenant la liste des matires et leurs coefficients dun tudiant, en ajoutant lattribut matieres dans la classe Etudiant comme suit :
private Map<String, Double> matieres; public Map<String, Double> getMatieres() { return matieres; } public void setMatieres(Map<String, Double> matieres) { this.matieres = matieres; }

Le fichier de dfinition des beans beans.xml sera comme suit (utilisation de la mthode : injection par mutateur) :

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 32

<?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-2.5.xsd"> <bean id="filiereGL" class="org.insat.ioc.FiliereGL" /> <bean id="filiereRT" class="org.insat.ioc.FiliereRT" /> <bean id="etudiant" class="org.insat.ioc.Etudiant"> <property name="filiere"> <ref local="filiereGL" /> </property> <property name="matieres"> <map> <entry key="Programmation" value="3" /> <entry key="Architecture" value="2" /> <entry key="SIG" value="1.5" /> <entry key="Anglais" value="1" /> </map> </property> </bean> </beans>

On peut amliorer aussi notre fichier de dfinition des beans beans.xml , en utilisant les namespaces property et util, lors de la cration de ce dernier :

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 33

Et le fichier de dfinition des beans beans.xml sera :


<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

<bean id="filiereGL" class="org.insat.ioc.FiliereGL" /> <bean id="filiereRT" class="org.insat.ioc.FiliereRT" /> <util:map id="matieres"> <entry key="Programmation" value="3" /> <entry key="Architecture" value="2" /> <entry key="SIG" value="1.5" /> <entry key="Anglais" value="1" /> </util:map> <bean id="etudiant" class="org.insat.ioc.Etudiant" p:filiere-ref="filiereGL" p:matieres-ref="matieres" /> </beans>

Et le programme principale sera le suivant :


package org.insat.main; import java.util.Map; import org.insat.ioc.Etudiant; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class EtudiantApp { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Etudiant etudiant = (Etudiant)context.getBean("etudiant"); etudiant.maFiliere(); System.out.println("Mes matires et leurs coefficients sont: "); for (Map.Entry<String, Double> entry : etudiant.getMatieres().entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } } }

Spring Framework 2.5

Atelier 2 - Inversion of Contrle (IoC) 34

Lexcution de ce programme rsulte :

Spring Framework 2.5

35

Atelier 3 : Programmation Oriente Aspect (AOP)

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 36

Atelier 3 - Programmation Oriente Aspect (AOP)


Principe
La programmation oriente aspect (en anglais aspect-oriented programming - AOP) est un paradigme de programmation qui permet de sparer les considrations techniques (aspect en anglais) des descriptions mtier dans une application. Par exemple, le principe de l'inversion de contrle (en anglais, IOC, Inversion Of Control) peut tre implmente par cette mthode de programmation. Comme nous pouvons le voir dans la figure suivante, un module ou composant mtier est rgulirement pollu par de multiples appels des composants utilitaires externes.

De fait ces appels rendent le code plus complexe et donc moins lisible. Comme chacun sait, un code plus court et donc plus clair amliore la qualit et la rutilisabilit. La solution constituerait donc externaliser tous les traitements non relatifs au logique mtier en dehors du composant. Pour ce faire il faut pouvoir dfinir des traitements de faon dclarative ou programmatique sur les points cls de l'algorithme. Typiquement avant ou aprs une mthode.

Dans la plupart des cas ce genre de traitements utilitaires se fait en dbut ou en fin de mthode, comme par exemple journaliser les appels ou encore effectuer un commit ou un rollback sur une transaction.

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 37

La dmarche est alors la suivante:

Dcomposition en aspect: Sparer la partie mtier de la partie utilitaire. Programmation de la partie mtier: Se concentrer sur la partie variante. Recomposition des aspects: Dfinition des aspects

Grce l'AOP, le couplage entre les modules grant des aspects techniques peut tre rduit de faon trs importante, ce qui prsente de nombreux avantages : Maintenance accrue Meilleure rutilisation Gain de productivit Amlioration de la qualit du code

Lexique
La programmation oriente aspect dfinie un jargon bien spcifique, simples mais puissants : aspect : un module dfinissant des greffons et leurs points d'activation. greffon (en anglais, advice) : un programme qui sera activ un certain point d'excution du systme, prcis par un point de jonction. tissage ou tramage (en anglais, weaving) : insertion statique ou dynamique dans le systme logiciel de l'appel aux greffons. point d'action, de coupure, de greffe (en anglais, pointcut) : endroit du logiciel o est insr un greffon par le tisseur d'aspect. point de jonction, d'excution (en anglais, join point) : endroit spcifique dans le flot d'excution du systme, o il est valide d'insrer un greffon. considrations entrecroises, proccupations transversales (en anglais, cross-cutting concerns) : mlange, au sein d'un mme programme, de sous-programmes distincts couvrant des aspects techniques spars.

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 38

Exemple dutilisation
Lobjectif de cet atelier est de tracer (Log) les appels aux mthodes dans une application, sans ajouter du code de Log dans cette application. Grace Spring, il est possible de tracer les appels aux mthodes objets pendant l'excution et sans modifier le code de l'application. Tout dabord, vous devez crer un projet Spring laide du plugin eclipse Spring IDE (voir Lab Spring IDE). Ajouter les jars suivants votre application : spring.jar prsent dans \SPRING_HOME\dist commons-logging.jar prsent dans \SPRING_HOME\ lib\jakarta-commons aspectjweaver.jar prsent dans \SPRING_HOME\ lib\aspectj aspectjrt.jar prsent dans \SPRING_HOME\ lib\aspectj cglib-nodep-2.1_3.jar prsent dans \SPRING_HOME\ lib\cglib

Avec SPRING_HOME dsigne le chemin dinstallation du framework spring.

AOP classique Soit lapplication Calculatrice qui permet de faire laddition ou la soustraction de deux entier. Le principe est d'intercepter les entres/sorties des mthodes "addition(int,int)" et "soustraction(int,int) " et de les logger l'aide d'une classe externe "CalculatriceLogger". La classe Calculatrice La classe Calculatrice tracer est la suivante :
package org.insat.aop; public class Calculatrice { public int addition(int a, int b) { return a + b; } public int soustraction(int a, int b) { return a - b; } }

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 39

La classe CalculatriceLogger La classe CalculatriceLogger contient les deux mthodes "logMethodEntry()" et "logMethodExit()" qui vont tre appeles par Spring-AOP pour tracer les appels des mthodes interceptes. Le code de cette classe est le suivant :
package org.insat.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.JoinPoint.StaticPart; public class CalculatriceLogger { // Cette mthode est appele chaque fois (et avant) qu'une mthode du // package org.insat.aop est intercepte public void logMethodEntry(JoinPoint joinPoint) { Object[] args = joinPoint.getArgs(); // Nom de la mthode intercepte String name = joinPoint.getSignature().toLongString(); StringBuffer sb = new StringBuffer(name + " called with: ["); // Liste des valeurs des arguments reus par la mthode for (int i = 0; i < args.length; i++) { Object o = args[i]; sb.append("'" + o + "'"); sb.append((i == args.length - 1) ? "" : ", "); } sb.append("]"); System.out.println(sb); } // Cette mthode est appele chaque fois (et aprs) qu'une mthode du // package org.insat.aop est intercepte // Elle reoit en argument 'result' qui est le retour de la mthode // intercepte public void logMethodExit(StaticPart staticPart, Object result) { // Nom de la mthode intercepte String name = staticPart.getSignature().toLongString(); System.out.println(name + " returning: [" + result + "]"); } }

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 40

Configuration AOP La dernire tche qui reste est de configurer lAOP laide dun fichier de configuration Spring. Donc, crer un fichier de dfinition des beans, le nommer springContext.xml . Lors de la cration de ce dernier, il faut ajouter le namespace AOP comme suit:

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 41

Le fichier de dfinition des beans est :


<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <bean name="calculatrice" class="org.insat.aop.Calculatrice" /> <!-- Debut de la configuration AOP --> <aop:config> <aop:pointcut id="servicePointcut" expression="execution(* org.insat.aop.Calculatrice.*(..))" /> <aop:aspect id="loggingAspect" ref="calculatriceLogger"> <aop:before method="logMethodEntry" pointcut-ref="servicePointcut" /> <aop:after-returning method="logMethodExit" returning="result" pointcut-ref="servicePointcut" /> </aop:aspect> </aop:config> <bean id="calculatriceLogger" class="org.insat.aop.CalculatriceLogger" /> <!-- Fin de la configuration AOP --> </beans>

Explication de la configuration AOP: <aop:config> ... </aop:config> Dfinit le bloc de configuration AOP. <aop:pointcut id="servicePointcut" expression="execution(*org.insat.aop.Calculatrice.*(..))"/> Permet de dfinir des points d'interception sur les objets. Ici l'expression org.insat.aop.Calculatrice.* signifie que toutes les mthodes des objets qui sont dans la classe Calculatrice seront interceptes. <aop:aspect id="loggingAspect" ref="calculatriceLogger "> Les appels aux mthodes seront renvoys vers le bean Spring " calculatriceLogger " (classe CalculatriceLogger) <aop:before method="logMethodEntry" ...> Avant l'appel (before) des deux mthodes "logMethodEntry()" et "logMethodExit()", la mthode "CalculatriceLogger.logMethodEntry()" est appele. <aop:after-returning method="logMethodExit" returning="result"...>

Spring Framework 2.5

Atelier 3 - Programmation Oriente Aspect (AOP) 42

Aprs l'appel (after) des deux mthodes "logMethodEntry()" et "logMethodExit()", la mthode "CalculatriceLogger.logMethodExit()" est appele et le rsultat des mthodes lui seront passs en argument.

Programme principale Le programme principal excuter est le suivant :


package org.insat.main; import org.insat.aop.Calculatrice; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class CalculatriceApp { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("springContext.xml"); Calculatrice calculatrice = (Calculatrice)context.getBean("calculatrice"); calculatrice.addition(3, 2); calculatrice.soustraction(8, 6); } }

Lexcution de ce programme rsulte :

Spring Framework 2.5

43

Atelier 4 : JPA manag par Spring

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 44

Atelier 4 - JPA manag par Spring


Principe
L'utilisation de JPA dans un environnement non manag peut se rvler dlicate et problmatique. Ceci est d essentiellement la gestion de la session de persistance, qui dans le mode non-manag doit tre gre la main par le dveloppeur, or la mthode la plus simple qui consiste ouvrir une session de persistance chaque fois qu'on en a besoin est inefficace. C'est pour cela qu'il vaut mieux (faut) utiliser un conteneur pour la gestion de la session de persistance (JPA, Hibernate, etc.) comme par exemple le conteneur Spring.

Exemple dutilisation
Nous allons prsenter rapidement dans ce billet les tapes suivre pour configurer Spring 2.5 et JPA dans le cadre d'une application java simple (ne ncessitant pas un serveur d'application). Nous allons utiliser MySQL comme base de donnes. Il est aussi facile de migrer vers un autre SGBD.

Cration du projet java Pour crer un projet de nature JPA et le configurer, nous allons utiliser le plugin Dali intgr par dfaut dans la dernire version d Eclipse Galileo destine aux dveloppeurs java EE. Crez un projet de nature JPA comme suit :

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 45

Nous allons maintenant crez la connexion la base de donnes de type MySQL :

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 46

cliquez sur Add Connection .

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 47

choisissez le type de connexion MySQL et lui attribuez un nom puis cliquez sur Next :

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 48

Entrez les paramtres de la base:

Cliquez sur le bouton

pour dfinir le pilote de connexion (Driver).

Sous longlet Name/Type slectionnez la version 5.1 du Driver puis passez longlet Jar List . Sous longlet Jar List effacer le jar par dfaut et spcifier le chemin du Driver (mysql-connector-java5.1.9.jar) et cliquez sur OK .

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 49

NB : Si le bouton OK reste dsactiv changez le nom du driver.

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 50

Testez enfin la connexion pour tre sur que les paramtres entrs sont correctes :

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 51

Une fois la procdure est termine, ajoutez les dpendances suivantes au projet (recourez vous latelier Spring IDE section Ajout des librairies Spring pour savoir comment ajouter les dpendances au projet) :

Gnration des Entits JPA Nous allons maintenant crer les entits partir de la base MySQL. Cliquez-droit sur le projet puis allez vers JPA Tools -> Generate Entities from Tables :

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 52

Slectionnez la connexion dj cr et choisissez les entits gnrer partir des tables:

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 53

Slectionnez le package de destination et cliquez sur Finish :

Couche DAO Nous allons maintenant crer la couche DAO. La classe DAO contient les mthodes CRUD pour accder la base de donnes. Nous allons dfinir la classe DAO spcifique l'entit Membre.

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 54

Crez un package org.insat.dao et une classe MembreDAO et y ajouter le code suivant :

import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.insat.entities.Membre; import org.springframework.stereotype.Component; import org.springframework.stereotype.Repository; @Repository @Component public class MemberDAO { @PersistenceContext private EntityManager entityManagerFactory; public Membre findById(String id) { return entityManagerFactory.find(Membre.class, id); } }

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 55

Nous avons spcifis 2 annotations au sein de cette classe : @Repository: indique que la classe est un "Repository" (ou Data Access Object - DAO). Avec une certaine configuration dans le fichier applicationContext.xml (que nous dcrirons plus loin), cette classe sera automatiquement gr par Spring lexcution (runtime). Elle sera instancie et sauvegarde et peut tre ensuite inject dans les classes de service directement. @Component: indique que le bean est manag par Spring.

Nous avons annot l' EntityManager par @PersistenceContext pour indiquer Spring qu'il doit l'injecter automatiquement.
Le reste est du JPA ordinaire.

Couche Mtier

Maintenant, nous allons dfinir la couche mtier qui sera appel par suite. Pour la couche service, nous allons dfinir d'abord une interface, qui dfinit des mthodes communes et ensuite les implmenter.

Dans notre cas, crez un package appel org.insat.service et une interface MembreService : Interface MembreService
import org.insat.entities.Membre; public interface MembreService { public Membre findById(String id); }

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 56

Crez ensuite la classe dimplmentation MembreServiceImpl Classe MembreServiceImpl


package org.insat.service; import org.insat.dao.MembreDAO; import org.insat.entities.Membre; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class MembreServiceImpl implements MembreService { @Autowired MembreDAO memberDao; @Transactional public Membre findById(String id) { // TODO Auto-generated method stub return memberDao.findById(id); } }

Nous avons annot la classe avec @Service pour la marquer en tant que Spring Bean, et plus prcisment comme faisant partie de la couche Service. Nous avons dclar le champ memberDao annots avec @Autowired pour quil soit instanci par linjection de Spring de manire automatique. Nous avons annot la mthode finfById avec @Transactional, pour indiquer Spring qu'il doit l'englober dans une transaction. Ainsi la transaction est soit valide en totalit (commit) soit annule en totalit en cas dchec (rollback).

Configuration du projet Commencez par rendre le projet de nature Spring

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 57

Crer ensuite un fichier nomm jdbc.properties sous le rpertoire src pour y stocker les paramtres de la base : jdbc.properties
jdbc.driverClass=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/libertysoft?autoReconnect=true jdbc.username=root jdbc.password=root jdbc.database=MYSQL jdbc.showSql=true

Nous allons maintenant indiquer les paramtres de la bd et des composants Bean travers un fichier de configuration.

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 58

Crez le fichier de configuration applicationContext.xml sous le rpertoire src et y insrez le code suivant:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <context:property-placeholder location="classpath:jdbc.properties" /> <!-- Connection Pool --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass" value="${jdbc.driverClass}" /> <property name="jdbcUrl" value="${jdbc.url}" /> <property name="user" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </bean> <!-- JPA EntityManagerFactory --> <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" p:dataSource-ref="dataSource"> <property name="jpaVendorAdapter"> <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"> <property name="database" value="${jdbc.database}" /> <property name="showSql" value="${jdbc.showSql}" /> </bean> </property> </bean> <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager" p:entityManagerFactory-ref="entityManagerFactory" /> <context:annotation-config /> <tx:annotation-driven transaction-manager="transactionManager" /> <context:component-scan base-package="org.insat.dao" /> </beans>

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 59

Explication Spcifier la DataSource qui est utilis par Hibernate :

<bean id="dataSource" destroy-method="close">

Indiquer Spring les paramtres de l entityManagerFactory initialiser :

By <bean id="entityManagerFactory" p:dataSource-ref="dataSource">

Demander Spring de scanner le package en cours et de dterminer les composants instancier (dans notre cas ce sont les classes MemberDAO annote par @Repository et MemberServiceImpl annote par @Service qui seront instancies) :

<context:component-scan base-package="com.test.dao"/>

Activer lAutoWiring : Rechercher @Autowired et injecter linstance du bean correspondant.

<context:annotation-config/>

Spring Framework 2.5

Atelier 4 - JPA manag par Spring 60

Excution du projet Excuter le code suivant pour tester lextraction des donnes partir de la base : Classe org.insat.test.TestMembre
package org.insat.test; import org.insat.service.MembreService; import org.springframework.context.support.ClassPathXmlApplicationContext; public class TestMembre { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub MembreService membreService; ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(new String[] {"applicationContext.xml"}); membreService = (MembreService) appContext.getBean("membreServiceImpl"); System.out.println("Nom : " + membreService.findById("gl@insat.tn").getNommembre()); } }

Spring Framework 2.5

61

Atelier 5: Spring MVC

Spring Framework 2.5

Atelier 5 - Spring MVC 62

Atelier 5 - Spring MVC


Principe
Spring MVC aide dvelopper des applications web flexible et faiblement coupls. Le modle de conception Modle-Vue-Contrleur permet de sparer la logique mtier, la logique de prsentation et la logique de navigation. Les modles sont responsables pour encapsuler les donnes d'application. Les Vues ont comme rle de rendre rponse l'utilisateur l'aide de l'objet modle. Les contrleurs sont chargs de recevoir la demande de l'utilisateur et dappeler des services.
La figure ci-dessous montre le flux de la demande dans le Framework MVC Spring :

Quand une requte est envoye, la squence suivante d'vnements se produit. Le DispatcherServlet reoit d'abord la demande. Le DispatcherServlet consulte le HandlerMapping et invoque le contrleur associ la demande. Le contrleur fait appel aux mthodes appropris de la couche service et retourne un objet ModeAndView au DispatcherServlet . L'objet ModeAndView contient les donnes du modle et le nom de la vue. Le DispatcherServlet envoie le nom de la vue au ViewResolver pour trouver la vue actuelle invoquer. Le DispatcherServlet passe lobjet modle la vue. Enfin, la vue, l'aide du modle de donnes, rend le rsultat l'utilisateur. Spring Framework 2.5

Atelier 5 - Spring MVC 63

Exemple dutilisation
L'objet de ce lab est d'illustrer progressivement par un exemple simple mais pratique la cration d'une application web avec Spring MVC. Allez vers New -> Dynamic Web Project pour crer un nouveau projet web dynamique :

Spring Framework 2.5

Atelier 5 - Spring MVC 64

Entrez le nom du projet et cliquez sur Finish :

Spring Framework 2.5

Atelier 5 - Spring MVC 65

Cliquez-droit sur le dossier du projet, et slectionnez Spring Tools -> Add Spring Project Nature, afin d'ajouter les capacits de Spring au projet Web :

Ajoutez les jars suivants au projet :

Spring Framework 2.5

Atelier 5 - Spring MVC 66

spring-webmvc.jar est disponible sous ~\spring-framework-2.5.6.SEC01\dist\modules\ spring.jar est disponible sous ~\spring-framework-2.5.6.SEC01\dist \ commons-logging.jar est disponible sous ~\spring-framework-2.5.6.SEC01\lib\jakarta-commons\

Ajout dun contrleur Crez un nouveau contrleur sous le package org.insat.controllers . Une classe contrleur de Spring doit hriter de org.springframework.web.servlet.mvc.AbstractController .

Spring Framework 2.5

Atelier 5 - Spring MVC 67

Insrez le code suivant la classe contrleur ainsi cr :


package org.insat.controllers; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.web.servlet.ModelAndView; import org.springframework.web.servlet.mvc.AbstractController; public class HelloWorldController extends AbstractController { private String message; @Override protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception { return new ModelAndView("welcomePage", "welcomeMessage", message); } public void setMessage(String message){ this.message = message; } }

La classe HelloWorldController possde lattribut message qui sera dfini par le setter injection . Cette classe doit implmenter la mthode handleRequestInternal() pour traiter la requte. Aprs traitement de la requte, elle retourne un objet ModelAndView au DispatcherServlet .

Configuration du DispatcherServlet Le DispatcherSevlet , comme son nom l'indique, est une servlet unique qui gre le processus de traitement des requtes (request-handling). Quand une requte est envoye au DispatcherServlet , ce dernier dlgue le travail en invoquant les contrleurs concerns pour traiter la demande. Comme tout autre servlet, le DispatcherServlet a besoin d'tre configur dans le descripteur de dploiement Web. Pour ceci ajouter le code suivant au web.xml :

Spring Framework 2.5

Atelier 5 - Spring MVC 68

<servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcher</servlet-name> <url-pattern>*.htm</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>redirect.jsp</welcome-file> </welcome-file-list>

Dans notre cas, le nom du servlet est dispatcher . Par dfaut, le DispatcherServlet cherchera le fichier dispatcher-servlet.xml pour charger la configuration de Spring MVC. Ce nom est forme par la concatnation du nom de servlet ( dispatcher ) avec -servlet.xml .

Fichier de configuration Pour crer le fichier de configuration dispatcher-servlet.xml cliquez-droit sur le dossier WEB-INF et slectionnez New -> Other et suivez les instructions dcrites par les figures suivantes :

Spring Framework 2.5

Atelier 5 - Spring MVC 69

Spring Framework 2.5

Atelier 5 - Spring MVC 70

Spring Framework 2.5

Atelier 5 - Spring MVC 71

Une fois que le fichier de configuration est cr, nous devons configurer le contrleur et la classe ViewResolver . Ajoutez alors le code suivant au fichier de configuration :
<?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-2.5.xsd"> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix"> <value>/WEB-INF/jsp/</value> </property> <property name="suffix"> <value>.jsp</value> </property> </bean> <bean name="/welcome.htm" class="org.insat.controllers.HelloWorldController"> <property name="message" value="Hello GL INSAT !!"></property> </bean> </beans>

Explication du code Le contrleur est configur par lextrait XML suivant:

<bean name="/welcome.htm" class="org.insat.controllers.HelloWorldController"> <property name="message" value="Hello GL INSAT !!"></property> </bean>

Lattribut name indique lURL de redirection de la requte. Par dfaut, le DispatcherServlet utilise le BeanNameUrlHandlerMapping pour rediriger les requtes entrantes. Ainsi, nous navons pas besoin dune configuration supplmentaire. Lattribut message du contrleur HelloWorldController est inject via le Setter Injection . Le ViewResolver est configur par le code suivant :

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix"> <value>/WEB-INF/jsp/</value> </property> <property name="suffix"> <value>.jsp</value> </property> </bean>

InternalResourceViewResolver est utilis pour rsoudre le nom de la vue. Lemplacement de la vue est donn par la concatnation valeur du prfixe + nom de la vue + valeur suffixe. Spring Framework 2.5

Atelier 5 - Spring MVC 72

Dans notre cas, lemplacement actuel de la vue est /WEB-INF/jsp/welcomePage.jsp Ajout de la requte (page redirect.jsp) Insrez une page jsp sous le rpertoire WebContent . Cette page sera utilise pour envoyer la requte :

Ajoutez le code suivant la page redirect.jsp :


<%@ page language="java" contentType="text/html;" pageEncoding="UTF-8"%> <% response.sendRedirect("welcome.htm"); %>

La page redirect.jsp sera invoque lexcution de l'application Web. Elle va rediriger la requte au DispatcherServlet , qui son tour consulte le BeanNameUrlHandlerMapping et invoque le HelloWorldController . La mthode handleRequestInternal() de la classe HelloWorldController sera alors invoque. handleRequestInternal() retourne la proprit message sous le nom welcomeMessage et le nom de la vue welcomePage au DispatcherServlet . Le ViewResolver sera alors invoqu pour dterminer la vue actuelle.

Ajout de la vue Ajoutez maintenant la page de la vue : Spring Framework 2.5

Atelier 5 - Spring MVC 73

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>Welcome Page</title> </head> <body> Ceci est la page welcomePage. <h1>Le message est : ${welcomeMessage} !!</h1> </body> </html>

Le paramtre welcomeMessage envoy partir du contrleur. Sa valeur est celle de lattribut message que nous lavons inject travers le fichier de configuration.

Excution de lapplication Excuter lapplication sous un serveur web (dans notre cas cest Tomcat 6.0) et accdez la page redirect.jsp:

Spring Framework 2.5

Atelier 5 - Spring MVC 74

Spring Framework 2.5

75

Atelier 6 : Intgration Spring dans JSF

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 76

Atelier 6 - Intgration Spring dans JSF


Principe
Spring peut facilement tre intgr dans la plupart des Framework web (bas sur java). Tout ce que vous devez le faire est de dclarer un ContextLoaderListener dans le fichier web.xml et utiliser un contextConfigLocation <context-param> pour fixer les fichiers de contexte charger. Dans cette approche dintgration JSF-Spring, l'inversion de contrle est appliqu la fois par Spring et par JSF. Le point saillant est que les beans de Spring ne sont pas injects par Spring, mais par JSF. Donc, Spring joue juste le rle dun conteneur. Il est vrai que le support de JSF pour l'injection par setter setter injection n'est pas tout fait diffrent de celui du Spring. Mais en plus de linjection de dpendance, Spring peut apporter beaucoup de valeur ajoute pour JSF, telles que les transactions dclaratives, la scurit, l'accs distant, etc, et qui pourraient s'avrer utiles dans une application JSF.

Exemple dutilisation
La meilleure faon de comprendre lapproche dintgration JSF-Spring est de le voir en exemple. Dans cet exemple nous allons utiliser Spring pour grer les dpendances des backing beans JSF. Nous supposons que vous tes dj familier avec JSF! Voici les tapes suivre : Cration dun projet web JSF de nature Spring : Crer tout dabord un nouveau projet web dynamique :

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 77

Ensuite, choisir le serveur ou le conteneur web, o votre application sera dploye. Vous devez aussi configurer lapplication, en cliquant sur le bouton Modify comme indiquer ci-dessous :

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 78

Ajouter JavaServer Faces votre application web:

Ajouter la nature Spring votre application :

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 79

Ajouter les jars suivants votre application :

Configuration de web.xml Ajouter dans l e descripteur de dploiement web.xml un ContextLoaderListener qui permettra de charger un WebApplicationContext partir du fichier de dfinition des beans Spring, dclar dans la variable de contexte contextConfigLocation :
<!-- Configuration Spring --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/applicationContext.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <listener> <listener-class> org.springframework.web.context.request.RequestContextListener </listener-class> </listener> <!-- Fin Configuration Spring -->

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 80

Configuration de faces-config.xml La plus simple faon d'intgrer la couche mtier de Spring avec la couche prsentation JSF, est d'utiliser la classe DelegatingVariableResolver. Donc, ajouter cette dclaration dans le fichier de configuration de JSF faces-config.xml :
<application> <variable-resolver> org.springframework.web.jsf.DelegatingVariableResolver </variable-resolver> </application>

Cration de la classe Etudiant Crer la classe tudiant comme suit :


package org.insat.springjsf.bean; public class Etudiant { private String nom; private String prenom; private String filiere; public String getNom() { return nom; } public String getPrenom() { return prenom; } public String getFiliere() { return filiere; } public void setNom(String nom) { this.nom = nom; } public void setPrenom(String prenom) { this.prenom = prenom; } public void setFiliere(String filiere) { this.filiere = filiere; } }

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 81

Cration de applicationContext.xml Crer un fichier de dfinition des beans Spring applicationContext.xml , qui permettra linstanciation dun tudiant (ajouter le namespace Property lors de la cration de ce fichier) :
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <bean id="etudiant" class="org.insat.springjsf.bean.Etudiant" p:nom="Mohamed" p:prenom="Ali" p:filiere="Gnie Logiciel" /> </beans>

Cration dune page web Crer une page web qui permettra laccs aux donnes instancis par Spring, en tant que ManagedBean JSF :
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <%@ taglib prefix="f" uri="http://java.sun.com/jsf/core"%> <%@ taglib prefix="h" uri="http://java.sun.com/jsf/html"%> <html> <head> <title>Spring Jsf</title> </head> <body> <f:view> Je suis <h:outputText value=" #{etudiant.nom} #{etudiant.prenom}" /> , un tudiant en <h:outputText value=" #{etudiant.filiere}" />. </f:view> </body> </html>

Spring Framework 2.5

Atelier 6 - Intgration Spring dans JSF 82

Excution Lexcution de cette application rsulte :

Spring Framework 2.5

83

Atelier 7: Spring Security

Spring Framework 2.5

Atelier 7 - Spring Security 84

Atelier 7 - Spring Security


Principe
Spring Security permet de grer l'accs aux ressources d'une application Java. Ces ressources peuvent tre des pages web, mais aussi des objets de services mtier. Toute ressource sollicite par un appelant est rendue accessible si, d'une part, l'appelant s'est identifi, et si d'autre part, il possde les droits ncessaires (des rles dans le vocabulaire Spring Security). Le module Acegi a t rebaptis en version 2 par Spring Security. Outre ce renommage, cette nouvelle version apporte des schmas XML qui simplifient considrablement la configuration. Les requtes HTTP sont interceptes par un filtre de servlet qui dlgue un bean Spring les traitements de vrification d'accs aux pages web.

Ce bean met en uvre une chane de filtres. Chacun des filtres est un bean auquel est attribu une tche prcise : Intgration dans la session HTTP des informations de scurit contenues dans la requte Vrification de l'identit de l'appelant et affichage d'une invite de connexion si ncessaire Vrification des droits d'accs la ressource sollicite ...

Spring Framework 2.5

Atelier 7 - Spring Security 85

Certains filtres sont obligatoires, d'autres optionnels. La chane de filtres est largement configurable, ce qui permet de personnaliser au mieux la gestion de la scurit dans les applications web. Spring Security offre ainsi les fonctionnalits suivantes : Authentification anonyme Fonction Remember Me Gestion NTLM Intgration avec un serveur LDAP ou un serveur CAS Gestion des certificats X509

Spring Framework 2.5

Atelier 7 - Spring Security 86

Exemple dutilisation
Dans cette partie vous allez crer pas pas une application web et la scuriser avec Spring Security. Crez dans eclipse un projet web dynamique SpringSecurity Ajoutez des capacits Spring votre projet (cliquez droit sur le projet puis Spring Tools/Add Spring Nature)

Crez une page daccueil index.htm :


<html> <head> <title>Spring Security</title> </head> <body> <h1>Ceci est une page scurise</h1> </body> </html>

Ajouter les jars suivants votre application :

Spring Framework 2.5

Atelier 7 - Spring Security 87

Configuration du web.xml Imposez la page index.htm comme tant la page daccueil :


<welcome-file-list> <welcome-file>index.html</welcome-file> </welcome-file-list>

Dclarez lintercepteur de scurit. Pour cela, ajoutez le contenu suivant dans le fichier web.xml :
<filter> <filter-name>springSecurityFilterChain</filter-name> <filter-class> org.springframework.web.filter.DelegatingFilterProxy </filter-class> </filter> <filter-mapping> <filter-name>springSecurityFilterChain</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

Configurez le chargeur de dfinition des beans : ContextLoaderListener :


<listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/app-security.xml</param-value> </context-param>

Le fichier web.xml est dsormais bien configur.

Spring Framework 2.5

Atelier 7 - Spring Security 88

Configuration de app-security.xml Crer le fichier de dfinition des beans \WEB-INF\app-security.xml. Lors de la cration de ce fichier, slectionner le namespace security et property :

Le fichier de dfinition des beans app-security.xml sera :


<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sec="http://www.springframework.org/schema/security" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/bean s http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security2.0.4.xsd"> </beans>

Spring Framework 2.5

Atelier 7 - Spring Security 89

Une configuration de base Pour une configuration chane de filtres minimale, nous modifions le fichier app-security.xml comme suit :
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sec="http://www.springframework.org/schema/security" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.4.xsd">

<sec:authentication-provider> <sec:user-service> <sec:user name="admin" password="admin" authorities="ROLE_ADMIN,ROLE_USER" /> <sec:user name="guest" password="guest" authorities="ROLE_USER" /> </sec:user-service> </sec:authentication-provider> <sec:http auto-config="true"> <sec:intercept-url pattern="/**" access="ROLE_ADMIN" /> <sec:http-basic /> </sec:http> </beans>

Le volume de cette configuration est bien moindre, bien que cet exemple est complet et bien fonctionnel. Voici lexplication des lments de cette configuration : La base de donnes utilisateur est dfinie dans le fichier de configuration. Pour chaque utilisateur, on spcifie l'identifiant, le mot de passe et les rles qui lui sont attribus avec l'lment <sec:user />. On dfinit aussi les rgles d'accs aux pages de l'application l'aide de l'lment <sec:intercepturl />. Il s'agit simplement d'associer un pattern d'URL un ou plusieurs rles (sparation avec une virgule). A noter que les patterns d'URL sont traits dans l'ordre de dclaration : si /** tait dclar en premier, les autres patterns ne seraient pas vrifis. Le dernier lment <sec:http-basic />permet d'afficher une invite de connexion avec une popup pour demander l'identification de l'utilisateur.

Spring Framework 2.5

Atelier 7 - Spring Security 90

Configuration avec JDBC provider Les informations d'authentification peuvent tre stockes dans une base de donnes:
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:sec="http://www.springframework.org/schema/security" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.4.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" p:driverClassName="com.mysql.jdbc.Driver" p:url="jdbc:mysql://localhost:3306/libertysoft" p:username="root" p:password="" /> <sec:authentication-provider> <sec:jdbc-user-service data-source-ref="dataSource" users-by-username-query="SELECT MAILMEMBRE, PASSWORDMEMBRE, 'true' as enabled FROM membre WHERE MAILMEMBRE = ?" authorities-by-username-query="SELECT MAILMEMBRE,ROLE as authorities FROM rolemembre WHERE MAILMEMBRE = ?" /> </sec:authentication-provider> <sec:http auto-config="true"> <sec:intercept-url pattern="/**" access="ROLE_ADMIN, ROLE_MABABA" /> <sec:http-basic /> </sec:http> </beans>

L'attribut data-source-ref permet de rfrencer un bean Spring de type DataSource. Sachant quon dispose dune base de donnes Mysql nomme libertysoft et qui comporte une table membre pour les utilisateurs, une table role pour la gestion des rles et une table rolemembre. Si vous ne spcifiez pas les attributs users-by-username-query et authorities-by-usernamequery, par dfaut Spring utilise une classe DAO qui respecte le schma SQL suivant :

Spring Framework 2.5

Atelier 7 - Spring Security 91

CREATE TABLE users ( username VARCHAR(50) NOT NULL PRIMARY KEY, password VARCHAR(50) NOT NULL, enabled BIT NOT NULL ); CREATE TABLE authorities ( username VARCHAR(50) NOT NULL, authority VARCHAR(50) NOT NULL ); ALTER TABLE authorities ADD CONSTRAINT fk_authorities_users foreign key (username) REFERENCES users(username);

Authentification par formulaire Si vous voulez activer lauthentification par formulaire, il suffit de remplacer l'lment <sec:http-basic /> par l'lment <sec:form-login />. Spring Security gnre une page de formulaire par dfaut :

Mme il est possible de spcifier deux pages dauthentification et dchec personnalises laide des attributs login-page et authentication-failure-url:
<sec:http auto-config="true"> <sec:intercept-url pattern="/**" access="ROLE_ADMIN" /> <sec:form-login login-page="/login.jsp" authentication-failure-url="/failure.jsp" /> </sec:http>

Spring Framework 2.5

Atelier 7 - Spring Security 92

Par ailleurs, la page de login doit respecter certaines rgles : Action : j_spring_security_check Nom input identifiant : j_username Nom input mot de passe : j_password

<form method="post" action="j_spring_security_check"> Identifiant : <input name="j_username" value="" type="text" /> Mot de passe : <input name="j_password" type="password" /> <input value="Valider" type="submit" /> </form>

Test de lapplication Dans notre exemple, toutes les pages sont filtres. La demande d'identification se produit quelle que soit la page demande. Une fois l'utilisateur identifi, les informations de scurit le concernant sont stockes en session HTTP dans le security context. L'identification n'est par consquent pas demande une nouvelle fois lorsque l'on navigue vers d'autres pages. Si l'utilisateur tente daccder une ressource non autorise (par exemple page index.html pour l'utilisateur guest), Spring Security renvoie une erreur 403 au navigateur web :

Spring Framework 2.5

Atelier 7 - Spring Security 93

Si l'identification de l'utilisateur est incorrecte (identifiant ou mot de passe), Spring Security renvoie une erreur au navigateur web :

Si l'identification de l'utilisateur est correcte et laccs la ressource est autorise :

Spring Framework 2.5

94

Atelier 8: Spring .NET

Spring Framework 2.5

Atelier 8 - Spring .NET 95

Atelier 8 - Spring .NET


Principe
Suite au succs de la version Java de Spring, ce ntait quune question de temps avant que la version .NET de Spring est arrive. Spring.NET est un Framework qui fournit un support complet visant linfrastructure des applications .NET. Le cur de Spring.NET est le concept de dpendance dinjection et plus gnralement linversion de contrle. En effet, Spring.NET fournit un ensemble doutils qui aident respecter les bonnes pratiques (Injection de dpendance, Programmation Oriente Aspect).

Exemple dutilisation
A travers cet atelier, nous allons prsenter les principes de base dinjection de dpendance (Dependency Injection) de Spring.NET travers une simple application console. Nous allons reproduire le mme exemple dcrit dans latelier Inversion de Contrle (IoC) ralis en java. Cration du projet Crez un nouveau projet de type Console Application :

Spring Framework 2.5

Atelier 8 - Spring .NET 96

Ajoutez la rfrence de Spring.NET votre projet. Pour cet exemple, nous avons besoin seulement de Spring.Core.dll . Les autres rfrences peuvent tre ncessaires dans des cas plus complexes. Spring.Core.dll se trouve sous le rpertoire ~\Spring.NET\Spring.NET\bin\net\2.0\debug

Configuration de Spring.Net Il existe plusieurs moyens d'obtenir une rfrence une instance du conteneur Spring.NET : IApplicationContext . Pour cet exemple, nous allons utiliser une IApplicationContext instancie partir du fichier de configuration standard des applications .NET.

Spring Framework 2.5

Atelier 8 - Spring .NET 97

Commencez alors par ajouter le fichier de configuration votre application :

Ajoutez le code suivant au fichier de configuration App.config (ou Web.config sil sagit dune application web).
<?xml version="1.0" encoding="utf-8" ?> <configuration> <configSections> <sectionGroup name="spring"> <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core" /> <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core" /> </sectionGroup> </configSections> <spring> <context> <resource uri="config://spring/objects" /> </context> <objects xmlns="http://www.springframework.net"> <description>Exemple simple sur l'utilisation de Spring IoC.</description> </objects> </spring> </configuration>

Ceci prsente configuration de base pour Spring.Net. A ce stade, vous pouvez commencer ajouter les dfinitions des objets l'intrieur du tag objects (<objects> </objects>).

Spring Framework 2.5

Atelier 8 - Spring .NET 98

Ajout des classes Nous allons maintenant refaire le mme travail que dans latelier IoC avec une implmentation bas sur Spring.NET. Crez alors les classes suivantes : Interface IFiliere :
using System; namespace SpringIoCApp { interface IFiliere { String Nom { get; } }

Une filire est caractrise par son nom. Classes FiliereGL : Cette classe implmente linterface IFiliere.
using System; namespace SpringIoCApp { class FiliereGL : IFiliere { private String _nom; public string Nom { get { return _nom; } set { _nom = value; } } } }

Spring Framework 2.5

Atelier 8 - Spring .NET 99

Classes Etudiant :
using System; namespace SpringIoCApp { class Etudiant { private IFiliere _filiere; public Etudiant() { } public Etudiant(IFiliere filiere) { _filiere = filiere; } public IFiliere Filiere { get { return _filiere; } set { _filiere = value; } } } }

Un tudiant dispose dune filire. Dfinition des objets Pour l'instant, aucun objet na t dfinit dans le fichier de configuration de l'application. Nous allons les dfinir maintenant. Ajoutez alors lextrait XML suivant lintrieur du tag <objects> du fichier App.config .
<object name="Etudiant" type="SpringIoCApp.Etudiant, SpringIoCApp" > <constructor-arg name="filiere" ref="FiliereGL" /> </object> <object name="FiliereGL" type="SpringIoCApp.FiliereGL, SpringIoCApp"> <property name="nom" value="Gnie Logiciel"/> </object>

Il est noter que le tag <object> de Spring.NET est lquivalent du tag <bean> de Spring Java. Notez aussi que nous avons spcifi le nom complet de la classe Etudiant ( SpringIoCApp.Etudiant ) au sein de l'attribut type de la dfinition de l'objet.

Spring Framework 2.5

Atelier 8 - Spring .NET 100

Setter Injection Le code suivant permet d'injecter le nom de la filire dans l'instance FiliereGL identifi par l'ID FiliereGL .
<property name="nom" value="Gnie Logiciels"/>

Constructor Injection Enfin, pour dfinir la filire de ltudiant, nous avons dfinis la rfrence linstance FiliereGL comme un argument du constructeur de l'objet Etudiant. Ainsi, lorsque l'objet Etudiant est initialis, la filire sera initialise dans le constructeur.
<constructor-arg name="filiere" ref="FiliereGL" />

Rcupration de lobjet Excutez le code suivant pour rcuprer l'objet partir du contexte Spring.Net:
using System; using Spring.Context; using Spring.Context.Support; namespace SpringIoCApp { class Program { static void Main(string[] args) { IApplicationContext ctx = ContextRegistry.GetContext(); Etudiant etudiant = (Etudiant)ctx.GetObject("Etudiant"); Console.Write("Filire : " + etudiant.Filiere.Nom ); } } }

Le rle de ce code est de rcuprer le contexte de l'application Spring.Net et demander ensuite une instance de lobjet Etudiant . Ce morceau de code ne connat que le nom de l'objet et l'interface utiliser. Il ne connait pas quelle classe est implmente (dans notre cas cest la classe FiliereGL) et il n'a pas s'inquiter sur la faon d'injecter le bon nom de filire dans l'objet car Spring.Net traite tout a. Excution

Spring Framework 2.5