Formation Spring

Formation Spring

www.objis.com - Formation SPRING 1

www.objis.com - Formation SPRING

A propos d’Objis…

Centre de formation depuis 2005

Spécialiste technologies Java/J2ee

Formations intra/inter entreprises

70% de pratique

Paris – Lyon – Dakar

www.objis.com



Atouts Objis

Audit technique de vos besoins

70% de travaux pratiques

Clé USB avec outils et corrigés TP

Bilan pédagogique individuel

Ingénierie de financement

Veille technologique

3www.objis.com - Formation SPRING


Veille technologique


(cliquez sur les images)


SOMMAIRE (5j)

• Historique, définition et architecture • Concept clé N°1 : injection de dépendances • Concept clé N°2 : Programmation Orientée Aspect • Accès aux données JDBC • Intégration Spring / Hibernate • Gestion des transactions • Intégration Spring / Struts • Développement web avec Spring MVC • Gestion de la sécurité • Intégration Spring / JMS • Stratégies de test avec Spring• Conclusion – ressources – Rappels J2EE



Etape 1 : Introduction Spring

Historique

Définition

Architecture



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

7


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



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



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

10


SPRING : architecture modulaire

Jusqu'où votre appli. sera orientée SPRING ?



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.



13

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



SPRING : architecture modulaire

Exemple modules pour appli Struts/Hibernate



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



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



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



Exemple de couplage fort



Problèmes couplage fort

Pas de 'Saxophone' sans 'Musicien'

Difficile de tester la Classe Musicien

Difficile de réutiliser la Classe Musicien


solutions1) Masquer l'implémentation avec Interfaces !2) Injection de code à l'exécution.


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.



Exemple de couplage faible


Ici les classes sont indépendantes.

Couplage faible


Déclaration Musicien et Saxophone


Fichier de configuration de Spring : applicationContext.xml

REFERENCE : http://static.springframework.org/spring/docs/2.5.x/reference/beans.html


Lancement de l'Application


joue Vive le vent... : TOOT TOOT TOOTjoue Vive le vent... : TOOT TOOT TOOT

1)Chargement conteneur

3) Utilisation bean

2)Récupération bean


Modification paramétrage...


Le musicien change d'instrument...


Lancement de l'Application


joue Vive le vent... : PLINK PLINK PLINKjoue Vive le vent... : PLINK PLINK PLINK


3) Utilisation bean



Etape 3 : POA

Limites de la programmation Objet (POO)

Atouts de la programation Aspect (POA)

Exemple de mise en oeuvre POA Spring

Intégration avec @AspectJ



Constats et limites de la POO

Phénomène de dispersion : dans le code d'une classe métier, on retrouve souvent du code 'technique' : log, sécurité, transaction...

Ce code technique correspondant à des 'préocupations transversalles' des différentes couches de l'application.

Maintenance du code et Réutilisabilité des composants diminués.



Exemple : appli. gestion d'école



Valeur ajoutée POA

La programmation Orientée Aspect (POA) permet de séparer le code métier et le code technique correspondant aux préocupations transversales.

Un aspect = une préocupation transversale.

Le tisseur d'aspect de Spring (Spring AOP) intercepte les méthodes métier et applique les aspects associés à cette méthode.

D'autres tisseurs d'aspects (AspectJ, JbossAOP) interceptent le changement d'état d'une variable , ainsi qu'un constructeur



Programmation Orientée Aspect



Exemple : appli. gestion d'école



Exemple d'aspect : Spectateurs

Nous souhaitons que les spectateurs prennent place systématiquement avant qu'un musicien joue.

Nous souhaitons que les spectateurs applaudissent systématiquement après que le musicien joue.

Nous pourrons également demander d'étteindre les Tél portables avant la prestation, ou encore de demander remboursement si prestation de mauvaise qualité...



Exemple d'aspect : Spectateur



Mise en oeuvre aspect



Pas d'impact sur code Applicatif !


joue Vive le vent... : Les spectateurs prennent placeTOOT TOOT TOOTLes spectateurs applaudissement :BRAVO !

joue Vive le vent... : Les spectateurs prennent placeTOOT TOOT TOOTLes spectateurs applaudissement :BRAVO !


3) Utilisation bean



Vocabulaire POA

Aspect = service = préocupation transversale

Point de jonction (JoinPoint),

Coupe (Pointcut)

Greffon (Advice)

Cible (Target) = objet sur lequel appliquer aspect

Tissage = Application d'un aspect à une cible



Greffon (advice)

Greffon = un programme qui sera activé à un certain point d'exécution du système, précisé par un point de jonction.

Exemple : méthode 'applaudit' de l'aspect Spectateurs



Types de greffon (advice)

Before : exécution avant le point de jonction

After : exécution après le point de jonction

After-returning : éxécution après...si succès

After-throwing : éxécution après...si échec

Around : éxécution autour du point de jonction



Point de jonction (Joinpoint)

Point de jonction = Endroit spécifique dans le flot d'exécution du système, où il est valide d'insérer un greffon.

Il n'est pas possible d'insérer un greffon au milieu du code d'une fonction.

Par contre on pourra le faire avant, autour de, à la place ou après l'appel de la fonction.•Exemple : Le public applaudit APRES que chaque instrument soit joué



Coupe (PointCut)

Coupe = ensemble de points de jonction

Exprimé avec notation AspectJ.

Attribut 'expression' de la balise <aop:pointcut>

La coupe spécifie qu'un greffon d'oit être appliqué à toute méthode 'jouer', quelque soit son package (*), quelque soit le nombre d'arguments (..), quelque soit le type de retour..


<aop:pointcut id="servicePointcut"

expression="execution(* *.jouer(..))">

Quelque soit classe/packageQuelque soit classe/package

Quelque soit le type de retour de la méthodeQuelque soit le type de retour de la méthode

Quelque soit paramètresQuelque soit paramètres


Tissage et cycle de vie applicatif

Tissage = Application d'un aspect à une cible

3 types de tissages

Tissage à la compilation (AspectJ). Nécessite compilateur spécial.

Tissage au chargement de l'application (AspectJ). Nécessite un ClassLoader spécial.

Tissage à l'exécution (Typique Spring POA). Ici le conteneur génère dynamiquement Proxy qui intercepte les appels et met en oeuvre l'aspect.



Lien utiles Tisseurs d'aspects

AspectJ : http://eclipse.org/aspectj

Jboss AOP : http://labs.jboss.com/portal/jbossaop/index.html

Spring AOP : http://www.springframework.org



Intégration d'aspect via @Aspect



Intégration d'aspect via @Aspect


Les spectateurs prennent placeLes spectateurs éteignent tél. portablesjoue Vive le vent... : TOOT TOOT TOOTLes spectateurs applaudissement : BRAVO !

Les spectateurs prennent placeLes spectateurs éteignent tél. portablesjoue Vive le vent... : TOOT TOOT TOOTLes spectateurs applaudissement : BRAVO !


Aspects AspectJ dans spring

Le runtime AspectJ créé des aspects aspectJ (ex : JugeAspect.aj)

Le conteneur Spring peut manager les aspects aspectJ, même s'il ne les a pas créé ( attribut 'factory-method' de la balise <bean>).

L'aspect aspectJ peut avoir besoin de beans gérés par le conteneur Spring. (ex : JugeAspect fait une critique via un MoteurDeCritique)



Etape 4 : accès aux données

Philosophie d'accès aux données

La gamme d'exceptions

Accès aux datasources

Framework JDBC de Spring



Philosophie d'accès aux données

Utilisation interface DAO.

Le développeur a plusieurs choix d'implémentations de technologies de persistance (JDBC,Hibernate,JPA...)

Seules les méthodes d'accès sont exposées via l'interface. L'application est plus modulaire.

Les services sont facilement testables car non couplés à une implémentation donnée.

On peut créer des implémentations 'factices' facilitant tests unitaires et sans accès réel à la base, donc + rapide et avec moins de risque d'échec du à la base de données.



Gestion Exceptions

Comment gérer exceptions d'accès données ?

SQLException (Jdbc) trop générique ! Exceptions Hibernate nombreuses et plus

détaillées mais propres à Hibernate ! Donne indication sur framework de persistance utilisé...

Réponse de Spring : DataAccessExceptionune gamme d'exceptions détaillées etindépendantes de votre stratégie de persistence.

Spring se charge de lever la bonne exception quelque soit le framework de persistance utilisé.



Exceptions sans / avec SPRING



Stratégie Template / Callback

Spring distingue étapes obligatoires d'accès aux données (Template, Ex : connection DB) et étapes facultatives (Callback, Ex : contexte transactionnel)

Template = Bean , Callback = Bean

Inconvénient : vous devez créer le Callback.



Templates disponibles

51


Injection jdbcTemplate dans DAO



Stratégie DAO Support

Chaque template fournit méthodes permettant l'acces aux données sans avoir à créer explicitement un Callback

DAO Support = surcouche de Template

Vous pouvez créer votre DAO comme héritant de DAO Support



Stratégie DAO Support

Exemple : si votre DAO hérite de JdbcDaoSupport, vous pourrez obtenir un template JdbcTemplate à travers la méthode : getJdbcTemplate();

Vous pourrez également accéder directement aux objets de votre framework de persistence.

Exemple : JdbcDaoSupport fournit la méthode getConnection() pour récupérer l'objet Connection de Jdbc.



Exemple DAO Support



58

Configuration DataSource

3 options :– Source de données définies par driver JDBC– Source de données identifiée par nom JNDI– Source de données avec pool de connexion

Conseil : utiliser accès à DataSource JNDI avec pooling de connexion

– JNDI : infos de connection à DB externes à l'appli– Pool de connexion : meilleures performances

JndiObjectFactoryBean : retrouver un objet d'un annuaire JNDI et le transformer en bean Spring



59

JNDI DataSource

• Attribut 'resourceref' utile uniquement en environnement J2EE • Si value='true' , alors le nom JNDI sera préfixé de java:comp/envEx : ici, le nom JNDI est java:comp/env/jdbc/RantzDataSource

• Attribut 'resourceref' utile uniquement en environnement J2EE • Si value='true' , alors le nom JNDI sera préfixé de java:comp/envEx : ici, le nom JNDI est java:comp/env/jdbc/RantzDataSource

Nom JNDIde la base de données

Nom JNDIde la base de données Fabrique de bean


60

Namespace jee avec spring 2.0

- Elément <jee:jndi-lookup> permet aussi de retrouver objet via annuaire JNDI

- Déclaration suivante strictement identique à déclaration page précédente

60


Pool de connexion

Spring ne fournit pas de pool de connexion

Conseil : utiliser Apache DBCP http://jakarta.apache.org/commons/dbcp DBCP fournit plusieurs DataSources, le

plus simple à configurer étant BasicDataSource



DataSources avec Driver JDBC

org.springframework.jdbc.datasource.DriverManagerDataSource : retourne nouvelle connection à chaque appel

org.springframework.jdbc.datasource.SingleConnectionDataSource retourne même connection à chaque appel.

Leurs configuration est identique qu'avecDataSource DBCP sauf qu'il n'y a pas de paramètres de config lié au pool

Ces dataSources sont à éviter en production ! Préférer dataSource avec pool de connexion (Ex :BasicDataSource DBCP)



Bonne pratique configuration DataSource



Etape 5 : Intégration Spring / Hibernate

Atouts d'hibernate et de Spring

HibernateDaoTemplate

HibernateDaoSupport

Code non intrusif



Intégration Spring / Hibernate

Solution 1 : Créez votre DAO en injectant un template HibernateTemplate fourni par Spring.

Solution 2 : Créez votre DAO comme héritant de HibernateDaoSupport , superClasse fournie par Spring

Solution 3 : Créez un DAO non intrusif par injection d'une SessionFactory



DAO par injection HibernateTemplate



DAO par héritage de HibernateDaoSupport



DA0 'non intrusif'



Déclaration du DAO



Annotation @Repository (pour DAO)

Permet de se dispenser de configuration DAO dans XML

Avantage : translation d'exceptions

Necessite configuration complémentaire

•Autowiring byName•<component-scan base-package='com.jdbc.dao'>

Hérite de @Component

Equivalence JSR 250 : @Resource



A étudier : PetClinic

Fournie avec SPRING 2.5, Petclinic est une version de l'application petstore avec Spring, et plusieurs solutions de mapping O/R.

Bonnes pratiques integration Spring Jdbc, Hibernate, JPA



Etape 6 : Transactions

Concept de transaction

Gestionaires de transaction SPRING

Les 5 propriétés d'une transaction

Transaction programmative

Transaction déclarative



Concept de transaction

Ensemble d'opération qui réussissent tous (commit)ou échouent toutes (Rollback)

Exemple : retrait d'argent dans distributeur. •1) les billets sortent•2) compte débité

Propriétés ACID (Atomique, Cohérente, Isolée, Durable)

Transactions importantes dans applications entreprises !

Transaction avec 1 base / Transactions distribuées



Gestionnaires de Transactions

Avec Spring,comme avec serveur d'application J2EE (Conteneur EJB), il est possible de gérer les transactions de façon programmative ou déclarative

Spring propose différents gestionnaires de transactions (TransactionManagers) adaptés à différentes cibles



Configuration TransactionManager

JDBC - <bean id="transactionManager“

class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource"><ref local="dataSource"/></property>

</bean>

JTA - <bean id="transactionManager“

class="org.springframework.transaction.jta.JtaTransactionManager"/>

Hibernate -<bean id="transactionManager"class="org.springframework.orm.hibernate.HibernateTransactionManager">

<property name="sessionFactory"><ref local="sessionFactory"/></property></bean>

Lien : http://static.springframework.org/spring/docs/2.5.x/reference/transaction.html



Les 5 propriétés d'une transaction


Optimisation si requête lecture en base de données

Bonne pratique : read-only = truepour méthodeq 'get'

Optimisation si requête lecture en base de données

Bonne pratique : read-only = truepour méthodeq 'get'

Quelles Exceptions (Métier/Runtime) lancent un Rollback ?

Quelles Exceptions (Métier/Runtime) lancent un Rollback ?


Propagation de transaction

PROPAGATION_SUPPORTS : la méthoe courante n'a pas besoin d'êre exécutée dans une transaction, mais s'il y en a une, elle peut y participer.

PROPAGATION_REQUIRED : la méthode courante doit obligatoirement être exécuté dans une transaction. Elle peut participer à une transaction déja existante.

PROPAGATION_REQUIRES_NEW : création explicite d'une nouvelle transaction.

PROPAGATION_NEVER : la méthode courante ne doit pas être exécutée dans une transaction.

PROPAGATION_NESTED : nouveauté Spring. Utile en cas de pb sur transaction avec Nombreuses données dont qqs une avec pb.



Niveaux d'Isolation

ISOLATION_DEFAULT : utilise le niveau d'isolation de la base de données de l'application.

ISOLATION_READ_UNCOMMITED : autorise lecture sale (dirty read)

ISOLATION_READ_COMMITED : n'autorise pas lecture sale.

ISOLATION_REPEATABLE_READ : n'autorise ni lecture sale, ni lecture répétable

ISOLATION_SERIALIZABLE : n'autorise ni lecture sale, ni lecture répétable, ni lecture fantome

•Niveau le plus fort, mais pb de PERFORMANCE !•Oracle, postgres.



Valeurs par défaut

Propagation : PROPAGATION_REQUIRED

Isolation : ISOLATION_DEFAULT

Read-only : false

Timeout : none




Hibernate fournit objet TransactionTemplate

Quelle implémentation de PlatformTransactionManager ?

Objet TransactionDefinition

Objet TransactionStatus



Transaction déclarative

Mise en oeuvre proxy (POA)

Choix Métadonnées : XML

Choix Métadonnées : @Transactional



Intercepteur : proxy AOP



Configuration XML : namespace tx



Configuration XML : interception AOP


Déclaration attribut de Transaction(XML)

<bean id="petStore" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="petStoreTarget"/></property><property name="transactionAttributes">

<props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop>

</props></property>


@Transactional



Etape 7 : Intégration Struts / Spring

Valeur ajoutée et limite de Struts

Ce qu'apporte Spring à Struts

Stratégie d'intégration : délégation de Proxy



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 !



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.



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>




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 …




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…



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



Etape 8 : Spring MVC

Cinématique requête HTTP

Dispatcher et Controlleur Spring MVC

Exemples Mapping et ViewResolver

Bonnes pratiques



Architecture & cinématique



Dispatcheur


web.xmlweb.xml


Controleur



Config des couches applicatives


Voir le TP Dédié

web.xmlweb.xml


Exemple handler Mapping :

Ici les URLs home.htm et login.htm sont gérés par SpringM VC


objisapp-servlet.xmlobjisapp-servlet.xml


Exemple viewResolver (Vue à afficher)

Ci-dessous, toutes les vues sont des JSP placées dans \WEB-INF\jsp


objisapp-servlet.xmlobjisapp-servlet.xml


Méthodologie dév Spring MVC

Configurez le web.xml et ajoutez librairies Spring MVC

Créez les fichiers XML de définitions de beans représentant les différentes couches de l'application

Définissez vos beans dans les fichiers dans l'ordre•la couche DAO •la couche Service•la couche Controleur.



Etape 9 : Sécurité

Introduction : les étapes

Authentification

Autorisations



Introduction

Avec Spring,comme avec serveur d'application J2EE (Conteneur EJB), il est possible de gérer la sécurité de façon programmative ou déclarative

Intercepteurs : Proxy POA si on sécurise des méthodes ou bien filtres de servlets si on sécurise des ressources web (JSP,IMG...)

Authentification & Autorisations (Fichier, DB, LDAP...)



4 étapes (dont 2 facultatives)

Authentification : Qui êtes vous ?

Autorisation : êtes vous autorisé ?

Lancer en tant que (facultatif)

Après invocation (facultatif) : avez-vous le droit de profiter des infos renvoyées par resource sécurisée ?



Authentification


Login/password dans une base de données

Login/password dans une base de données


Spring Security

Module Sécurité de Spring anciennement nommé 'Acegi Security'

http://static.springframework.org/spring-security/site/index.html



Librairies Spring security


Fichiers supplémentaires

dédiés à la sécurité Spring

Fichiers supplémentaires

dédiés à la sécurité Spring


Configuration web.xml : Filtre de sécurité


web.xmlweb.xml


Configuration web.xml : ContextListener


web.xmlweb.xml


Stratégie de sécurité et utilisateurs


ApplicationContext-security.xmlApplicationContext-security.xml


Stratégie de sécurité et utilisateurs



Service 'Remember Me'

'Se souvenir de moi'

Solution 1 : infos dans Cookie

Solution 2 : infos dans Base de données


Service 'Remember Me'


Authentification base de données



Authentification 'prêt à l'emploi'



Authentification personalisée



Mots de passe sécurisés


Redefinition daoAuthenticationProvider

Stratégie d'encodage (ici Md5)

Clé d'encryption (ICI la clé change en fonction du username)


@Secured



Etape 10 : Spring / JMS

API JMS

Fournisseur ActiveMQ

JmsTemplate de Spring

Envoi/réception de message



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)



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



Queue / Topic



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



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



Config Active MQ dans Spring



Envoi message avec JmsTemplate


InjectionsInjections

Callback MessageCreatorCallback MessageCreator

Queue ou Topic ?


Configuration JmsTemplate



Réception Asynchrone de message



Namespace jms



Etape 11 : Tests

IoC et tests unitaires

Spring et les tests d'intégration

MockObjects

TestContext



Spring et tests unitaires

Avant Spring 2.5 : support junit 3.8

Spring 2.5 : support Junit 4 , TestNG

Avec IoC , tests unitaires facilités

Avec Spring , test integration facilités



Spring 3.0 Java5+

Support Web Services : REST• Ainsi que nouvelles @MVC

Spring Expression Language• Unified EL ++

Validation déclarative types Modèle• Hibernate validator (JSR 303)

Support Portlets 2.0• Action / Evevement / Resource

Support de Java 6• JSF 2.0, JPA 2.0,...



Spring 3.0 : nouvelle structure de projet

Build des podules• Gérés par Maven• 1 module = 1 jar• Plus de spring.jar !!!

Build du projet • Basé sur Ivy• Procédure de déploiement• Gestion des dépendances• Génération des manifests OSGi



IoC et tests unitaires Avec l'injection de dépendences, le code dépend

moins du conteneur qu'avec serveur J2EE

Vos POJO peuvent être testés unitairement via new(), SANS conteneur Spring (contrairement aux EJB2).

Test simplifié couche Service en isolant la couche DAO via Objet DAO factice (sans acces réel à DB)• www.mockobjects.com

Spring apporte quelques objets factices• org.springframework.mock



Objets factice de Spring

JNDI : org.springframework.mock.jndi

Servlets : org.springframework.mock.web

Portlets : org.springframework.mock.web.portlet



Support test unitaires dans Spring ReflectionTestUtils,

• Package org.springframework.test.util• Utile pour test unitaires & d'intégration• Setter un champ non public ou appeler une méthode privée (Hibernate/JPA)

AbstractModelAndViewTests (pour Spring MVC)• Test unitaire d'objet ModelAndView (controlleur)• Classe ModelAndViewAssert



Support test intégration lib/spring-test.jar

Package org.springframework.test

+ lent que test unitaire JUnit

+ rapide que test Cactus

TestContext Framework (java5+)• Tests d'intégration• org.springframework.test.context• AbstractTransactionalJUnit4SpringContextTests



TestContext : Demo PetClinic



Pourquoi utiliser Spring?

Spring est un bon choix dans applications web multicouches. En particulier les beans de chaque couche peuvent être gérés et injectés à l'exécution.

Spring fournit une bone abstraction pour application Hibernate. Duo Spring/Hibernate gagnant.

Avec JDBC spring facilite accès aux données.

Si vous avez une couche 'service' à associer à une vue, Spring crée de la valeur ajoutée.



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)



Architecture multicouche

143


Architecture J2EE



Livraisons J2EE

145


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 Binding146www.objis.com - Formation SPRING


Exemple log4j.xml



Vue 'DashBoard' SpringSource Tool Suite


4

21

3

5


Interroger la base de connaissances SpringSource Tool Suite


4

2

1

3

5


Configurer SpringSource Tool Suite


2

1

3


Modularité dynamique (au déploiement)rendue possible avec OSGi


service-2-0.jar

gui-2-2-2.jar

service-1-1.jar

dao-1-0.jar

LogAspect-1.1.jar

gui-1-1-4.jar

gui-1-0-0.jar


Déploiement de serveurs SpringSourcedans un nuage Amazon EC2


...

Amazon EC2+

S3

sts


Autres Formations Objis

Architectures SOA

Développement de services web

Développement et Conception XML

Développement Struts

Développement Hibernate

Développement .NET

Intégration continue et méthodes agiles

Voir catalogue sur www.objis.com



Contact : Douglas Mbiandou

Ingénieur INSA Lyon (2000)

8 ans d'expériences projets SI

Architecte / Formateur Java

Directeur technique & Resp. pédagogique Objis

[email protected]

Tél : 04 78 29 37 26 / 06 60 46 76 45


Formation Spring

Documents

Transcript of Formation Spring