Spring Framework Training Kit

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................................................................................. 8Installation ........................................................................................................................................................... 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) ...................................................... 25Principe .............................................................................................................................................................. 25 Exemple dutilisation ......................................................................................................................................... 27 Amlioration .................................................................................................................................................. 31

Atelier 3 - Programmation Oriente Aspect (AOP) .................................. 36Principe .............................................................................................................................................................. 36 Lexique .............................................................................................................................................................. 37 Exemple dutilisation ......................................................................................................................................... 38

Atelier 4 - JPA manag par Spring ........................................................... 44Principe .............................................................................................................................................................. 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 ............................................................................ 62Principe .............................................................................................................................................................. 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 ..................................................... 76Principe .............................................................................................................................................................. 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 ....................................................................... 84Principe .............................................................................................................................................................. 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


Table des matires 5

Atelier 8 - Spring .NET............................................................................. 95Principe .............................................................................................................................................................. 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


A propos des auteurs 6

A propos des auteurs

Naoufel EL HAJ lve ingnieur en Gnie Logiciel lInstitutNational 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


7

Atelier 1: Spring IDE


Atelier 1 - Spring IDE 8

Atelier 1 - Spring IDESpring 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.

InstallationAfin 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 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


Spring IDE Autowire ExtensionSpring 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 SpringSpring 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 .





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 :



Fichier de configuration SpringIl 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 :



Attribuez ensuite un nom au fichier de configuration :



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 :



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 HelloWorldCrez 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 :



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 .

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.



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







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.



Arborescence finale du projet

RefactoringSpring 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 :



Changez le nom de la classe et cliquez sur Next :


24

Atelier 2: Inversion of Contrle (IoC)


Atelier 2 - Inversion of Contrle (IoC) 25

Atelier 2 - Inversion of Contrle (IoC)PrincipeL'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


Injection de dpendances : A dpend directement de B

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



Exemple dutilisationDans 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 :



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!"); } }



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 :



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 :

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(); } }



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 matieres; public Map getMatieres() { return matieres; } public void setMatieres(Map matieres) { this.matieres = matieres; }

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



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 :



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

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 entry : etudiant.getMatieres().entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } } }



Lexcution de ce programme rsulte :


35

Atelier 3 : Programmation Oriente Aspect (AOP)


Atelier 3 - Programmation Oriente Aspect (AOP) 36

Atelier 3 - Programmation Oriente Aspect (AOP)PrincipeLa 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.



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

LexiqueLa 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.



Exemple dutilisationLobjectif 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; } }



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 + "]"); } }



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:



Le fichier de dfinition des beans est :

Explication de la configuration AOP: ... Dfinit le bloc de configuration AOP. 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. Les appels aux mthodes seront renvoys vers le bean Spring " calculatriceLogger " (classe CalculatriceLogger) Avant l'appel (before) des deux mthodes "logMethodEntry()" et "logMethodExit()", la mthode "CalculatriceLogger.logMethodEntry()" est appele.



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 :


43

Atelier 4 : JPA manag par Spring


Atelier 4 - JPA manag par Spring 44

Atelier 4 - JPA manag par SpringPrincipeL'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 dutilisationNous 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 :



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



cliquez sur Add Connection .



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



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 .



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



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



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 :



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



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.



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); } }



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 MembreServiceimport org.insat.entities.Membre; public interface MembreService { public Membre findById(String id); }



Crez ensuite la classe dimplmentation MembreServiceImpl Classe MembreServiceImplpackage 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



Crer ensuite un fichier nomm jdbc.properties sous le rpertoire src pour y stocker les paramtres de la base : jdbc.propertiesjdbc.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.



Crez le fichier de configuration applicationContext.xml sous le rpertoire src et y insrez le code suivant:



Explication Spcifier la DataSource qui est utilis par Hibernate :

Indiquer Spring les paramtres de l entityManagerFactory initialiser :

By

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) :

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



Excution du projet Excuter le code suivant pour tester lextraction des donnes partir de la base : Classe org.insat.test.TestMembrepackage 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("[email protected]").getNommembre()); } }


61

Atelier 5: Spring MVC


Atelier 5 - Spring MVC 62

Atelier 5 - Spring MVCPrincipeSpring 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


Exemple dutilisationL'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 :



Entrez le nom du projet et cliquez sur Finish :



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-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 .



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 :



dispatcher org.springframework.web.servlet.DispatcherServlet 1 dispatcher *.htm redirect.jsp

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 :







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 : /WEB-INF/jsp/ .jsp

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

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 :

/WEB-INF/jsp/ .jsp

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


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 :

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


Welcome Page Ceci est la page welcomePage. Le message est : ${welcomeMessage} !!

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:




75

Atelier 6 : Intgration Spring dans JSF


Atelier 6 - Intgration Spring dans JSF 76

Atelier 6 - Intgration Spring dans JSFPrincipeSpring 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 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 dutilisationLa 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 :



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 :



Ajouter JavaServer Faces votre application web:

Ajouter la nature Spring votre application :



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 : contextConfigLocation /WEB-INF/applicationContext.xml org.springframework.web.context.ContextLoaderListener org.springframework.web.context.request.RequestContextListener



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 : org.springframework.web.jsf.DelegatingVariableResolver

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; } }



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) :

Cration dune page web Crer une page web qui permettra laccs aux donnes instancis par Spring, en tant que ManagedBean JSF : Spring Jsf Je suis , un tudiant en .



Excution Lexcution de cette application rsulte :


83

Atelier 7: Spring Security


Atelier 7 - Spring Security 84

Atelier 7 - Spring SecurityPrincipeSpring 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 ...



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



Exemple dutilisationDans 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 : Spring Security Ceci est une page scurise

Ajouter les jars suivants votre application :



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

Dclarez lintercepteur de scurit. Pour cela, ajoutez le contenu suivant dans le fichier web.xml : springSecurityFilterChain org.springframework.web.filter.DelegatingFilterProxy springSecurityFilterChain /*

Configurez le chargeur de dfinition des beans : ContextLoaderListener : org.springframework.web.context.ContextLoaderListener contextConfigLocation /WEB-INF/app-security.xml

Le fichier web.xml est dsormais bien configur.



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 :



Une configuration de base Pour une configuration chane de filtres minimale, nous modifions le fichier app-security.xml comme suit :

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 . On dfinit aussi les rgles d'accs aux pages de l'application l'aide de l'lment . 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 permet d'afficher une invite de connexion avec une popup pour demander l'identification de l'utilisateur.



Configuration avec JDBC provider Les informations d'authentification peuvent tre stockes dans une base de donnes:

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 :



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 par l'lment . 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:



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

Identifiant : Mot de passe :

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 :



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 :


94

Atelier 8: Spring .NET


Atelier 8 - Spring .NET 95

Atelier 8 - Spring .NETPrincipeSuite 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 dutilisationA 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 :



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.



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). Exemple simple sur l'utilisation de Spring IoC.

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



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; } } } }



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 du fichier App.config .

Il est noter que le tag de Spring.NET est lquivalent du tag 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.



Setter Injection Le code suivant permet d'injecter le nom de la filire dans l'instance FiliereGL identifi par l'ID FiliereGL .

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.

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


Documents

Spring Framework Training Kit