SPRING - Objis

Formation Spring
Spécifique
1
SOMMAIRE
• Historique, définition et architecture (p3)
• Concept clé N°1 : injection de dépendances (p13)
• DEV : Intégration Spring / JMS (p31)
• DEV : Intégration Spring / Struts (p24)
• Conclusion – ressources – Rappels J2EE (p46)
2
Etape 1 : Introduction Spring
 Historique
 Définition
 Architecture
3
SPRING : Historique
 Rod Johnson (2002)
 Faire avec un simple bean (POJO)
ce qui était seulement possible avec EJBs
 Environnement J2SE et J2EE
 Simplicité
 Testabilité
 Couplage faible. Programmation par interfaces
4
Mission du Framework Spring
 Nous pensons que:
– J2EE devrait être plus facile à utiliser
– Il est préférable de programmer à travers des interfaces plutôt qu’à
travers des classes.
– La conception OO est plus importante qu’une toute technologie
d’implémentation, comme J2EE.
– Trop d’exceptions à gérer en Java ! Et si un framework nous permettait
de mieux gérer les exceptions ?
– Les tests sont essentiels. Et si un framework nous permettait de tester
facilement notre application.
 Nous souhaitons que:
– Spring soit un plaisir à utiliser
– Votre code applicatif “ne dépende pas” des APIs Spring.
– Spring n’entre pas en compétition avec de bonnes solutions existantes,
mais facilite l’intégration avec ces solutions.. (Par example, Hibernate est
un bon outil de mapping O/R. Pourquoi en créer un autre ?.)
5
SPRING : définition
 Framework et conteneur léger, à injection de dépendance et
orienté aspect.
– framework : permet configuration et création d'applications
complexes à partir de composants réutilisables
– conteneur : Spring contient et manage cycle de vie des
composants susceptibles d'être injectés
– léger : taille (2,8Mb) + surcharge JVM + non intrusif
– à injection de dépendance : Spring vous injecte les composants
dont vous avez besoin = JNDI Reverse.
– orienté aspect : permet séparation logique métier et services
techniques transversaux (Logs, Sécurité. Transaction..)
6
Conteneurs Spring
 Plusieurs implémentations de Conteneurs héritant de 2 interfaces
principales
 BeanFactory (org.springframework.beans.factory.BeanFactory)
– Ex : XMLBeanFactory : définition beans dans XML
– Convient si pb de ressources (Ex :tel portable)
 ApplicationContext (org.springframework.context.ApplicationContext)
– Extension de BeanFactory
– Ex : ClassPathApplicationContext,FileSystemXMLApplicationContext
– Messages, I18n, publication d'évènements à des listeners
7
SPRING : architecture modulaire
 Jusqu'où votre appli. sera orientée SPRING ?
8
SPRING : Modules clés
 Core : fonctions essentielles. Utilise fabrique de bean
(conteneur) org.springframework.beans.factory.BeanFactory.
Support de l'injection.
 Application Context : ce qui permet de faire de Spring
un Framework : support internationalisation (i18n), cycle de vie,
validations + services entreprises : acces JNDI, integration EJB,
scheduling + intégration velocity/Freemarker
 AOP : Gère la séparation préocupations transversales
techniques. Possibilité créez vos propres aspects. Intégration
avec AspectJ et basés sur interfaces de l'AOP Alliance
 DAO / JDBC : accès aux données (gestion exceptions).
 ORM : intégration framework ORM (hibernate, iBatis, JPA,
JDO). Rq : avec DAO, permet de donner DAO à plusieurs
frameworks ORM.
9
SPRING : Modules clés
 JMX : possibilité d'exposer vos beans comme composants JMX
(Java Management Extension). Monitoring des beans.
 JCA : connecteur JEE. Intégration Spring avec mainframes, et
autres système d'information (ERP,CRM, MOM...)
 Spring MVC : Créer applications web Model-Vue-Controlleur
avec Spring.
 Portlets : Une page web = plusieurs portlets
 Remoting : Accéder aux beans à travers le réseau.
Intégration RMI, JAX-RPC, JAX-WS.
 JMS : Intégration Java Messages Services
10
SPRING : architecture modulaire
 Exemple modules pour appli Struts/Hibernate
11
SPRING : architecture modulaire
 Exemple modules pour appli Struts/JMS
12
Etape 2 : Injection de dépendances
 Inversion de controle (IoC) et Injection de dép.
 Sans injection : couplage fort entre objets
 Avec injection : couplage faible
13
Inversion de Contrôle (IoC)
 IoC = Votre code partage avec un framework le
flot d'éxécution d'un programme.
 Exemple avec les listeners de SWING
 IoC différent de Injection de dépendances...
14
Sans injection
 Pour travailler avec un objet, nous le
crééons (en dur) avec les techniques
suivantes
• New()
• JNDI Lookup
 Cela créée un couplage (statique) fort entre
l'objet demandeur et l'objet apellé.
15
Exemple de couplage fort
16
Problèmes couplage fort
 Pas de 'Saxophone' sans 'Musicien'
 Difficile de tester la Classe Musicien
 Difficile de réutiliser la Classe Musicien
solutions
1)
! Masquer l'implémentation avec Interfaces
2) Injection de code à l'exécution.
17
Avec injection
 Pour travailler avec un objet possédant un
savoir-faire, nous déclarons une interface
que l'objet doit implémenter.
• Spring injecte dynamiquement un objet
implémentant cette interface. L'objet est
déclaré dans un fichier xml de configuration,
par défaut applicationContext.xml
 Cela créée un couplage faible entre l'objet
demandeur et l'objet apellé. Ils n'ont pas
besoin de se connaître mutuellement.
18
Exemple de couplage faible
Ici les classes sont
indépendantes.
Couplage faible
19
Déclaration Musicien et
Saxophone
REFERENCE : http://static.springframework.org/spring/docs/2.5.x/reference/beans.html
Fichier de configuration de Spring : applicationC
20
Lancement de l'Application
1)Chargement
conteneur
2)Récupération bean
3) Utilisation bean
joue Vive le vent... : TOOT TOOT TOOT
21
Modification paramétrage...
Le musicien change d'instrument...
22
Lancement de l'Application
1)Chargement
conteneur
2)Récupération bean
3) Utilisation bean
joue Vive le vent... : PLINK PLINK PLINK
23
Intégration Struts / Spring
 Valeur ajoutée et limite de Struts
 Ce qu'apporte Spring à Stuts
 Stratégie d'intégration : délégation de Proxy
24
Atouts Struts / Spring
 Struts apporte une couche MVC simple et bien
connue des développeurs…
 …mais struts ne gère pas le Modèle !!!
 Spring apporte un accès simple en non intrusif à
une couche métier performante
 Struts + Spring = bon duo !
25
Technique : délégation d'actions
 Grace à la technique de ‘délégation d’actions’, il
est possible d’avoir des classes étant à la fois
des actions struts et des beans Spring.
 L’idée est d’utiliser une classe spécifique (
org.springframework.web.struts.DelegatingAction
Proxy ) afin de déléguer à Spring la gestion de
l’action struts.
 Ces ‘nouvelles actions struts’ ont des capacités
bien supérieures aux actions classiques,
réduisant ainsi les faiblesses de Struts.
26
Mise en oeuvre Struts + Spring
 Dans la pratique, nous continuons à coder actions struts
normalement. La seule différence est que , dans strutsconfig.xml, la classe de l’action est
org.springframework.web.struts.DelegatingActionProxy ,
 <action path=‘/login’ name=‘loginForm’
type=‘org.springframework.web.struts.DelegatingActionProxy ’
parameter=‘method’
validate=‘false’
input=‘/WEB-INF/jsp/login.jsp’>
<forward name=‘success’ path=‘/WEB-INF/jsp/login_success.jsp’>
<forward name=‘failure’ path=‘/WEB-INF/jsp/login_failure.jsp’>
</action>
27
Mise en oeuvre Struts + Spring
 Dans le fichier de configuration Spring actionservlet.xml, cette action est
configurée de la façon suivante :
<bean name=‘/login’ class=‘com.objis.demospring.LoginAction’>
<property name=‘userManager’ >
<ref bean=‘userManager’>
</property>
</bean>
 Spring réalise le lien avec l’action struts via le nom du bean, identique au
chemin de l’action Struts ‘/login’
 Ici LoginActrion est à la fois une action Struts complète (qui hérite de
Action, DispatchAction…) et un bean Spring à part entière, bénéficiant
de l’inversion de contrôle
 Ici le service (userMAnager) est injecté à l’action. Ce service apellera le
bean userDAO …
28
Mise en oeuvre Struts + Spring
 Dans Les ‘nouvelles actions Struts’ :
• ne lient plus la couche présentation à une
implémentation donnée de la couche métier.
•sont plus facilement testables de manière unitaire du
point de vue de l’accès au service.
•disposent d’un mécanisme d’interception; étant des
beans Spring, nous pouvons utiliser la POA pour
intercepter leurs méthodes. Cela peut permettre d’ajouter
des mécanismes transversaux de sécurité, monitoring,
logs, cache, transaction…
29
2 avantages à retenir
 Spring va gérer parfaitement le ‘M’ de MVC, ce que Struts
ne gère pas.
 Bonne pratique : injection d’objets dans l’action Struts (ex :
service comme userMAnager) au lieu de passer par des
new() ou des JNDI Lookup. Le Code plus modulaire avec
meilleure testabilité.
30
Intégration Spring / JMS
 API JMS
 Fournisseur ActiveMQ
 JmsTemplate de Spring
 Envoi/réception de message
31
Présentation JMS
 Java Messages Service ( API 1.1 et 1.0.2)
 Envoyer / recevoir des messages
 Messages Synchones / asynchrones
 Queue (point-à-point) / Topics (abonnement)
 Produits : WebSphere MQ (IBM), Active MQ (Apache)
32
API JMS
 javax.jms.Connection / ConnectionFactory
 javax.jms.Session
 javax.jms.Destination (Queue ou bien Topic ?)
 javax.jms.Message / TextMessage
 javax.jms.MessageProducer (méthode send(Msg))
 javax.jms.MessageConsumer
33
Queue / Topic
34
Intégration Spring / JMS
 Envoi / réception synchrone : JmsTemplate
 org.springframework.jms.core
 Messages asynchrones : Listeners
 JMS 1.0.2 et JMS 1.1
 Gestion d'exceptions + réduction code
35
Active MQ
 Fournisseur JMS de la fondation Apache
 http://activemq.apache.org
 Port d'écoute par défaut : 61616
 Fabrique de Connection
(ActiveMQConnectionFactory)
 Queue / Topics
36
Config Active MQ dans Spring
37
Configuration JmsTemplate
38
JmsTemplate : gestion Exceptions
39
Envoi message
avec JmsTemplate
Injections
Queue ou Topic ?
Callback MessageCreator
40
Réception Synchrone
de message
1
2
3
41
Réception Asynchrone
de message
42
Réception Asynchrone
de message
43
Namespace jms
44
Convertion de type : interface
Converter
45
ANNEXES
 Ressources
 Architecture JEE
 Architecture en couche
 API JEE
46
Ressources
 www.springframework.org
 API :http://static.springframework.org/spring/docs/2.5.x/api
 Livres :
•Spring in action (Craig walls. Editions Manning)
•Spring par la pratique (Julien Dubois , Editions Eyrolles)
•J2EE without EJB (Rod Johnson)
47
Architecture multicouche
48
Architecture J2EE
49
Livraisons J2EE
50
Services J2EE
 JNDI : Java Naming Directory Interface
 JCA : Java Connector Architecture
 JTA : Java Transaction API
 JPA : Java Persistence API
 JMS : Java Message Service
 JAAS : Java Authentication & Authorisation Service
 JAX-WS : Java API for XML Web Services
 JAXB : Java API for XML Binding
51