Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Formation : Développement JEE avec Spring FRAMEWORK SPRING Octobre 2020 . SOMMA

Formation : Développement JEE avec Spring FRAMEWORK SPRING Octobre 2020 . SOMMAIRE 1. Introduction à Spring..................................................................................................................................5 Introduction....................................................................................................................................................................................................................5 1 Formation : Développement JEE avec Spring Pré-requis........................................................................................................................................................................................................................5 1.1 Historique de Spring..........................................................................................................................................................................................5 1.2 Spring et J2EE.....................................................................................................................................................................................................7 1.3 Les modules Spring.............................................................................................................................................................................................8 1.4 Concept de Beans...............................................................................................................................................................................................9 1.5 Le contexte d'application Spring...................................................................................................................................................................9 1.6 Conception de Beans........................................................................................................................................................................................10 1.6.1 Déclarer des beans...................................................................................................................................................................................10 1.6.2 Configurer le contexte.............................................................................................................................................................................11 1.6.3 Chargement d’un contexte.....................................................................................................................................................................11 1.6.4 Récupération d’une référence d’un Bean...........................................................................................................................................11 1.6.5 Constructeurs.............................................................................................................................................................................................12 1.6.6 Configuration de bean dans le cas de l’héritage.............................................................................................................................13 1.6.8 Injection de dépendances.......................................................................................................................................................................15 1.6.9 Chargement et utilisation de propriétés dans un bean..................................................................................................................23 1.6.10 Portée des beans (scoping).................................................................................................................................................................23 1.6.11 Les espaces de nommage.....................................................................................................................................................................26 1.6.12 Initialisation et destruction de beans.............................................................................................................................................28 1.6.13 Injection dans les propriétés des beans.........................................................................................................................................28 1.6.14 Référencer d’autres beans.................................................................................................................................................................28 1.6.15 La liaison automatique inter beans (Auto-wiring).......................................................................................................................28 2 Accès aux bases de donnés.........................................................................................................................31 2.1 Accès par JDBC..................................................................................................................................................................................................31 b) Dépendances du projet...................................................................................................................................................................................31 2.2 Accès par JdbcTemplate................................................................................................................................................................................38 2.3 Intégration de Spring avec Hibernate.......................................................................................................................................................39 3 Gestion des transactions............................................................................................................................43 3.1 Tour d'horizon des gestionnaires de transactions indépendants...............................................................................................................43 3.2 Implémentation d'un scénario "Two phase-commit" avec Atomikos.............................................................................................................44 b) Configuration et codage de l'application........................................................................................................................................................48 Les tests.......................................................................................................................................................................................................................55 Classe de Services........................................................................................................................................................................................................55 Transactions entre 2 bases de données........................................................................................................................................................................58 2 Formation : Développement JEE avec Spring Transaction entre 1 base de données et un broker JMS...............................................................................................................................................60 3.2 La propagation des transactions.................................................................................................................................................................62 3.3 L'utilisation des transactions de manière déclarative.............................................................................................................................63 3.4. La déclaration des transactions dans la configuration du contexte...........................................................................................................63 3.5 Un exemple de déclaration de transactions dans la configuration.............................................................................................................68 3.6 La déclaration des transactions avec des annotations..................................................................................................................................74 3.7 L'utilisation de l'annotation @Transactional.....................................................................................................................................................76 3.8 Le support de @Transactional par AspectJ.......................................................................................................................................................78 3.9 Un exemple de déclaration des transactions avec des annotations.....................................................................................................78 3.10. La gestion du rollback des transactions.........................................................................................................................................................85 3.11 La gestion du rollback dans la configuration............................................................................................................................................85 3.13 La gestion du rollback avec les annotations...................................................................................................................................................87 3.15. La mise en oeuvre d'aspects sur une méthode transactionnelle........................................................................................................87 3.16 L'utilisation des transactions via l'API..............................................................................................................................................................92 3.17 L'utilisation de la classe TransactionTemplate......................................................................................................................................92 3.18 L'utilisation directe d'un PlatformTransactionManager...............................................................................................................................97 4 Scheduler...............................................................................................................................................99 4.1 Définition d’une tache programmée (Scheduler Task)...........................................................................................................................99 Conclusion.................................................................................................................................................................................................................101 Configuration des clients...........................................................................................................................................................................................102 5 Intégration de Spring...............................................................................................................................103 6 Mise en place d’un environnement de développement Java/Eclipse/Maven...........................................................103 6.1 Création d’un projet Maven/Eclipse pour Spring 2.5...........................................................................................................................103 3 Formation : Développement JEE avec Spring 1. Introduction à Spring Introduction Spring est un framework Java écrit par un groupe de programmeurs chevronnés, afin de simplifier le processus de développement des applications d’entreprise. Ce framework peut être vu comme une boite à outils, constituée d’un ensemble d’API, qui offre des moyens de: - Concevoir une application basée sur POJO (plain old Java objects). Remarque : Un POJO est une classe Bean Java - Réduire le couplage grace à l’injection de dépendences et une conception applicative orientée interface - Utilisation de la programmation déclarative - Réduction des temps de développement par l’utilsiation des templates Pré-requis Afin de d’utiliser le framework Spring, il est indispensable d’avoir des connaissances de base du langage de programmation Java, et idéalement maitriser un IDE tel que Eclipse. 1.1 Historique de Spring Le framework Spring a été initialement développé par Rod Johnson et Juergen Holler. Spring a connu plusieurs versions :  Spring 1.0 : mars 2004  Spring 1.1 : septembre 2004  Spring 1.2 : mai 2005  Spring 2.0 : octobre 2006  Spring 2.5 : novembre 2007  Spring 3.0 : décembre 2009  Spring 3.1 : courant 2011 Spring 1.0 implémente les fonctionnalités de base du framework :  le conteneur qui implémente le motif de conception IoC  le développement orienté POJO  l'AOP par déclaration  le support de JDBC, ORM et frameworks Web  la configuration XML basée sur une DTD 4 Formation : Développement JEE avec Spring Spring 1.2  support de JMX  support JDO 2, Hibernate 3, TopLink  support de JCA CCI, JDBC Rowset  déclaration des transactions avec @Transactional Spring 2.0 apporte de nombreuses nouveautés :  le support et l'utilisation d'AspectJ  la configuration XML basée sur un schéma XML  des simplifications de la configuration notamment avec des namespaces dédiés (beans, tx, aop, lang, util, jee, p)  les Message Driven POJO  les annotations @Repository, @Configurable Spring 2.5 apporte de nombreuses nouveautés pour faciliter sa configuration :  l'ajout de nouveaux namespaces (context, jms) avec de nouveaux tags  l'enrichissement des namespaces existants (jee, aop)  l'ajout d'annotations concernant le cycle de vie des beans (@Service, @Component, @Controller), autowiring (@Autowired, @Qualifier, @Required), la gestion des transactions (@Transactional) et support des annotations standards de Java 5 (@PostConstruct, @PreDestroy, @Resource)  les tests d'intégration reposant sur Junit 4 et des annotations (@ContextConfiguration, @TestExecutionListeners, @BeforeTransaction, @AfterTransaction) Spring 3.0 apporte de nombreuses nouveautés pour sa configuration et les fonctionnalités proposées :  des possibilités enrichies de configurer le context en utilisant des annotations : annotations issues du projet Spring JavaConfig qui sont ajoutées dans Spring Core (@Configuration, @Bean, @DependsOn, @Primary, @Lazy, @Import, @ImportResource et @Value)  Spring Expression Langage (SpEL) : un langage d'expressions utilisable pour la définition des beans dans Spring Core et pour certaines fonctionnalités dans des projets du portfolio  le support de REST  Object to XML Mapping (OXM) : abstraction pour utiliser des solutions de mapping objet/XML initialement proposée par le projet Spring Web services et intégrée dans Spring Core  requiert un Java SE 5.0 ou supérieur (refactoring des API pour une utilisation des generics, des varargs, de java.util.concurrent, ...)  une nouvelle modularisation : la distribution de Spring en jar a été revue pour que chaque module ait son propre jar. L'archive spring.jar n'est plus proposée  le support de moteurs de bases de données embarquées (Derby, HSQL, H2) 5 Formation : Développement JEE avec Spring  le support de la validation (JSR 303), du data binding et de la conversion de type  le support JSR 330  le scheduling par configuration, annotations (@Async, @Scheduled) ou API  l'ajout de nouveaux namespaces (task, jdbc, mvc)  la compatibilité forte avec Spring 2.5  le support de l'API Porlet 2.0 par Spring MVC Spring 3.1 :  support des conversations  support des caches  ajout de la notion de profile qui permet d'avoir des configurations du context différentes pour chaque environnement  ajout de nouvelles annotations pour définir certaines fonctionnalités de namespaces dans la configuration  support des servlets 3 1.2 Spring et J2EE Spring est né de l'idée de fournir une solution plus simple et plus légère que celle proposée par Java 2 EE. C'est pour cette raison que Spring a été initialement désigné comme un conteneur léger (lightweight container). L'idée principale de Spring est de proposer un framework qui utilise de simples POJO pour développer des applications plutôt que d'utiliser des EJB complexes dans un conteneur. Spring ne respecte pas les spécifications de Java EE mais il intègre et utilise de nombreuses API de Java EE (Servlet, JMS, ...). Spring propose aussi une intégration avec certains composants de Java EE notamment les EJB. Java EE utilise une approche convention over configuration : par exemple, les EJB sont par défaut transactionnels. Spring utilise une approche ou la configuration doit être explicite. Spring est de plus en plus controversé notamment à cause de son empattement et à sa complexité croissante. De plus, face à la simplification engagée par Java EE à partir de sa version 5 et à l'ajout de l'injection de dépendances dans Java EE 6, le choix entre Java EE et Spring n'est plus aussi facile. 6 Formation : Développement JEE avec Spring 1.3 Les modules Spring Spring regroupe un ensemble de modules : a) Core du conteneur Spring Il s’agit du module noyau de Spring, qui prend en charge la creation, configuration et gestion des beans à l’intérieur du conteneur. Le point d’entrée principal est une factory de beans Spring, qui est la partie qui traite l’injection de dépendances. En se basant sur cette factory de beans ( Voir Design Pattern – Factory ), plusieurs implementations de contextes d’application sont offertes (chacune offre un moyen de configurer Spring). En plus de l’application contexte, et du la factory de beans, ce module fournit également plusieurs services tels que l’accès JNDI, l’intégration d’EJB, le scheduling et l’accès à l’API email. b) Intégration et accès aux données Le module JDBC et DAO (accès aux données objets) de Spring simplifie le développement d’applications de type bases de données. Ceci, par exemple, en fournissant des messages d’erreurs plus simples à interpréter que les codes erreurs provenant du moteur de base de données. Il est également prévu l’intégration des principaux ORM (object-relational mapping (ORM) / frameworks de mapping objets/relationel) du monde Java, tels que Hibernate, Java Persistence API, Java Data Objects, et iBATIS SQL Maps (avec support de la gestion des transactions) c) Module AOP de Spring L’AOP (Aspect Orienting Programming) est implémenté dans Spring à travers un module spécialisé. L’AOP est un moyen de réduire le couplage entre les objets d’une application. Par exemple, les besoins de sécurité et les aspects transactionnels sont traités par l’AOP, indépendamment des objets sur lesquels ils interviennent. d) WEB et REMOTING Le paradigme Model-View-Controller (MVC) est l’approche la plus communément utilisée pour uploads/Finance/ vlinder-spring-221020.pdf