Spring par la pratique

978

2212

1242

17

Cod

e d

iteur

:G

12421

ISB

N:

97

8-2

-21

2-1

24

21

-7

www.editions-eyrolles.com

A. CogolugnesTh. TemplierJ. DuboisJ.-Ph. Retaill

Arnaud Cogolugnes estarchitecte Java EE dans une socit de services eninformatique franaise. Il dispense des formations et assure la mise en placetechnique ainsi que ledveloppement dapplicationsdentreprise.

Thierry Templier est architecteet expert Web/Java EE au seindune SSII Nantes. Il y met enuvre des architecturesorientes services fondes sur Spring. Il est galementcoauteur de JavaScript pour le Web 2.0, paru chez le mme diteur.

Julien Dubois a t charg du lancement de la filialefranaise de SpringSource suite la premire dition de cetouvrage. Il travaille doncaujourdhui directement aveclquipe de dveloppement de Spring, et intervientrgulirement en tant quexpertet formateur.

Jean-Philippe Retaill estresponsable Internet au seindune grande compagniedassurance europenne. Il est galement auteur deRefactoring des applicationsJava/J2EE et coauteur deProgrammation orienteaspect pour Java/J2EE, parus chez le mme diteur.

Conc

eptio

n:

Nor

d Co

mpo

45

Arnaud Cogo lugnes

Th ierry Templ i er

Ju l i en Dubo is

Jean -Ph i l i ppe Reta i l l

Prface de Jrgen H l l er

Tirez le meilleur parti de Java EE avec Spring!Cet ouvrage montre comment dvelopper des applications Java EE professionnelles performantes laide du framework Spring. Louvrage prsente les concepts sur lesquels reposent Spring(conteneur lger, injection de dpendances, programmation orient aspect) avant de dtailler lesdiffrentes facettes du dveloppement dapplications dentreprise avec Spring : couche prsenta-tion, persistance des donnes et gestion des transactions, intgration avec dautres applicationset scurit applicative.

Cette seconde dition prsente en dtail les nouveauts majeures des versions 2.5 et 3.0 deSpring et de ses modules annexes : modle de programmation bas sur les annotations, SpringDynamic Modules for OSGi, Spring Batch, Spring Security, SpringSource dm Server, etc. Laccentest mis tout particulirement sur les bonnes pratiques de conception et de dveloppement, quisont illustres travers une tude de cas dtaille, le projet Open Source Tudu Lists.

Au sommaireLes fondations de Spring. Le conteneur lger de Spring Les concepts avancs du conteneur Spring Les conceptsde la POA (programmation oriente aspect) Spring AOP Test des applications Spring. Les frameworks de pr-sentation. Spring MVC Spring Web Flow Utilisation dAjax avec Spring (DWR, GWT). Gestion des donnes. Per-sistance des donnes Gestion des transactions Support de JMS et JCA. Technologies dintgration. Spring WebServices Spring Security Spring Batch. Spring en production. Spring Dynamic Modules et OSGi SpringSourcedm Server Supervision avec JMX.

Springpar la pratique


Spring

par

la p

ratique

A.

Co

go

lu

gn

es

Th

. T

em

pli

er

J.

Du

bo

isJ

.-P

h.

Re

ta

ill

2e dition

Spring 2.5

et 3.0

Sur le site www.springparlapratique.org Dialoguez avec les auteurs et participez au forum de discussion Accdez au code source de ltude de cas du livre Dcouvrez les complments et mises jour Tlchargez les annexes au format pdf (Spring IDE, Dveloppement OSGi dans Eclipse,

Industrialisation des dveloppements Spring dans Eclipse)

@

2e

ditio

n

Spring 2

.5

et

3.0

12421_Spring_OK_xp 18/06/09 17:03 Page 1


Titre_Spring2.0_XP 29/05/09 17:02 Page 1

CHEZ LE MME DITEUR

Des mmes auteurs

T. Templier, A. GouGeon. JavaScript pour le Web 2.0. N12009, 2007, 492 pages.

J.-P. reTAill. Refactoring des applications Java/J2EE. N11577, 2005, 390 pages.

R. pAwlAk, J.-P. reTAill, L. SeinTurier. Programmation oriente aspect pour Java/J2EE. N11408, 2004, 462 pages.

Autres ouvrages sur Java/JEE

A. pATricio. Java Persistence et Hibernate. N12259, 2008, 390 pages.

A. GoncAlveS. Cahier du programmeur Java EE 5. N12363, 2e dition 2008, 370 pages.

K. DjAAfAr. Dveloppement JEE 5 avec Eclipse Europa. N12061, 2008, 390 pages.

C. DelAnnoy. Programmer en Java. Java 5 et 6. N12232, 5e dition, 2007, 800 pages + CD-Rom.

e. puybAreT. Cahier du programmeur Swing. N12019, 2007, 500 pages.

e. puybAreT. Cahier du programmeur Java 1.4 et 5.0. N11916, 3e dition, 2006, 380 pages.

Autres ouvrages de dveloppement Web

A. boucher. Ergonomie Web. Pour des sites Web efficaces. N12479, 2e dition 2009, 456 pages.

r. GoeTTer. CSS 2 : pratique du design web. N12461, 3e dition, 2009, 340 pages.

L. jAyr. Cahier du programmeur Flex 3. N12409, 2009, 226 pages.

A. vAnnieuwenhuyze. Flex 3. N12387, 2009, 532 pages.

F. poTencier et H. hAmon. Cahier du programmeur Symfony. Mieux dvelopper en PHP avec Symfony 1.2 et Doctrine. N12494, 2009, 510 pages.

G. ponon eT J. PAuli. Cahier du programmeur Zend Framework. N12392, 2008, 460 pages.

p. roqueS. Cahier du programmeur UML 2. Modliser une application web. N12389, 4e dition, 2008, 236 pages.

C. porTeneuve. Bien dvelopper pour le Web 2.0. N12391, 2e dition 2008, 674 pages.

e. DASpeT et c. pierre De Geyer. PHP 5 avanc. N12369, 5e dition, 2008, 804 pages.


A r n a u d C o g o l u g n e s

T h i e r r y T e m p l i e r

J u l i e n D u b o i s

J e a n - P h i l i p p e R e t a i l l

a v e c l a c o n t r i b u t i o n d e S v e r i n e T e m p l i e r R o b l o u

e t d e O l i v i e r S a l v a t o r i

2e dition

Spring 2.5

et 3.0

Titre_Spring2.0_XP 29/05/09 17:02 Page 2

DITIONS EYROLLES61, bd Saint-Germain75240 Paris Cedex 05

www.editions-eyrolles.com

Le code de la proprit intellectuelle du 1er juillet 1992 interdit en effet expressment la photocopie usage collectif sans autorisation des ayants droit. Or, cette pratique sest gnralise notamment dans les tablissements denseignement, provoquant une baisse brutale des achats de livres, au point que la possibilit mme pour les auteurs de crer des uvres nouvelles et de les faire diter correctement est aujourdhui menace.En application de la loi du 11 mars 1957, il est interdit de reproduire intgralement ou partiellement le

prsent ouvrage, sur quelque support que ce soit, sans autorisation de lditeur ou du Centre Franais dExploitation du Droit de Copie, 20, rue des Grands-Augustins, 75006 Paris. Groupe Eyrolles, 2006, 2009, ISBN : 978-2-212-12421-7

Prfacede la deuxime dition

Youd like to learn about modern best practices in Enterprise Java, with Spring as the unifyingfactor? This is the book to read! It is my pleasure to introduce one of the very first books thatfocus on the latest generations of the Spring Framework: version 2.5 and 3.0, introducingstrong support for source-level metadata annotations that complement Springs traditionalXML-based approach. Whether Spring newbie or seasoned Spring developer, there is plentyfor you to discover.This book discusses Spring in a Java 5 and Java EE 5 world of annotation-based programmingmodels. It paints a complete picture of Springs philosophy with respect to annotation-baseddependency injection and annotation-based metadata overall, while pointing out that traditionalapproaches using external metadata play a key role as well. The authors will be guiding youthrough the choices, pointing out the limits and trade-offs involved.In this second edition, the authors did a fresh update to the latest mainstream trends in theSpring ecosystem: Spring 2.5s annotation-based MVC programming model is thoroughlycovered, as is the annotation-based test context framework which was introduced in Spring 2.5 aswell. This represents where the Spring community is going and puts much-deserved focus onthe hidden power of the annotation-based model, such as flexible method signatures.This book is not just up to date; it is even ahead of its time! The authors cover Spring 3.0 at theend of its milestone phase already. Key developments in the MVC space, such as Spring 3.0scomprehensive REST support, are covered next to Spring 2.5s feature set. It shows thatSpring 2.5 was half way to 3.0, since 3.0 is really all about completing the mission that2.5 started! This books side-by-side discussion indicates a smooth migration path as well.Finally, Spring is more than just the Spring Framework nowadays. Spring is rather a wholeportfolio of projects: including Spring Security, Spring Web Flow, Spring Web Services,Spring Batch, as well as Spring Dynamic Modules and SpringSource dm Server. Beyondcovering the core Spring Framework itself, this book also discusses those key portfolio projectsand demonstrates their practical use in application architectures.Enjoy!

Jrgen HLLER,Spring Framework project lead, VP & Distinguished Engineer, SpringSource

Spring Livre Page V Lundi, 15. juin 2009 5:57 17

SpringVI

Vous souhaitez en savoir plus sur les meilleures pratiques pour le dveloppement dapplica-tions dentreprise avec le framework Spring comme socle technique ? Voici le livre quil vousfaut ! Cest avec plaisir que je vous prsente un des tout premiers ouvrages sur les derniresgnrations du framework Spring, savoir les versions 2.5 et 3.0, qui proposent notammentune utilisation avance des annotations pour complter la traditionnelle approche XML deSpring. Que vous soyez un dveloppeur Spring novice ou aguerri, vous y apprendrez beaucoup.Ce livre traite de Spring dans le monde de Java 5 et de Java EE 5, dont les modles deprogrammation sappuient fortement sur les annotations. Il dresse un portrait complet de laphilosophie de Spring quant linjection de dpendances et la gestion de mtadonnes demanire gnrale via des annotations, sans ngliger les approches traditionnelles fondes surdes mtadonnes externes, qui jouent aussi un rle primordial. Les auteurs expliquent les bonschoix faire, en mettant en vidence les avantages et les inconvnients de chacun deux.Dans cette deuxime dition, leffort des auteurs a port sur la couverture exclusive des toutesdernires tendances de lcosystme Spring, comme le modle de programmation de SpringMVC ou le framework de tests unitaires, tous deux fonde sur les annotations et introduitsdans Spring 2.5. Il sagit l du chemin directeur suivi par la communaut Spring, qui met enavant la puissance cache dun modle fond sur les annotations du fait de la grande flexibilitquil offre pour la signature des mthodes.Cet ouvrage nest pas une simple mise jour : il est mme en avance sur son temps ! Lesauteurs couvrent Spring 3.0, dans la phase finale de ses milestones successifs. Les derniresnouveauts de la partie MVC, telles que le support REST introduit dans Spring 3.0, sont aussibien couvertes que les fonctionnalits spcifiques de Spring 2.5. Cela dmontre que Spring2.5 avait fait la moiti du chemin vers Spring 3.0 et que cette dernire version complte lamission commence par la version 2.5.Spring nest dsormais plus seulement un framework, mais un portfolio complet de projets,avec notamment Spring Security, Spring Web Flow, Spring Web Services, Spring Batch, maisaussi Spring Dynamic Modules et loutil dm Server. Ce livre ne couvre pas le seul frameworkSpring, mais va plus loin en traitant de ces projets cls du portfolio et en montrant leur usagedans les applications dentreprise.Bonne lecture !

Jrgen HLLERCofondateur et responsable du dveloppement de Spring Framework, SpringSource

Spring Livre Page VI Lundi, 15. juin 2009 5:57 17

Prfacede la premire dition

French readers have had to wait longer than most for a book on Spring in their nativelanguage. However, the wait has not been in vain, and they are fortunate in this, the first bookon Spring in French.

It is almost five years since I wrote the first code towards what would later become the SpringFramework. The open source project formally began in February 2003, soon making theproduct far more than any individual could achieve. Since that time, Spring has becomewidely used worldwide, powering applications as diverse as retail banking portals; airlinereservation systems; the French online tax submission system; payment engines handlinginter-bank transfers, salaries and utility bills; search engines; government agency portalsincluding that of the European Patent Office; critical scientific research systems; logisticssolutions; and football web sites. In that time, Spring also spawned a rich literature, in a varietyof languages.

This book does an excellent job, not merely of describing what Spring does, and how, but thecentral issue of why. Excellent examples illustrate the motivation for important Springconcepts and capabilities, making it not merely a book about a particular product, but a valuablebook about writing effective server-side Java applications.

While this book is ideal as an introduction to Spring and modern concepts such as Depen-dency Injection and Aspect Oriented Programming, it always respects the reader. The authorsnever write down to their readership. While their experience stands out, and they offer clearguidance as to best practice, the reader feels involved in their discussion of architectural choicesand trade-offs.

The content is not only up to date, but broad in scope and highly readable. Enterprise Java isa dynamic area, and open source projects are particularly rapidly moving targets. Spring hasprogressed especially rapidly in the last six months, with work leading up to the final releaseof Spring 2.0. The authors of this book have done a remarkable job of writing about Spring 2.0features as soon as they have stabilized. The coverage of AJAX is also welcome.

The writing style is clear and to the point, making the book a pleasure to read.

Spring Livre Page VII Lundi, 15. juin 2009 5:57 17

SpringVIII

Finally, the authors commitment to providing a realistic sample application (rather than thesimplistic effort that mars many books), is shown by the fact that Tudu Lists has become aviable open source project in its own right.I highly recommend this book to all those new to the Spring Framework or wishing to deepentheir understanding of it, as well as those who wish to understand the current state of enter-prise Java development.

Rod JOHNSONFounder, Spring Framework, CEO, SpringSource

Si les lecteurs francophones ont d patienter plus que dautres pour avoir accs un livre surSpring crit dans leur langue, leur attente naura pas t vaine, puisque ce premier ouvrage enfranais ddi Spring est une grande russite.Voici bientt cinq ans que jai crit les premires lignes du code de ce qui allait devenir leframework Spring. Le projet Open Source lui-mme na rellement dbut quen fvrier 2003,pour aboutir rapidement un produit outrepassant de beaucoup ce quune seule personneaurait pu raliser. Aujourdhui, Spring est largement utilis travers le monde, dans des appli-cations aussi diverses que des portails bancaires publics, des systmes de rservation de billetsdavion, le systme franais de dclaration de revenus en ligne, des moteurs de paiementsassurant les transferts interbancaires ou la gestion de la paie et des factures, des moteurs derecherche, des portails de services gouvernementaux, dont celui de lOffice europen desbrevets, des systmes critiques de recherche scientifique, des solutions de logistique ou dessites ddis au football. Durant toute cette priode, Spring a fait lobjet dune abondantelittrature, dans un grand nombre de langues.Au-del de la description de ce que fait Spring et de la faon dont il le fait, toute loriginalitde ce livre rside dans sa faon de rpondre la question centrale du pourquoi. Les trs bonsexemples qui illustrent les motivations ayant conduit llaboration des concepts et des fonc-tionnalits fondamentales de Spring en font, bien plus quun simple manuel de prise en main,un ouvrage de rfrence pour quiconque souhaite raliser efficacement des applications Javact serveur.Idal pour une introduction Spring et des concepts aussi modernes que linjection dedpendances ou la programmation oriente aspect, ce livre respecte en outre toujours lelecteur, les auteurs stant fait un point dhonneur de ne jamais le prendre de haut. Tout enprofitant de leur vaste exprience et de leur clair expos des meilleures pratiques, le lecteur sesent continuellement impliqu dans leur prsentation critique des choix darchitecture et descompromis qui en dcoulent.Le contenu de louvrage est parfaitement jour et couvre une large gamme de sujets. J2EE estun domaine trs actif, dans lequel les projets Open Source voluent de manire extrmementrapide. Spring lui-mme a fortement progress au cours des six derniers mois, pour atteindresa version finalise Spring 2.0. Les auteurs de ce livre ont accompli une vritable prouesse

Spring Livre Page VIII Lundi, 15. juin 2009 5:57 17

Prface de la premire dition IX

pour traiter des fonctionnalits de cette version de Spring 2.0 ds quelles ont pu tre stabilises.La couverture de la technologie AJAX est en outre particulirement bienvenue.Pour finir, les auteurs ont fait leffort dadjoindre au livre une application exemple ralisteplutt quune tude de cas simpliste, comme on en trouve dans trop douvrages. Cette appli-cation, Tudu Lists, est mme devenue un projet Open Source part entire, avec dj denombreux utilisateurs.Ajoutons que le style dcriture est clair et pragmatique, rendant le parcours du lecteur trsagrable.Pour toutes ces raisons, je ne saurais trop recommander la lecture de cet ouvrage ceux quidbutent dans lutilisation du framework Spring ou qui souhaitent en approfondir la matrisecomme ceux qui ont cur de mieux comprendre ltat de lart du dveloppement Javadentreprise.

Rod JOHNSONFounder, Spring Framework, CEO, SpringSource

Spring Livre Page IX Lundi, 15. juin 2009 5:57 17

Spring Livre Page X Lundi, 15. juin 2009 5:57 17

Remerciements

Nous remercions ric Sulpice, directeur ditorial dEyrolles, et Olivier Salvatori pour leursmultiples relectures et conseils.Nous remercions galement les personnes suivantes de la communaut Spring, pour leurconfiance, leur accessibilit et leur gentillesse : Jrgen Hller et Rod Johnson pour leursprfaces, Gildas Hikage Cuisinier et Florent Ramire de Jaxio pour leurs relectures.Arnaud Cogolugnes :Merci aux collgues de travail qui mont soutenu (Christophe Arnaud, Laurent Canet, JulieLaporte et ric Rouchouse) et merci Claire pour sa patience.Julien Dubois :Merci ma famille et mes proches pour leur soutien tout au long de cette aventure.Jean-Philippe Retaill :Merci Audrey et ma famille pour mavoir soutenu dans lcriture de cet ouvrage.Thierry Templier :Un grand merci tout particulier ma femme, Sverine, quant son soutien tout au long de ceprojet et pour son travail de relecture concernant mes chapitres. Merci galement toutes lespersonnes qui mont soutenu dans ce projet.

Spring Livre Page XI Lundi, 15. juin 2009 5:57 17

Spring Livre Page XII Lundi, 15. juin 2009 5:57 17

Table des matires

Prfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VRemerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XIAvant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Objectifs de cet ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1Organisation de louvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 propos de lapplication Tudu Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 qui sadresse louvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

CHAPITRE 1Introduction Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Brve histoire de Java EE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Versions de Java EE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Processus de standardisation de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Problmatiques des dveloppements Java EE . . . . . . . . . . . . . . . . . . . . . . 8En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Les rponses de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Lcosystme Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Notions darchitecture logicielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Couches logicielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14La programmation par interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Linversion de contrle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Linjection de dpendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Le conteneur lger dans une application . . . . . . . . . . . . . . . . . . . . . . . . . . 20En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Spring Livre Page XIII Lundi, 15. juin 2009 5:57 17

SpringXIV

Ltude de cas Tudu Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Prsentation de Tudu Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22Architecture de Tudu Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

PARTIE ILes fondations de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

CHAPITRE 2

Le conteneur lger de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29Premiers pas avec Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Instanciation du conteneur lger de Spring . . . . . . . . . . . . . . . . . . . . . . . . 30Le contexte dapplication de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Dfinition dun bean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Les schmas XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34Nommage des beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Les mthodes dinjection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Injection des proprits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Injection des collaborateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42Injection avec le schma p . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49Slection du mode dinstanciation, ou porte . . . . . . . . . . . . . . . . . . . . . . 50En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

Dtection automatique de composants . . . . . . . . . . . . . . . . . . . . . . . . . . 52Les diffrents types de composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52Paramtrages pour la dtection automatique . . . . . . . . . . . . . . . . . . . . . . . 53Filtrer les composants dtecter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Crer sa propre annotation de composant . . . . . . . . . . . . . . . . . . . . . . . . . 55Quand utiliser la dtection automatique ? . . . . . . . . . . . . . . . . . . . . . . . . . 56

Accs au contexte dapplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56Les post-processeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Le post-processeur de Bean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58Le post-processeur de fabrique de Bean . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Support de linternationalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

Spring Livre Page XIV Lundi, 15. juin 2009 5:57 17

Table des matiresXV

CHAPITRE 3

Concepts avancs du conteneur Spring . . . . . . . . . . . . . . . . . . . . . . . . 65Techniques avances dinjection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

Injection de Beans de portes diffrentes . . . . . . . . . . . . . . . . . . . . . . . . . 66Vrification des dpendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Techniques avances de dfinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70Dfinitions abstraites de Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70Support de nouveaux types pour les valeurs simples . . . . . . . . . . . . . . . . 71Support de fabriques de Beans spcifiques . . . . . . . . . . . . . . . . . . . . . . . . 72

Cycle de vie des Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74Lancement des traitements via XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Lancement des traitements via des interfaces . . . . . . . . . . . . . . . . . . . . . . 76Lancement des traitements via des annotations . . . . . . . . . . . . . . . . . . . . 76

Abstraction des accs aux ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . 77Accs programmatique une ressource . . . . . . . . . . . . . . . . . . . . . . . . . . 79Injection de ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Spring dans une application Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80Externalisation de la configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81Langage dexpression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82Publication dvnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

couter des vnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85Publier des vnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Quand utiliser le modle vnementiel de Spring ? . . . . . . . . . . . . . . . . . 87

Scinder les fichiers de configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Langages dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

Dclaration de Beans dans des fichiers ddis . . . . . . . . . . . . . . . . . . . . . 92Rafrachissement des Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Dclaration de Beans en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94Injection de dpendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94Considrations sur les langages dynamiques . . . . . . . . . . . . . . . . . . . . . . 96

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

CHAPITRE 4

Les concepts de la POA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99Limites de lapproche oriente objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Intgration de fonctionnalits transversales . . . . . . . . . . . . . . . . . . . . . . . 101

Spring Livre Page XV Lundi, 15. juin 2009 5:57 17

SpringXVI

Exemple de fonctionnalit transversale dans Tudu Lists . . . . . . . . . . . . . . 101Analyse du phnomne de dispersion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

Notions de base de la POA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108La notion daspect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108Le tissage daspect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114Utilisation de la POA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

CHAPITRE 5

Spring AOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117Implmentation de la notification avec Spring AOP . . . . . . . . . . . . . . . 117

Implmentation de laspect de notification avec Spring AOP classique . . 118Implmentation de laspect de notification avec le support AspectJ de Spring AOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

Utilisation de Spring AOP classique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122Dfinition dun aspect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123Porte des aspects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123Les coupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123Les greffons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

Utilisation de Spring AOP avec AspectJ . . . . . . . . . . . . . . . . . . . . . . . . . 129Dfinition dun aspect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129Les coupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131Les greffons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134Le mcanisme dintroduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139Le tissage des aspects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141Modifications de cibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

Prconisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

CHAPITRE 6

Test des applications Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149Pourquoi crire des tests ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150Les tests unitaires avec JUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Les cas de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151Les assertions et lchec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Spring Livre Page XVI Lundi, 15. juin 2009 5:57 17

Table des matiresXVII

Excution des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

Les simulacres dobjets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158Diffrences entre simulacres et bouchons . . . . . . . . . . . . . . . . . . . . . . . . . 158Les simulacres dobjets avec EasyMock . . . . . . . . . . . . . . . . . . . . . . . . . . 159Les simulacres dobjets de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164Autres considrations sur les simulacres . . . . . . . . . . . . . . . . . . . . . . . . . . 165En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

Les tests dintgration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166Les extensions de Spring pour JUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166Utilisation de DbUnit avec Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Ragir lexcution des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

PARTIE IILes frameworks de prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

CHAPITRE 7

Spring MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Implmentation du pattern MVC de type 2 dans Spring . . . . . . . . . . 183

Fonctionnement du patron MVC 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184Principes et composants de Spring MVC . . . . . . . . . . . . . . . . . . . . . . . . . 185

Initialisation du framework Spring MVC . . . . . . . . . . . . . . . . . . . . . . . 187Gestion des contextes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187Initialisation du contrleur faade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Support des annotations pour les contrleurs . . . . . . . . . . . . . . . . . . . . . . 190En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

Traitement des requtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191Slection du contrleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191Les types de contrleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

Spring MVC et la gestion de la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205Slection de la vue et remplissage du modle . . . . . . . . . . . . . . . . . . . . . . 205

Spring Livre Page XVII Lundi, 15. juin 2009 5:57 17

SpringXVIII

Configuration de la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Les technologies de prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Support de REST (Representational State Transfer) . . . . . . . . . . . . . . 216Contrleur Web REST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Le RestTemplate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

Mise en uvre de Spring MVC dans Tudu Lists . . . . . . . . . . . . . . . . . . 222Configuration des contextes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222Implmentation des contrleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223Implmentation de vues spcifiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

CHAPITRE 8

Spring Web Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231Concepts des flots Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

Dfinition dun flot Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232Les types dtats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

Mise en uvre de Spring Web Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234Configuration du moteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235Langage dexpression et portes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242Configuration des lments dun flot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244Scurisation dun flot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

Mise en uvre de Spring Web Flow dans Tudu Lists . . . . . . . . . . . . . . 262Conception des flots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262Implmentation des entits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

CHAPITRE 9

Utilisation dAJAX avec Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271AJAX et le Web 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Le Web 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272Les technologies dAJAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

Le framework AJAX DWR (Direct Web Remoting) . . . . . . . . . . . . . . 276Principes de fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Spring Livre Page XVIII Lundi, 15. juin 2009 5:57 17

Table des matiresXIX

Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279Utilisation de lAPI Servlet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283Gestion des performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283Intgration de Spring et de DWR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

Le framework GWT (Google Web Toolkit) . . . . . . . . . . . . . . . . . . . . . . 287Principes de fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287Configuration de GWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288Interfaces graphiques Web riches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290Appels distants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292Intgration de Spring et GWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

Mise en uvre dAJAX avec DWR dans Tudu Lists . . . . . . . . . . . . . . 296Fichiers de configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296Chargement chaud dun fragment de JSP . . . . . . . . . . . . . . . . . . . . . . . . 296Modification dun tableau HTML avec DWR . . . . . . . . . . . . . . . . . . . . . . 298Utilisation du patron open-entity-manager-in-view avec JPA . . . . . . . . . . 299

Mise en uvre dAJAX avec GWT dans Tudu Lists . . . . . . . . . . . . . . 300Fichiers de configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300Construction de linterface graphique avec GWT . . . . . . . . . . . . . . . . . . . 302Modification dun tableau avec GWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

PARTIE IIIGestion des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

CHAPITRE 10

Persistance des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311Stratgies et design patterns classiques . . . . . . . . . . . . . . . . . . . . . . . . . 312

Le design pattern script de transaction . . . . . . . . . . . . . . . . . . . . . . . . . . . 312Le design pattern DAO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313Le design pattern modle de domaine et le mapping objet/relationnel . . . 314En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

Accs aux donnes avec Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

Support JDBC de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317JdbcTemplate et ses variantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Classe de DAO pour JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

Spring Livre Page XIX Lundi, 15. juin 2009 5:57 17

SpringXX

Configuration dune DataSource . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

Support ORM de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326Le standard JPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326Gestion des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

Solutions non standardises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334iBATIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334Hibernate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

CHAPITRE 11

Gestion des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345Rappels sur les transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

Proprits des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346Types de transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348Gestion des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349Types de comportements transactionnels . . . . . . . . . . . . . . . . . . . . . . . . . 351Ressources transactionnelles exposes . . . . . . . . . . . . . . . . . . . . . . . . . . . 353Gestionnaires de transactions JTA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354Concourance daccs et transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

Mise en uvre des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356Gestion de la dmarcation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356Mauvaises pratiques et anti-patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357

Lapproche de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358Une API gnrique de dmarcation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358Injection du gestionnaire de transactions . . . . . . . . . . . . . . . . . . . . . . . . . . 361Gestion de la dmarcation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362Synchronisation des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367Fonctionnalits avances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368Approches personnalises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

Mise en uvre de la gestion des transactions dans Tudu Lists . . . . . . 372Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

Spring Livre Page XX Lundi, 15. juin 2009 5:57 17

Table des matiresXXI

CHAPITRE 12

Support des technologies JMS et JCA . . . . . . . . . . . . . . . . . . . . . . . . . . 375La spcification JMS (Java Messaging Service) . . . . . . . . . . . . . . . . . . 376

Interaction avec le fournisseur JMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378Constituants dun message JMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381Envoi de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382Rception de message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384Versions de JMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385

Support JMS de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385Configuration des entits JMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386Envoi de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388Rception de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

La spcification JCA (Java Connector Architecture) . . . . . . . . . . . . . . 396Gestion des communications sortantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 397Gestion des communications entrantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

Support JCA de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401Communications sortantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401Communications entrantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408

Mise en uvre de JMS et JCA dans Tudu Lists . . . . . . . . . . . . . . . . . . 409Configuration de lintercepteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409Envoi des messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410Rception des messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413

PARTIE IVTechnologies dintgration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415

CHAPITRE 13

Spring Web Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417Les services Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Concepts des services Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418Spring WS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418

Lapproche dirige par les contrats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

Spring Livre Page XXI Lundi, 15. juin 2009 5:57 17

SpringXXII

Mise en uvre de services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420Mapping des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431Appels des services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435Gestion des transports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440

Mise en uvre de Spring WS dans Tudu Lists . . . . . . . . . . . . . . . . . . . 441Configuration des contextes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441Dfinition des contrats des services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442Mapping des messages changs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444Implmentation des endpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446Implmentation de clients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448

CHAPITRE 14

Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451La scurit dans les applications Web . . . . . . . . . . . . . . . . . . . . . . . . . . . 451

Les besoins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452Rappel des principales notions de scurit . . . . . . . . . . . . . . . . . . . . . . . . 453

La scurit Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454JAAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454La spcification Java EE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454

Utilisation de Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455Principaux avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455Historique de Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457Configuration de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458Gestion de lauthentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459Scurit dune application Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473Scurisation de linvocation des mthodes . . . . . . . . . . . . . . . . . . . . . . . . 479Le systme de dcision dautorisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482Scurisation des vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485Mise en cache des donnes utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486Scurisation des objets de domaine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496

Spring Livre Page XXII Lundi, 15. juin 2009 5:57 17

Table des matiresXXIII

CHAPITRE 15

Spring Batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497Concepts de Spring Batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498

Composants externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499Notions de job et dtape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499Contenu dune tape de job . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500Lecture et criture de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501Gestion des batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502

Premiers pas avec Spring Batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502Lecture, transformation et criture de donnes . . . . . . . . . . . . . . . . . . 505

Principes et composants impliqus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506Support pour les fichiers plats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507Support pour les fichiers XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511Support pour les bases de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514

Lancement des batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517Notions avances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519

Historisation des batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519Interception de lexcution dune tape . . . . . . . . . . . . . . . . . . . . . . . . . . 524Flot dun job . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526Gestion des transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527Gestion des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 529

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533

PARTIE VSpring en production . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535

CHAPITRE 16

Spring Dynamic Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537La technologie OSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537

Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538Architecture dOSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539Les composants OSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540Gestion des dpendances entre les composants . . . . . . . . . . . . . . . . . . . . 544Interaction avec le conteneur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551

Spring Livre Page XXIII Lundi, 15. juin 2009 5:57 17

SpringXXIV

Concepts avancs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555

Spring Dynamic Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555Frameworks et OSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555Mise en uvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557Espace de nommage OSGi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567

Mise en uvre de Spring Dynamic Modules dans Tudu Lists . . . . . . 567En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582

CHAPITRE 17

Loutil dm Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583Concepts gnraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583

Complexit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584Solutions apportes par dm Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584Gestion des dpendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590

Structuration des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590Fichiers war . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591Modules Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594Fichiers par . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598

Plate-forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599Installation et mise en uvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599Gestion du dpt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600Administration et dploiement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601Traces applicatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602Configuration avance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603

Mise en uvre de dm Server dans Tudu Lists . . . . . . . . . . . . . . . . . . . . 607Configuration du dpt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608Composant source de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609Composant daccs aux donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611Composant dinterface Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612Composant par de lapplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614

Spring Livre Page XXIV Lundi, 15. juin 2009 5:57 17

Table des matiresXXV

CHAPITRE 18

Supervision avec JMX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615Les spcifications JMX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615

Architecture de JMX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616Les notifications JMX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624Implmentations de JMX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630

JMX avec Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630Fonctionnalits du support JMX par Spring . . . . . . . . . . . . . . . . . . . . . . . 630Exportation de MBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631Contrle des informations exportes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633Gestion des noms des MBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639Les connecteurs JSR 160 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641Les notifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642En rsum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644

Mise en uvre du support JMX de Spring dans Tudu Lists . . . . . . . . 645La supervision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649

Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653

Spring Livre Page XXV Lundi, 15. juin 2009 5:57 17

Spring Livre Page XXVI Lundi, 15. juin 2009 5:57 17

Avant-propos

Spring est un framework Open Source rendant lutilisation de Java EE la fois plus simple etplus productive. Tout au long de cet ouvrage, nous nous efforons de dgager les bonnes prati-ques de dveloppement dapplications Java/Java EE, dont une large part ne sont pas propres Spring, mais dont la mise en uvre est grandement simplifie et rendue plus consistante grce son utilisation.Spring sappuie sur des concepts modernes, tels que linversion de contrle ou la program-mation oriente aspect, afin damliorer larchitecture des applications Java/Java EE en lesrendant plus souples, plus agiles et plus facilement testables.Sintgrant avec les grands frameworks Open Source tels quHibernate, ainsi quavec les stan-dards Java EE, Spring propose un modle dapplication cohrent, complet et simple demploi.Recommand par de nombreux architectes et dveloppeurs expriments, Spring commence se diffuser au sein des SSII et des entreprises franaises. Une bonne connaissance de ceproduit est donc essentielle aujourdhui, dans le monde trs concurrentiel de linformatiquedentreprise.

Objectifs de cet ouvrageCet ouvrage se veut un guide pratique autour de Spring et de lcosystme technologique quigravite autour. Spring ayant volu et stant fortement toff ces dernires annes, nousprivilgions le cur du modle de programmation introduit dans Spring 2.5, puis perptuavec Spring 3.0, ainsi que lenvironnement dexcution de SpringSource, qui sappuie notammentsur OSGi.Nous avons voulu rendre ce livre accessible au plus grand nombre afin de permettre aux dve-loppeurs Java/Java Java EE dtre plus productifs et de mieux russir leurs projets laide deSpring. Cest la raison pour laquelle nous nentrons pas dans la description dAPI complexes.Il sagit avant tout dun ouvrage didactique, destin rendre le lecteur directement oprationnel.Cette volont daccessibilit ne signifie pas pour autant que louvrage soit dune lecturesimple et peu technique. Lorsque cest ncessaire, nous abordons des thmes complexes,comme les transactions avec JTA ou lintgration avec JCA.

Spring Livre Page 1 Lundi, 15. juin 2009 5:57 17

Spring2

Convaincus que lon apprend mieux par la pratique, nous adjoignons louvrage une tude decas complte, lapplication Tudu Lists. Le lecteur a de la sorte sous les yeux, au fur et mesure de sa progression, des exemples de mise en uvre concrte, dans une applicationrelle, des sujets traits. Quand le sujet principal dun chapitre sy prte, une tude de casfonde sur Tudu Lists est dcrite avec prcision.

Organisation de louvrageLouvrage commence par dcrire des principes et des problmes courants des applicationsJava/Java EE, puis aborde des concepts darchitecture logicielle tels que le dveloppement encouches ou les conteneurs lgers. Cette introduction permet notamment dtablir un vocabu-laire qui sera utilis tout au long des chapitres.Louvrage comporte ensuite cinq grandes parties : La premire partie prsente de faon trs dtaille le cur de Spring, cest--dire son conte-

neur lger et son framework de programmation oriente aspect. Les tests unitaires sontaussi abords.

La partie II concerne la couche de prsentation dune application Web. Nous y prsentonsle framework Web Spring MVC ainsi que son complment Spring Web Flow. Nous passonsaussi en revue des technologies AJAX sinterfaant avec Spring.

La partie III est ddie la couche de persistance des donnes, essentiellement le mappingobjet/relationnel, la gestion des transactions et les technologies JMS/JCA.

Une application ayant souvent besoin dinteragir avec dautres systmes, la partie IV sint-resse aux technologies dintgration. Lintgration peut tre ralise en Java, avec les techno-logies JCA ou JMS, mais galement en XML, en particulier via des services Web. Cettepartie aborde aussi la scurit avec Spring Security et les traitements batch avec SpringBatch.

La partie V soriente vers les applications Spring lors de leur excution, avec le support deSpring pour OSGi, le serveur dapplications dm Server et le support JMX de Spring.

propos de lapplication Tudu ListsLapplication Tudu Lists, qui nous sert dtude de cas tout au long de louvrage, est unexemple concret dutilisation des technologies Spring. Il sagit dun projet Open Sourcerel, qui a t ralis spcifiquement pour cet ouvrage, et qui permet dillustrer par lexempleles techniques dcrites dans chacun des chapitres.Loin de ntre quun simple exemple, cette application est utilise en production dansplusieurs entreprises. Le principal serveur Tudu Lists possde ainsi plus de cinq mille utilisateurs.Cette application tant Open Source, le lecteur est invit participer son dveloppement.Elle est disponible sur le site de louvrage, ladresse http://www.springparlapratique.com.


Avant-propos 3

Le code source utilis dans louvrage nest pas directement issu de lapplication de produc-tion, notamment pour des raisons pdagogiques. Il est cependant disponible sur le site delouvrage. Toutes les instructions ncessaires linstallation des projets des diffrents chapitresy sont dcrites. Un forum permettant de poser des questions aux auteurs y est en outre propos.

qui sadresse louvrage ?Cet ouvrage sadresse tout dveloppeur Java/Java EE souhaitant amliorer sa productivit etses mthodes de dveloppement et sintressant larchitecture des applications.Il nest cependant nul besoin dtre expert dans les diffrentes technologies prsentes.Chaque chapitre expose clairement chacune delles, puis montre comment elle est implmen-te dans Spring avant den donner des exemples de mise en uvre dans lapplication TuduLists.Pour toute question, vous pouvez contacter les auteurs sur la page ddie louvrage du siteWeb des ditions Eyrolles, ladresse www.editions-eyrolles.com.


1Introduction Spring

Ce chapitre a pour vocation de prciser le contexte du dveloppement dapplications dentre-prises dans le monde Java, cela notamment pour expliquer quelle place le projet Springoccupe dans cette sphre vaste et complexe. Nous prsenterons donc ldition entreprise de laplate-forme Java, travers un bref historique et son mcanisme de standardisation. Cetteprsentation mettra en vidence les limites des outils standards de cette plateforme, nousverrons alors comment le projet Spring parvient les combler. Un ensemble de notions essen-tielles au modle de programmation de Spring seront ensuite abordes. Nous finirons par unemise en pratique de ces notions travers la prsentation de ltude de cas Tudu Lists, utilisecomme fil conducteur dans cet ouvrage.

Brve histoire de Java EEJava EE (Java Enterprise Edition) est une plate-forme fonde sur le langage Java et son envi-ronnement dexcution, qui regroupe un ensemble de technologies destines dvelopper desapplications dentreprise. Ces applications ont la plupart du temps une composante serveur etsont concurrentes, cest--dire quelles sont susceptibles dtre accdes par plusieursutilisateurs simultanment.La partie serveur est hberge par un composant logiciel appel serveur dapplications, qui fournitune infrastructure dexcution aux applications. Un exemple dinfrastructure dexcution est letraitement de requtes HTTP : le serveur dapplications gre les entres/sorties rseau et passe lamain aux applications pour les traitements purement fonctionnels. Ce mode de fonctionnementpermet aux applications de saffranchir dun certain nombre de problmatiques techniques etde se concentrer sur les parties mtier, qui offrent une relle plus-value pour lutilisateur final.La gestion des requtes HTTP nest quun exemple parmi un grand nombre de technologiesprises en charge par les diffrentes briques de la plate-forme Java EE, qui propose un support pour


Spring6

laccs aux bases de donnes, lenvoi et la rception de-mails, la production et la consommationde services Web, etc. Ces technologies dinterfaage sont compltes par dautres technolo-gies correspondant un modle de programmation : gnration dynamique de code HTML(JSP/servlet), gestion transactionnelle (JTA), gestion de la persistance (JPA), etc.Java EE vise fournir une infrastructure technique ainsi quun cadre de dveloppement pourles applications dentreprise.

Versions de Java EELa version entreprise de Java a vu le jour en 1999 sous le nom de J2EE 1.2 (Java 2 Platform Enter-prise Edition). Sans entrer dans le dtail de la logique de numrotation des versions de J2EE,sachons simplement que les versions 1.3 et 1.4 sont sorties respectivement en 2001 et 2003.Chacune de ces versions a apport son lot de nouveauts technologiques, tout en amenant denouvelles versions des technologies existantes. Les API Servlet et JSP sont certainement lesplus connues de la pile J2EE, puisquelles constituent les solutions techniques de base pourles applications Web en Java. Les EJB (Enterprise JavaBeans), solution phare pour limpl-mentation de composants dits mtiers, sont aussi lun de piliers de J2EE.Si le modle thorique dune application fonde sur J2EE tait des plus prometteurs, sa miseen pratique sest avre trs difficile. Le modle proposait en effet un grand nombre de solutions,souvent surdimensionnes pour la grande majorit des projets.Lchec de projets fonds sur J2EE ntait pas forcment d la plate-forme elle-mme, maisplutt la mauvaise utilisation des outils quelle fournissait. Cette mauvaise utilisation dcou-lait gnralement de la complexit de la plate-forme, dans laquelle se perdaient les quipes dedveloppement.Le symbole de la complexit de J2EE et de son inadquation aux besoins des applicationsdentreprise sincarne dans les EJB. Ces derniers disposaient datouts intressants, commeune gestion des transactions puissante et souple, mais qui saccompagnaient invariablementdinconvnients majeurs. Leur composante distribue tait, par exemple, un fardeau techno-logique, dont la plupart des applications pouvaient se passer.J2EE ne laisse cependant pas un constat dchec dfinitif. De nombreuses briques se sontrvles parfaitement adaptes pour constituer le socle dapplications dentreprise opration-nelles. Parmi ces briques, citons notamment Servlet et JSP, JavaMail, JMS (fonctionnementasynchrone) ou JTA (gestion des transactions).Ces briques nont pas t les seules impliques dans le succs des applications J2EE. 2004 at le tmoin de lmergence dun ensemble de solutions Open Source dont le but tait depallier la complexit de J2EE et, surtout, de combler ses lacunes. Caractristiques de cecourant, Hibernate et Spring ont fortement popularis le modle POJO (Plain Ordinary JavaObject), qui rejetait le modle trop technologique des EJB.La nouvelle version de ldition entreprise de Java, sortie en 2006, a su capturer lessence dumodle POJO et, forte de lapport de Java 5, a propos un modle de programmation beaucoupplus pertinent que J2EE. Cette version a t baptise Java Enterprise Edition 5 (Java EE), afin desaligner sur la version 5 du langage. Java EE 5 se caractrise fortement par la simplification


Introduction SpringCHAPITRE 1 7

en absorbant des principes du modle POJO, au profit notamment des EJB (version 3) et deJPA (une API pour grer la persistance des donnes).Java EE 6 continue le travail commenc par Java EE, en proposant des fonctionnalits la fois pluspuissantes et plus simples pour les composants phares. La spcification tend aussi une modularitde la plate-forme, avec diffrents niveaux dimplmentation des standards, qui permet de choisirexactement les composants ncessaires selon ses besoins. Cette modularit concerne princi-palement les composants dinfrastructures, car les composants logiciels sont dj modulaires.

Processus de standardisation de JavaIl existe un processus de standardisation de la plate-forme Java, appel Java CommunityProcess (JCP). Ce processus concerne toute la plate-forme Java, pas juste ldition entreprise.Llaboration de Java EE passe donc entirement par ce processus. Le JCP implique la cra-tion de requtes JSR (Java Specification Requests), qui constituent des propositions puis desralisations de certaines briques juges ncessaires la plate-forme Java. Le processus decration dune JSR est bien sr trs formalis, avec notamment llaboration dune spcifica-tion sous la forme dun document, sa validation par un jury ddi et lcriture dune impl-mentation de rfrence (reference implementation ou RI), gratuite.Une JSR constitue donc une spcification, cest--dire un standard, dans le monde Java.Il sagit bien dune spcification, cest--dire la description dun besoin de la plate-forme et laproposition dun modle adressant le besoin. La proposition doit tre trs complte et trsprcise, car elle est susceptible dtre ensuite implmente par diffrents produits. Un autrelivrable dune JSR est dailleurs un kit de validation, permettant de sassurer quun produitimplmente correctement la spcification.Toute personne peut tre partie prenante dans le JCP en proposant une JSR et mme en participant llaboration dune spcification. Une JSR est labore par un groupe dexperts, qui comprenddes experts reconnus dans le domaine concern, indpendants ou affilis des entreprises.Pour la plate-forme Java, la cration de standards assure une concurrence gnralementconstructive entre les implmentations dune JSR, base en quelque sorte sur le principe de laslection naturelle. Le standard vite normalement aussi de se retrouver pieds et poings lis unproduit (sil savre par exemple une implmentation peu performante). Cest ce quon appelle levendor lock-in. Cependant, dans les faits, le passage dune implmentation une autre pour dessystmes de grande taille se fait rarement sans douleur. Parmi les avantages des standards figureaussi linteroprabilit, permettant des systmes diffrents de communiquer.Si travers la notion de standard, le JCP a des effets bnfiques sur la plate-forme Java, ilne peut rpondre toutes les problmatiques. Les groupes dexperts ntant pas toujoursindpendants, cest--dire lis des entreprises, des dcisions dordre politique sont parfoisprises au dtriment de dcisions dordre technique, plus judicieuses. Les groupes dexperts oules comits impliqus dans le JCP ne sont dailleurs pas toujours reprsentatifs des commu-nauts dutilisateurs. Cela peut donner lieu des solutions inadaptes ou un effet tourdivoire cause de dcisions prises en petit comit.De par sa nature, le JCP ne peut constituer un lment rellement moteur dans linnovationde la plate-forme Java. Bien que la comptition entre implmentations puisse contribuer


Spring8

linnovation, il faut quelle soit correctement quilibre, car labondance de solutions provo-que de la dispersion et peut faire au final de lombre aux meilleures solutions. Le JCP basantgnralement ses spcifications sur des solutions existantes, ayant innov dans un domaine, lecaractre innovant est perdu cause de linertie du processus de standardisation.Si le JCP, travers les standards, apporte beaucoup la plate-forme Java, un ingrdientsupplmentaire est ncessaire, afin dapporter la crativit et lexprimentation nces-saires linnovation. Cet ingrdient est gnralement apport par un ensemble dacteurs, notam-ment lOpen Source, qui dispose dune souplesse que le JCP na pas. On ne peut pas opposerlOpen Source et un processus de standardisation comme le JCP, car ils disposent chacundavantages et dinconvnients, sont fortement lis et finalement complmentaires.

Problmatiques des dveloppements Java EEMalgr une simplification progressive, la plate-forme Java reste complexe, demandantdes connaissances techniques approfondies. En contrepartie, elle est dune grande puissance etpermet de rpondre aux besoins des applications les plus ambitieuses. Dvelopper desapplications avec une approche 100 % Java EE rvle cependant quatre faiblesses rcurrentes : Mauvaise sparation des proccupations : des problmatiques dordres diffrents (technique

et mtier) sont mal isoles. Cependant, cest certainement dans ce domaine que Java EE afait le plus de progrs depuis J2EE, notamment grce des concepts populariss par desframeworks comme Spring.

Complexit : Java EE reste complexe, notamment cause de la plthore de spcificationsdisponibles. Les quipes de dveloppement nont pas dangle dattaque vident et se retrou-vent parfois noyes sous loffre. Lexemple typique est un serveur dapplications monoli-thique, implmentant la totalit de la spcification Java EE, dont peine 20 % sontncessaires pour dvelopper la plupart des applications.

Mauvaise interoprabilit : malgr la notion de standard, les technologies ne sont pastoujours interoprables et portables. Une implmentation JPA disposera toujours doptionsdiffrentes de ces consurs et une application Web pourra rarement passer dun serveurdapplications un autre sans rglage supplmentaire.

Mauvaise testabilit : les applications dpendant fortement de linfrastructure dexcution,elles sont plus difficilement testables. Cest aussi une des consquences dune mauvaisesparation des proccupations.

En rsumCe bref historique de Java EE a mis en vidence les problmatiques de cette plate-forme, notam-ment une certaine inadquation avec les besoins des dveloppements dapplications dentreprise.Cependant, Java EE a su voluer et sadapter travers ses diffrentes versions, et ce depuis dixans. Cette volution a pass par une instance de standardisation, le Java Community Process(JCP). Les standards ne sont toutefois pas suffisants pour quune plate-forme telle que JavaEE soit performante et surtout innovante. LOpen Source peut tre un des acteurs de cetteinnovation en contribuant, grce un JCP attentif et lcoute, lamlioration de Java EE.



SpringNous allons voir comment Spring a su comprendre les problmes lis J2EE afin de proposerun modle de programmation plus adapt et plus productif.Java EE a su capter en partie lapport de solutions telles que Spring et sadapter dans unecertaine mesure. Nous verrons les lments qui constituent lcosystme de Spring et quisassemblent en une solution de dveloppement puissante et cohrente. Nous verronsaussi lhistoire de Spring, travers ses diffrentes versions et aborderons la plate-formeSpring, qui consiste en un serveur dapplications modulaire fond sur la technologieOSGi.

Les rponses de SpringPour remdier aux problmes que nous venons dvoquer, un ensemble de solutions a merg.Nous allons explorer les rponses apportes par Spring aux problmatiques du dveloppementdapplications dentreprise dans le cadre dune solution 100 % Java EE.

La notion de conteneur lger

Dans le monde Java, un conteneur lger est souvent oppos un conteneur EJB, jug lourdtechnologiquement et surtout peu adaptatif par rapport aux diffrents types de problmatiquescourantes dans le monde des applications dentreprise.Le conteneur lger fournit un support simple mais puissant pour grer une application via unensemble de composants, cest--dire des objets prsentant une interface, dont le fonctionne-ment interne na pas tre connu des autres composants. Le conteneur lger gre le cycle devie des composants (cration, destruction), mais aussi leurs interdpendances (tel composantsappuie sur tel autre pour fonctionner).Le conteneur lger permet davoir des applications plus portables, cest--dire parfaitementindpendantes du serveur dapplications, car lapplication vient avec son propre conteneur,qui lui fournit linfrastructure dont elle a besoin. travers son approche par composants, le conteneur lger encourage les bonnes pratiques deprogrammation : par interface, et faible couplage. Cela assure une meilleure volutivit desapplications, mais aussi amliore grandement leur testabilit.Le cur de Spring est un conteneur lger, qui est aujourdhui considr comme le pluscomplet sur le march.

La programmation oriente aspect

La programmation oriente aspect (POA) est un paradigme de programmation qui consiste modulariser des lments logiciels en complment dapproches telles que la programmationoriente objet.La POA se concentre sur les lments transversaux, cest--dire ceux qui se trouvent dupli-qus ou utiliss dans de nombreuses parties dune application, sans pouvoir tre centraliss


Spring10

avec les concepts de programmation classiques . Des exemples dlments transversauxsont la gestion des transactions, la journalisation ou la scurit. La POA amliore doncnettement la sparation des proccupations dans une application.Spring propose depuis sa premire version un excellent support pour la POA et a finalementcontribu sa popularisation. En effet, dans la mesure o le conteneur lger de Springcontrle le cycle de vie des composants dune application, il peut leur ajouter du compor-tement (on parle aussi de dcoration), et ce de faon compltement transparente.Le support de la POA par Spring nimpose aucune contrainte et permet dajouter trs facilementdu comportement nimporte quel type dobjet.

Lintgration de frameworks tiersSpring propose une intgration pour un grand nombre de frameworks et de standards Java EE.Lintgration passe gnralement par un support pour la configuration dans le conteneur lger,mais aussi par des classes dabstraction.Spring offrant une grande cohrence, les frameworks sont gnralement intgrs de maniresimilaire, ce qui facilite lassimilation et le passage de lun lautre. Spring laisse aussitoujours la possibilit dutiliser lAPI native des frameworks, car il se veut non intrusif .Il est important de noter que Spring ne limite jamais les possibilits dun framework en raisonde lintgration quil propose.Un exemple caractristique de cette intgration est le support dHibernate propos par Spring.Une partie de la configuration dHibernate est automatiquement prise en charge, et la gestiondes ressources (connexion la base de donnes, transactions), contraignante et propice deserreurs de programmation, est faite par les classes de support de Spring.

Lcosystme SpringSpring est maintenant plus quun conteneur lger, utilis pour le dveloppement dapplica-tions dentreprise. Il constitue le socle de nombreux projets (le portfolio Spring) et la basetechnique dun serveur dapplications.La figure 1-1 illustre les diffrentes briques du projet Spring, avec notamment lintgrationpropose pour certains frameworks.

Figure 1-1 Architecture de Spring

CoreConteneur

ORMHibernate,

JPA,EclipseLink

JEEJCA,JMS,JMX

JavaMail,Remoting

WebWeb MVC,

Struts,Tapestry ,

JSP,Portlet MVC

TestJUnit ,

TestNG

DAOJDBC,

Transaction

AOPAspectJ



Le projet Spring est constitu des modules suivants : Core, le noyau, qui contient la fois un ensemble de classes utilises par toutes les briques

du framework et le conteneur lger. AOP, le module de programmation oriente aspect, qui sintgre fortement avec AspectJ, un

framework de POA part entire. DAO, qui constitue le socle de laccs aux dpts de donnes, avec notamment une impl-

mentation pour JDBC. Dautres modules fournissent des abstractions pour laccs auxdonnes (solutions de mapping objet-relationnel, LDAP) qui suivent les mmes principesque le support JDBC. La solution de gestion des transactions de Spring fait aussi partie dece module.

ORM, qui propose une intgration avec des outils populaires de mapping objet-relationnel,tels que Hibernate, JPA, EclipseLink ou iBatis. Chaque outil peut bnficier de la gestiondes transactions fournie par le module DAO.

Java EE, un module dintgration dun ensemble de solutions populaires dans le monde delentreprise.

Web, le module comprenant le support de Spring pour les applications Web. Il contientnotamment Spring Web MVC, la solution de Spring pour les applications Web, et proposeune intgration avec de nombreux frameworks Web et des technologies de vue.

Test, qui permet dappliquer certaines techniques du conteneur lger Spring aux testsunitaires via une intgration avec JUnit et TestNG.

Les aspects cls de ces modules sont abords dans les diffrents chapitres de cet ouvrage.

Les projets du portfolioUn ensemble de projets gravitent autour de Spring, utilisant le conteneur lger et ses modulescomme bases techniques et conceptuelles : Spring Web Flow. Propose un support pour grer des enchanements de pages complexes

dans une application. Spring Web Services. Apporte un support pour les services Web, avec une approche

contract-first. Spring Security. Permet de grer lauthentification et lautorisation dans une application

Web, en promouvant une approche transverse et dclarative. Spring Dynamic Modules. Facilite lintgration des applications dentreprise sur la plate-

forme OSGi, afin de pousser le modle de composant jusque dans lenvironnementdexcution.

Spring Batch. Propose un support pour les traitements de type batch, manipulant de grandsvolumes de donnes.

Spring Integration. Implmentation des Enterprise Integration Patterns, qui apportent unedimension vnementielle une application Spring et lui permettent dinteragir avec dessystmes externes grce des connecteurs.


Spring12

Spring LDAP. Implmente lapproche de gestion des accs aux donnes de Spring pour lesannuaires LDAP.

Spring IDE. Ensemble de plug-ins Eclipse facilitant ldition de configurations Spring. Spring Modules. Propose une intgration dans Spring de diffrents outils et frameworks. Spring JavaConfig. Implmente une approche Java pour la configuration de contextes

Spring.Lensemble de ces projets font de Spring une solution pertinente pour tout type de dvelop-pement sur la plate-forme Java.Traiter de lensemble de ces projets ncessiterait beaucoup plus quun simple ouvrage. Nousnous contenterons donc de couvrir les aspects fondamentaux de ceux parmi ceux les plus utilissdans le monde de lentreprise.

Versions de SpringQuand la premire version de Spring est sortie, en 2004, elle contenait dj toutes les briquesde base de Spring, notamment son conteneur lger. Cependant la configuration XML tait trsgnrique et ne laissait que peu de place lextensibilit.La version 2.0, sortie en octobre 2006, a revu de fond en comble le systme de configurationXML, avec la notion de schma. Cette nouveaut rendait la configuration beaucoup moinsverbeuse, et surtout plus explicite. Elle ouvrait aussi des possibilits dextensibilit, puisquenimporte quel systme pouvait dfinir son propre schma de configuration et bnficier de lapuissance du conteneur lger.Cette version proposait en outre les premires annotations, destines complter la configu-ration XML. Spring 2.0 voyait enfin son systme de POA sintgrer trs troitement avec leframework AspectJ.Spring 2.5, sorti en novembre 2007, a pouss encore plus loin la configuration par annota-tions, aussi bien pour linjection de dpendances que pour la dclaration de

Spring par la pratique

Education

Transcript of Spring par la pratique