1 / 51

Formation Spring Spécifique

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.

cairo-richmond
Download Presentation

Formation Spring Spécifique

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Formation Spring Spécifique 1

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

  3. Etape 1 : Introduction Spring • Historique • Définition • Architecture 3

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

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

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

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

  8. SPRING : architecture modulaire • Jusqu'où votre appli. sera orientée SPRING ? 8

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

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

  11. SPRING : architecture modulaire • Exemple modules pour appli Struts/Hibernate 11

  12. SPRING : architecture modulaire • Exemple modules pour appli Struts/JMS 12

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

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

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

  16. Exemple de couplage fort 16

  17. Problèmes couplage fort • Pas de 'Saxophone' sans 'Musicien' • Difficile de tester la Classe Musicien • Difficile de réutiliser la Classe Musicien 1) Masquer l'implémentation avec Interfaces ! 2) Injection de code à l'exécution. solutions 17

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

  19. Exemple de couplage faible Ici les classes sont indépendantes. Couplage faible 19

  20. Déclaration Musicien et Saxophone REFERENCE : http://static.springframework.org/spring/docs/2.5.x/reference/beans.html Fichier de configuration de Spring : applicationContext.xml 20

  21. Lancement de l'Application 1)Chargement conteneur 2)Récupération bean 3) Utilisation bean joue Vive le vent... : TOOT TOOT TOOT 21

  22. Modification paramétrage... Le musicien change d'instrument... 22

  23. Lancement de l'Application 1)Chargement conteneur 2)Récupération bean 3) Utilisation bean joue Vive le vent... : PLINK PLINK PLINK 23

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

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

  26. 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.DelegatingActionProxy ) 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

  27. Mise en oeuvre Struts + Spring • Dans la pratique, nous continuons à coder actions struts normalement. La seule différence est que , dans struts-config.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

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

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

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

  31. Intégration Spring / JMS • API JMS • Fournisseur ActiveMQ • JmsTemplate de Spring • Envoi/réception de message 31

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

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

  34. Queue / Topic 34

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

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

  37. Config Active MQ dans Spring 37

  38. Configuration JmsTemplate 38

  39. JmsTemplate : gestion Exceptions 39

  40. Envoi message avec JmsTemplate Injections Queue ou Topic ? Callback MessageCreator 40

  41. Réception Synchrone de message 1 2 3 41

  42. Réception Asynchrone de message 42

  43. Réception Asynchrone de message 43

  44. Namespace jms 44

  45. Convertion de type : interface Converter 45

  46. ANNEXES • Ressources • Architecture JEE • Architecture en couche • API JEE 46

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

  48. Architecture multicouche 48

  49. Architecture J2EE 49

  50. Livraisons J2EE 50

More Related