Plateforme de développement JEE - zlitni.comzlitni.com/courses/jee-p3.pdf · • Module Web MVC de...

Plateforme de développement JEE

Tarek ZLITNI

[email protected]

mailto:[email protected]

Partie 3: La plateforme SPRING

©Tarek ZLITNI ([email protected]) Plateforme de développement JEE 3

Plan• Introduction

• Concepts de bases

• Architecture du framework Spring

• Installation de l’environnement Spring

• Le conteneur IoC

• Définition des beans

• Cycle de vie des beans

• Module Web MVC de Spring



Spring : Introduction

• Spring est un framework créé et supporté par l'entrepriseSpringSource

• Framework Spring est une plate-forme Java open source et il aété initialement écrit par Rod Johnson et a d'abord été publiésous la licence Apache 2.0 en Juin 2003

• Il permet de simplifier le développement d'applications Java etest devenu un standard dans l'industrie du développementlogiciel basé sur la plateforme Java, surtout dans ledéveloppement Java EE.

• Spring est un conteneur léger qui facilite le développementavec des POJO (Plain Old Java Object), c'est-à-dire avec desclasses Java qui n'ont pas besoin de s'exécuter dans unconteneur spécifique ou dans un serveur d'applications.



Spring

• Il se compose d'un noyau (core) et de plusieurs modules quiajoutent des fonctionnalités.

• Les principaux éléments du core de Spring peuvent être utilisésdans le développement de n'importe quelle application Java

• Spring assure des applications performantes, facilementvérifiables, avec un code réutilisable.

• mais il existe des extensions pour construire des applicationsweb à base de la plate-forme JEE.



Avantages de Spring

• Spring permet aux développeurs de développer desapplications de classe entreprise en utilisant des POJO.• L'avantage d'utiliser seulement POJO : pas besoin d'un produit de

conteneur d'EJB comme un serveur d'application, mais on a lapossibilité d'utiliser seulement un conteneur de servlet robustecomme Tomcat par exemple.

• Spring est organisé d’une façon modulaire.• Même si le nombre de packages et les classes sont importantes, il

faut se préoccuper uniquement sur ceux que vous voulez et ignorerle reste

• Spring ne réinvente pas la roue• Réellement, il utilise certaines technologies existantes comme les

Quartz et JDK timers, et d’autres technologies d'affichage



Avantages de Spring

• Le test d’une application développé Spring est simple car il n ya pas une dépendance du code à l’environnement dans ceframework.• En outre, en utilisant des JavaBean de style POJO, il devient plus

facile d'utiliser l'injection de dépendance pour l'injection de donnéesde test.

• le framework web de Spring est un framework MVC Web bienconçu, qui offre une excellente alternative aux frameworks telsque Struts ou autre sur les frameworks web conçus ou moinspopulaires.

• Spring fournit une interface de gestion de transactioncohérente, qui peut réduire à une opération locale (en utilisantune seule base de données, par exemple) et d'intensifier lesopérations mondiales (en utilisant JTA, par exemple).



l’Inversion du Contrôle (IoC)

• IoC est un concept général, et il peut être défini de différentesfaçons.

• L'inversion de contrôle permet de laisser à un conteneur commeSpring la responsabilité de gérer le cycle de vie des objets d'uneapplication plutôt que de le faire manuellement.

• Lors de l'écriture d'une application Java complexe, les classesd'application devraient être aussi indépendante que possible desautres classes Java pour augmenter la possibilité de réutiliser cesclasses et de les tester indépendamment des autres classes tout enfaisant des tests unitaires

• Sans IoC il est nécessaire de faire la création d'objets avec des new cequi augmente les dépendances entre classes concrètes

• avec l'IoC on essaye de ne référencer que des interfaces ou desclasses plus génériques ce qui permet d'avoir un code plus propre,réutilisable et facilement testable.



Injection de dépendance (Dependency Injection (DI) )

• Dependency Injection (DI) est est le cœur du FrameworkSpring

• DI est une concrétisation du concept Inversion de Control (IoC).• Dependency Injection aide à coller ces classes ensemble et en

même temps les garder indépendant.• Qu'est-ce que l'injection de dépendance exactement?

• la dépendance se traduit par une association entre deux classes. Parexemple, la classe A dépend de la classe B.

• l'injection, cela signifie que la classe B va se injectée dans la classe Apar le Ioc.

• L'injection de dépendance peut se produire dans la façon depasser des paramètres au constructeur ou par post-construction en utilisant des méthodes de réglage.



Programmation Orientée Aspects(AOP)

• L‘ AOP ou Programmation Orientée Aspects permet deséparer les aspects qui se retrouvent de manière transversedans différentes parties d'une application permettant ainsi deminimiser le code répétitif qui devient complexe et peumaintenable.

• L'AOP ne remplace donc pas la POO mais la complète enproposant des solutions mises en œuvre de façon élégante àcertaines de ses limitations ou des fonctionnalitésmanquantes.

• AOP permet de facilement implémenter des fonctionnalitéstransverses de façon modulaire.



Programmation Orientée Aspects(AOP)

• L'AOP s'utilise souvent pour écrire des Logs, mesurer lesperformances ou pour la gestion de transactions.

• la programmation orientée aspect (AOP) est considérée L'undes composants clés du framework spring.

• Le module AOP de Spring fournit une implémentation de laprogrammation orientée aspect

• permet de définir la méthode-intercepteurs et pointcuts dedissocier proprement le code qui implémente des fonctionnalitésqui doivent être séparés.


Architecture du framework Spring



• Le framework Spring est modulaire

• Permet de choisir les modules adéquats à l’application à développer, sans avoir à apporter dans le reste.

• Spring fournit environ 20 modules qui peuvent être utilisés sur la base d'une exigence de l'application.



Architecture du framework SpringCore Container

• Le Core Container est composé des modules du Core, desBeans, du Contexte (Context) et le Langage d’expression(Expression Language )

• Le module Core fournit les parties fondamentales duframework, contenant les éléments duIoC et DependencyInjection.

• Le module Bean fournit BeanFactory ; une implémentationsophistiquée du modèle de conception (factory pattern).

• L’ interface ApplicationContext est le point principal dumodule de Context.

• le langage d’expression (Expression Language) un langagepuissant pour l'interrogation et la manipulation d'un graphed’objet à l'exécution.



Architecture du framework SpringAccès et intégration des données

• La couche d’ accès et intégration des données (Data Access/Integration)layer est composée des modules de : JDBC, ORM, OXM, JMS et deTransaction modules

• Le module JDBC fournit une couche d’abstraction de JDBC qui évite lanécessité de faire JDBC relié au code.

• Le module ORM fournit des couches integration des APIs de mappingobjet-relationnel (JPA, JDO, Hibernate, iBatis).

• Le module OXM une couche d’abstraction qui supporte desimplementations du mapping Objet/XML (JAXB, Castor, XMLBeans,JiBX , Xstream).

• Le module du service de messagerie (Java Messaging Service JMS)inclut des fonctionnalités de production et de consommation desmessages.

• Le module de transaction prend en charge la gestion programmatiqueet déclarative transaction pour les classes qui implémentent desinterfaces spéciales et pour tous les POJOs.



Architecture du framework SpringWeb

• La couche Web est composée des modules : Web, Web-Servlet, Web-Struts et Web-Portlet

• Le module Web fournit une intégration des fonctionnalités basiques du web comme la fonctionnalité d’ upload de fichier et l’initialisation du conteneur IoC en utilisant les listeners servlet et le contexte d’applications web.

• Le module Web-Servlet englobe une implémentation du patron MVC pour les applications web.



Architecture du framework SpringWeb

• La couche Web est composée des modules : Web, Web-Servlet,Web-Struts et Web-Portlet

• Le module Web fournit une intégration des fonctionnalitésbasiques du web comme la fonctionnalité d’ upload de fichier etl’initialisation du conteneur IoC en utilisant les listeners servlet etle contexte d’applications web.

• Le module Web-Servlet englobe une implémentation du patronMVC pour les applications web.

• Le module Web-Struts contient un support des classes pourl’integration le tiers web classique de Struts web dans uneapplication Spring.

• Le module Web-Portlet fournit une implémentation MVC afin del’utiliser dans environnement portlet et reflète la fonctionnalitédu module Web-Servlet.



Architecture du framework SpringMiscellaneous

• Il existe d’autres modules importants comme les modules deAOP, Aspects, Instrumentation, Web et le Test

• Le module AOP fournit une implémentation de laprogrammation orientée aspect

• Le module Aspects offre une intégration avec AspectJ ; unframework puissant programmation orientée aspect .

• Le module Instrumentation offre des implémentations desclasses instrumentation et de chargement utilisées par certainsserveurs d’ applications.

• Le module Test supporte the test des composants Spring avec lesframeworks JUnit ou TestNG.


Installation de l’environnement Spring



• Etape 1 : Installer le Java Development Kit (JDK)

• Etape2 : Installer l’API Apache Common Logging

• La derrière version de Apache Commons Logging est téléchargeable àpartir de http://commons.apache.org/logging/. Une fois l’installation esttéléchargée, décompresser la dans l’emplacement désiré ( C:\commons-logging-1.1.1 par exemple pour en cas d’une machine windows)

• Ce dossier comporte, entre autres, les fichiers jar files suivants

Ajouter l’adresse de cet emplacement à lavariable d’environnement CLASSPATH


http://commons.apache.org/logging/.Unefoisl



• Etape 3 : Installer le IDE Eclipse (une version JEE)• Etape 4 : Installer les bibliothèques du Framework Spring• Télécharger la dernière version du framework Spring à partir de

http://www.springsource.org/download.• Choisir le fichier .zip pour les machines Windows, ou bien le fichier

.tz pour les machines Unix.• Décompresser le fichier téléchargé,

qui donnera le dossier suivant :• Toutes les bibliothèques de Spring se

trouvent dans le répertoire dist.

• Ajouter l’adresse de cet emplacement à lavariable d’environnement CLASSPATH, sivous utiliser un IDE autre que Eclispe (AvecEclipse, il n'est pas nécessaire de définirCLASSPATH)


http://www.springsource.org/download

Le premier Exemple avec Spring


Le premier exemple avec Spring

• Etape 1 : Créer un nouveau projet sous Eclipse (HelloSpring)

• Etape 2 : Ajouter les bibliothèques (.jar) de Spring

• Ajouter les API de Spring et common logging libraries dans le projet.

• Pour se faire, click droitsur le nom du pojetHelloSpring et puischoisir l’option suivantedans le menu de context :Build Path>ConfigureBuild Path pour afficherla fenetre de Java Path :

• Utiliser le bouton AddExternal JARs pourajouter les jars désirés




• Etape 2 : Ajouter les bibliothèques (.jar) de Spring• Sélectionner les jars suivants :

• antlr-runtime-3.0.1

• org.springframework.aop-3.1.0.M2

• org.springframework.asm-3.1.0.M2

• org.springframework.aspects-3.1.0.M2

• org.springframework.beans-3.1.0.M2

• org.springframework.context.support-3.1.0.M2

• org.springframework.context-3.1.0.M2

• org.springframework.core-3.1.0.M2

• org.springframework.expression-3.1.0.M2

• commons-logging-1.1.1

•




• Etape 3 : Création des fichiers sources

• Pour créer les fichiers sources du projet HelloSpring, créons d’abordun package nommé example.spring.

• Pour se faire, click droit sur src dans l’explorateur de packages et choisirl’ option : New -> Package.

• Créer les fichiers HelloWorld.java et MainApp.java files sous lepackage example.spring.




• Etape 3 : Création des fichiers sources : HelloWorld.java

package example.spring; public class HelloWorld { private String message; public void setMessage(String message){this.message = message; }public void getMessage(){ System.out.println("Your Message : " + message);} }




• Etape 3 : Création des fichiers sources : MainApp.java

package example.spring; import org.springframework.context.ApplicationContext; importorg.springframework.context.support.ClassPathXmlApplicationContext; public class MainApp { public static void main(String[] args) { ApplicationContext context = newClassPathXmlApplicationContext("Beans.xml"); HelloWorld obj = (HelloWorld) context.getBean("helloWorld"); obj.getMessage(); } }




• Etape 3 : Création des fichiers sources : MainApp.java• Deux points importants à retenir dans la class Main:

1. La première étape est de créer le context de l’applicationAPIClassPathXmlApplicationContext().• Cette API charge le fichier de configuration des beans et, pour la

creation et l’initialisation de tous les objets (les beans déclarés dans lefichier dans le fichier de configuration.

2. La deuxième étape est chargée e récupéré le bean desireen utilisant la méthode getBean() du context créé.• Cette méthode utilise ID du bean pour retourner un objet générique.

• Une fois l’objet est récupéré, on peut utiliser cet objet et on peutinvoquer ses méthodes.




• Etape 4 : Création de fichier de configuration de Bean Beans.xml• Il faut créer un fichier XML de configuration des Bean . Ce fichier doit être

créé dans le répertoire src comme indiqué ci-dessous:

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="helloWorld" class= “example.spring.HelloWorld"><property name="message" value="Hello World!"/> </bean> </beans>


http://www.springframework.org/schema/beans

http://www.w3.org/2001/XMLSchema-instance

http://www.springframework.org/schema/

http://www.springframework.org/schema/beans/spring-beans



• Etape 5 : Exécuter le programme

• Une fois on a terminé avec la création de fichiers sources et deconfiguration des beans, Il ne reste que la compilation et l'exécutiondu programme.

• Pour ce faire, Gardez onglet fichier MainApp.Java actif et utiliserl'option Exécuter disponible dans l'IDE Eclipse ou utiliser Ctrl + F11pour compiler et exécuter l’application MainApp., On affichera lemessage suivant dans la console Eclipse IDE:

Your Message : Hello World!


Les conteneurs IoC de Spring (IoC containers)


Les conteneurs IoC de Spring

• Le conteneur IoC (container) de Spring est le module principal de cetteframework.

• Le conteneur va créer les objets, les associer ensemble, les configureret gérer leur cycle de vie complet de la création jusqu'à la destruction.

• Le conteneur utilise l'injection de dépendance (DI) pour gérer leséléments qui composent une application. Ces objets sont appelésSpring beans.

• Le conteneur reçoit les instructions sur ce que les objets à instancier,configurer, assembler et par la lecture des métadonnées deconfiguration.

• Les métadonnées de configuration peut être représenté soit par XML,les annotations Java, ou un code Java.




• Le conteneur IoC de Spring utilise des classes Java POJO et lesmétadonnées de configuration pour produire une applicationentièrement configuré et exécutable.

• Vue globale du schéma de fonctionnement de Spring.




• Spring fournit deux types différents de conteneurs :

• Spring BeanFactory Container

• Spring ApplicationContext Container




• Spring BeanFactory Container

• Un conteneur simple fournit les fonctionnalités basic de DI et défini parl’interface org.springframework.beans.factory.BeanFactory. BeanFactoryet les interfaces en relations avec, comme BeanFactoryAware,InitializingBean, DisposableBean, sont encore présents dans Spring pour lesfins de compatibilité ascendante avec des palteformes 3-tiers qui s'intègrentà Spring.

• Il y a un certain nombre d'implémentations de l'interface BeanFactory dansSpring. L’implémentation couramment utilisée est la classeXmlBeanFactory.

• Il lit les métadonnées de configuration à partir d'un fichier XML et l'utilisepour créer une application.

• Il est conseillé lorsque les ressources sont limitées comme les appareilsmobiles ou des applications de base de l'applet.




• Spring BeanFactory Container : Exemple

package example.Spring; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.core.io.ClassPathResource; public class MainApp { public static void main(String[] args) { XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("Beans.xml")); HelloWorld obj = (HelloWorld) factory.getBean("helloWorld"); obj.getMessage(); } }



Les conteneurs IoC de Spring• Spring ApplicationContext Container

• Ce conteneur ajoute plus de fonctionnalités spécifiques comme la capacité derésoudre des messages textuels à partir d'un fichier proprieties et lapossibilité de publier des événements aux écouteurs. Il est défini parl’interface org.springframework.context.ApplicationContext.

• Il englobe toutes les fonctionnalités de BeanFactory, il est généralement Les implementations les plus utilisées de ApplicationContext :

• FileSystemXmlApplicationContext: Ce conteneur charge les définitions des beans à partir d’un fichier XML. Il faut donner l’adresse abosolue du fichier XML au constructeur.

• ClassPathXmlApplicationContext : Il charge la configuration à partir d’un fichierXML. Il n’est pas nécessaire de donner l’adresse , mais il faut modifier CLASSPATH car ce conteneur cherchera ce fichier dans CLASSPATH.

• WebXmlApplicationContext: Il charge le fichier XML des définitions de tous les beans à partir d’une application web.




• Spring ApplicationContext Container : Exemplepackage example.Spring; import org.springframework.context.ApplicationContext; import org.springframework.context.support.FileSystemXmlApplicationContext; public class MainApp { public static void main(String[] args) { ApplicationContext context = new FileSystemXmlApplicationContext("C:/Users/Tarek/workspace/HelloSpring/src/Beans.xml"); HelloWorld obj = (HelloWorld) context.getBean("helloWorld"); obj.getMessage(); } }


Définition des Beans


Définition des beans

• Les objets qui forment une application et qui sont gérés par le conteneur IoC de Spring sont appelés les beans.

• Un bean est un objet qui est instancié et genre par le conteneur IoC de Spring

• Ces beans sont créés par des métadonnées de configuration fournis au conteneur, par exemple, dans les définitions du tag XML <bean/>

• La définition du bean définition contient des informations nommées metadonnées de configuration requises par le conteneur pour savoir les points suivants :

• Comment créer un bean

• Les details de cycle de vie d’un bean

• Les dépendances d’un bean



Définition des beans• Les métadonnées de configuration sont représentées par l’ensemble des

propriétés suivantes:

Propriété Description

class Cet attribut est obligatoire et spécifier la classe utilisée pour créer le bean.

name spécifie l'identificateur unique de bean. Dans configuration à base XML de, les attributs Id et /ou name pour spécifier l'identifiant (s) de bean.

scope spécifie la portée des objets créés à partir d'une définition particulière de bean

constructor-arg utilisé pour injecter les dépendances entre les beans (argumentde constrcuteur)

properties utilisé pour injecter les dépendances (les propriétés d’un bean)



Définition des beans• Les métadonnées de configuration sont représentées par l’ensemble des

propriétés suivantes:

Propriété Description

autowiring mode utilisé pour injecter les dépendances

lazy-initializationmode

Un bean déclaré lazy-initialized appelle le conteneur IoCpour créer une instance du bean lorsqu’il est demandé la première fois ou au démarrage.

initializationmethod

Appelée juste après que toutes les propriétés nécessaires au bean sont initialisées par le conteneur.

destruction method

Appelée lorsque le conteneur englobant le bean est détruit.



Définition des beans

• Les métadonnées de configuration de Spring

• Le conteneur IoC de Spring est totalement indépendant du format danslaquelle ces métadonnées de configuration sont écrites.

• Trois méthodes importantes pour créer les métadonnées deconfiguration:

1. Configuration à base d’un fichier XML.

2. Configuration à base d’annotation.

3. Configuration à base d’un code Java.


Cycle de vie des beans



• Quand un bean est instancié, il peut être nécessaire d'effectuer uneinitialisation de l'obtenir dans un état utilisable. De même, lorsque il n'estplus utilisé et est retiré du conteneur, un nettoyage peut être nécessaire.

• Il existe une liste d’activités qui peut être placée entre l’instanciation et ladestruction d’un bean, nous se limitons à ce niveau uniquement à deuxméthodes importantes dans le cycle de vie d’un bean, qui sont requises aumoment d’initialisation et de destruction.

• Pour la configuration et la destruction d’un bean, on déclare simplementle tag <bean> avec les paramètres init-method et/ou destroy-method.

• L’attribut init-method spécifie une méthode qui peut être invoquée immédiatementlors de l’instanciation du bean.

• De même , destroy-method spécifie une méthode qui peut être invoquée juste avantque le bean est supprimé du conteneur.




• Initialisation• Implémentation de l’interface InitializingBean

• Ou bien , avec une configuration à base d’XML

public class ExampleBean implements InitializingBean { public void afterPropertiesSet() { // un code d’initialisation} }

<bean id="exampleBean" class="examples.ExampleBean" init-method="init"/> public class ExampleBean { public void init() { // un code d’initialisation

}}




• Destruction• Implémentation de l’interface DisposableBean

• Ou bien , avec une configuration à base d’XML

public class ExampleBean implements DisposableBean { public void destroy(){ // un code de destruction} }

<bean id="exampleBean" class="examples.ExampleBean" destroy-method="destroy"/>

public class ExampleBean { public void destroy() { // un code de destruction

}}



Cycle de vie des beans• Méthodes d’initialisation et de de destruction par défaut

• Si on a plusieurs beans ayant des méthodes d’ initialisation et de destructionou avec le même nom, on n’a pas besoin de déclarer init-method et destroy-method pour chaque bean. Spring offre la possibilité de configurer cettesituation en utilisant les attributs par défaut : default-init-method and default-destroy-method dans le tag <beans>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" default-init-method="init" default-destroy-method="destroy"> <bean id="..." class="..."> <!– configuration de bean--> </bean> </beans>




http://www.springframework.org/schema/bean

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

Héritage de définition des beans


Héritage de définition des beans • La définition d’un bean peut contenir plusieurs informations de

configuration (arguments de constructeur, valeurs des propriétés,informations spécifiques au conteneur comme la méthode d’initialisation,etc.

• La définition d’un bean fils hérite les données de configuration de ladéfinition du parent. La définition du fils peut réécrire quelques valeurs ouajouter d’autres , selon le besoin.

• L’héritage des définitions n’a aucune relation avec l’héritage des classesmais le concept est le même.

• On peut définir la configuration du bean parent comme un modèle et les beans filshéritent la configuration nécessaire du parent.

• Avec une configuration basée XML, on peut spécifier la définition du beanfils moyennant l’attribut parent, qui spécifie le bean parent comme valeurde cet attribut.



Héritage de définition des beans <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean id="helloWorld" class=“example.spring.HelloWorld"> <property name="message1" value="Hello World!"/> <property name="message2" value="Hello Second World!"/> </bean> <bean id="helloIndia" class="example.spring.HelloIndia" parent="helloWorld"> <property name="message1" value="Hello India!"/> <property name="message3" value="Namaste India!"/> </bean> </beans>

• Exemple :Beans.xml




http://www.springframework.org/sche

http://www.springframework.org/schema/beans/spring


Héritage de définition des beans • Exemple : HelloWorld.javaPackage example.spring;public class HelloWorld { private String message1; private String message2; public void setMessage1(String message){ this.message1 = message; } public void setMessage2(String message){ this.message2 = message; } public void getMessage1(){ System.out.println("World Message1 : " + message1); } public void getMessage2(){ System.out.println("World Message2 : " + message2); } }



Héritage de définition des beans • Exemple : HelloIndia.java

Package example.spring;public class HelloIndia {private String message1; private String message2; private String message3;public void setMessage1(String m){this.message1 = m; } public void setMessage2(String m){this.message2 = m; } public void setMessage3(String m){ this.message3=m; } public void getMessage1(){ System.out.println("India Message1 : " + message1); } public void getMessage2(){ System.out.println("India Message2 : " + message2); } public void getMessage3(){ System.out.println("India Message3 : " + message3); }}



Héritage de définition des beans • Exemple : MainApp.java

Package example.spring;import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MainApp { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml"); HelloWorld objA = (HelloWorld) context.getBean("helloWorld"); objA.getMessage1(); objA.getMessage2(); HelloIndia objB = (HelloIndia) context.getBean("helloIndia"); objB.getMessage1(); objB.getMessage2(); objB.getMessage3();}}



Héritage de définition des beans • Exemple : Résultat

World Message1 : Hello World! World Message2 : Hello Second World!India Message1 : Hello India! India Message2 : Hello Second World! India Message3 : Namaste India!



Héritage de définition des beans • Modèle (Template) de Définition Bean

• On peut créer un modèle de définition Bean qui peut être utilisé par d'autres définitionsde beans des enfants sans mettre beaucoup d'efforts. Lors de la définition d'un modèlede Bean, on spécifie attribut abstract avec une valeur de true:

<?xml version="1.0" encoding="UTF-8"?> <beans …<bean id="beanTeamplate" abstract="true"> <property name="message1" value="Hello World!"/> <property name="message2" value="Hello Second World!"/> <property name="message3" value="Namaste India!"/> </bean> <bean id="helloIndia" class= "example.spring.HelloIndia" parent="beanTeamplate"> <property name="message1" value="Hello India!"/> <property name="message3" value="Namaste India!"/> </bean> </beans>

• Le bean parent ne peut pas être instancié car il est marqué abstract. Un beansabstract est utilisé comme un parent qui nécessite par la suite la définition desenfants


Injection de dépendance


Héritage de définition des beans

• Chaque application java a un ensemble d’objets qui communiquentensemble pour présenter le résultat final à l’utilisateur.

• Lors de développement d'une application Java complexe, les classesd'application devraient être indépendantes le maximum possible desautres classes pour augmenter la possibilité de réutiliser ces classes etde les tester indépendamment.

• L’injection de dépendance (wiring) permet d’attacher ces classesensemble et en même temps en les maintenir indépendantes.



Héritage de définition des beans • Deux types de dépendance :

1. Injection de dépendance (DI) basée constructeur

• accomplie lorsque le conteneur invoque un constructeur de classe avecun certain nombre d'arguments, chacun représentant une dépendancesur les autres classes.

2. Injection de dépendance basée Setters (accesseurs en écritures)

• Accompli par le conteneur en appelant les méthodes setters des beansdésirés après une invocation d’un constructeur sans arguments ou uneméthode statique de création pour instancier un bean.

• On peut mixer les deux types, mais il est conseillé d’utiliser le DIbasée constructeur pour les dépendances obligatoires et la DI baséesetters pour celles optionnelles



Héritage de définition des beans • Injection de dépendance (DI) basée constructeur

• Il peut y avoir une ambiguïté en passant des arguments au constructeuren cas il y a plus d'un des paramètres. Pour résoudre cette ambiguïté,l'ordre dans lequel les arguments du constructeur sont définies dansune définition de bean est l'ordre dans lequel ces arguments.

• Exemple package x.y; public class Foo { public Foo(Bar bar, Baz baz) { } <beans> <bean id="foo" class="x.y.Foo"> <constructor-arg ref="bar"/> <constructor-arg ref="baz"/> </bean> <bean id="bar" class="x.y.Bar"/> <bean id="baz" class="x.y.Baz"/> </beans>

// ... }




• Le conteneur peut également utiliser le type correspondant à des typessimples si on spécifie explicitement le type de l'argument duconstructeur en utilisant l'attribut type.

• Exemple package x.y; public class Foo { public Foo(int year, String name) { } }

<beans> <bean id="exampleBean" class="examples.ExampleBean"> <constructor-arg type="int" value="2001"/> <constructor-arg type="java.lang.String" value="Zara"/> </bean> </beans>




• On peut également passer des arguments de constructeur, utiliserl'attribut d'index pour spécifier explicitement l'indice de arguments duconstructeur

• Exemple package x.y; public class Foo { public Foo(int year, String name) { } }

<beans> <bean id="exampleBean" class="examples.ExampleBean"> <constructor-arg index="0" value="2001"/> <constructor-arg index="1" value="Zara"/></bean> </beans>



Héritage de définition des beans • Injection de dépendance (DI) basée setters

• Exemple

package com.example; public class Person{Car mycar

public Person() {

} Void setMyCar( Car c){ mycar=c;}}<beans> <bean id="john-classic" class="com.example.Person"> <property name=“mycar" ref="golf"/> </bean> <bean name=“golf" class="com.example.Car"> <property name="name" value=“Golf 6"/> </bean> </beans>

package com.example; public class Car{String namepublic Car() {

} Void setName( String n){ name=n;}}


Plateforme Web MVC de Spring


Web MVC• Spring offre une architecture web MVC (model-view-controller)

architecture et des composants prédéfinis pour développer desapplications web flexibles et faiblement couplées.

• Le modèle MVC en résulte de la séparation des différents aspects del'application (données, traitement, et présentation), par un couplagefaible de ces composants.

• Le Modèle englobe les données de l’application et en général ils sontcomposées des POJO.

• La Vue est responsable de l’affichage (rendering) des données dumodèle

• Généralement , elle génère une réponse HTML interprétable par le navigateur duclient.

• Le Controleur est responsable de traitement des requêtes utilisateur etla création d’un modèle approprié pour l’envoyer à la vue pourl’affichage.



Web MVC• Le modèle web MVC de Spring :



Web MVC• La sequence d’évènements suite à une requête HTTP

1. Après la réception d’une requête HTTP, DispatcherServlet consulte leHandlerMapping pour appeler le Contrôleur(Controller) approprié.

2. Le Contrôleur récupère la requite la requête et appellee les methodsde services appropriées basée sur la méthode GET ou POST. Laméthode de service modifie les données du modèle(model) selon lalogique métier définie et retourne le nom de la vue (view) àDispatcherServlet.

3. DispatcherServlet se servit de ViewResolver pour récupérer la vuedéfinie pour la requête.

4. Une fois la vue (view) est finalisée, DispatcherServlet passe lesdonnées du modèle à la vue , qui est finalement affichée dans lenavigateur.



Web MVC• La configuration requise

• Il faut faire la correspondance des requêtes à DispatcherServlet à traiter, avec le mapping URL dans le fichierweb.xml. L’exemple suivant montre la déclaration et le mapping pour la HelloWebDispatcherServlet :

<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Application Spring MVC </display-name> <servlet> <servlet-name>HelloWeb</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>HelloWeb</servlet-name> <url-pattern>*.jsp</url-pattern> </servlet-mapping> </web-app>


http://java.sun.com/xml/ns/j2ee



http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd



• lors de l'initialisation de HelloWebDispatcherServlet, la plateforme essaye de charger le contexte de l'application à partir d'un fichier nommé [servlet-name] -servlet.xml situé dans le répertoire WebContent / WEB-INF de l'application.

• Dans le cas de l’exemple, le fichier sera HelloWeb-servlet.xml.

• L’élement <servlet-mapping> indique que les URLs à traiter par DispatcherServlet.

• Là, toutes les requêtes HTTP se terminant par .jsp seront traitées par HelloWebDispatcherServlet.

• Si on veut donner un nom et une destination par défaut respectivement pour [servlet-name]-servlet.xml et WebContent/WEB-INF, on peut personnaliser ce fichier par l‘ajout listenerContextLoaderListener dans web.xml


<web-app...>  .... <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>


Web MVC• Le contenu du fichier [servlet-name]-servlet.xml

(HelloWeb-servlet.xml) <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <context:component-scan base-package= " exemple.spring" /> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp/" /> <property name="suffix" value=".jsp" /> </bean> </beans>



http://www.springframework.org/schema/context





http://www.springframework.org/schema/context/spring-context-3.0.xsd


Web MVC

• Le fichier [servlet-name]-servlet.xml

• [servlet-name]-servlet.xml sera utilisé pour créer les beans définis,remplaçant les définitions de toutes les beans définis avec le mêmenom dans la portée globale.

• <context:component-scan...> sera utilisé pour activer les annotation descannage de Spring MVC qui permet d’utiliser les annotations comme@Controller ,@RequestMapping etc.

• InternalResourceViewResolver aura des règles définies pour résoudre lesnoms de vue. Conformément à la règle définie dans l’exemple suivant,une vue logique nommé hello est déléguée à une implémentation de lavue dans / WEB-INF / jsp / hello.jsp.



Web MVC• Définir un Contrôleur (Controller)

• DispatcherServlet délègue la requête aux contrôleurs d'exécuter àexécuter les fonctions qui sont spécifique à cette requête.

• L'annotation @Controller indique qu'une classe particulière joue lerôle d'un contrôleur.

• L'annotation @RequestMapping est utilisé pour mapper une URL àune classe entière ou à une méthode particulière.

@Controller @RequestMapping("/hello") public class HelloController{ @RequestMapping(method = RequestMethod.GET) public String printHello(ModelMap model) { model.addAttribute("message", "Hello Spring MVC Framework!"); return "hello"; } }




• Dans cet exemple, la première utilisation de @RequestMappingindique que toutes les méthodes de ce contrôleur sont relatives auchemin /hello.

• L’annotation suivante :

@RequestMapping(method = RequestMethod.GET) est utiliséepour déclarer la méthode printHello() comme la méthode de servicepar défaut du contrôleur pour traiter les requêtes HTTP de type GET.

• On peut écrire autrement :

@Controller public class HelloController{ @RequestMapping(value = "/hello", method = RequestMethod.GET) public String printHello(ModelMap model) { model.addAttribute("message", "Hello Spring MVC Framework!"); return "hello"; } }




• L ‘attribute value indique l'URL vers laquelle la méthode de traitementest mappé et l'attribut method définit la méthode de service pourgérer les requêtes HTTP de type GET.

• On définira la logique métier requise dans une méthode de service.

• On peut appeler d’autres méthodes dans cette méthode selon l'exigence.

• Sur la base de la logique métier définie, on créera un modèle (model)dans cette méthode.

• On peut spécifier différents attributs du model et ces attributs serontaccessibles par la vue pour présenter le résultat final.

• L’exemple donné crée un modèle avec un son attribut "message".

• Une méthode de service définie peut retourner une chaîne (String)qui contient le nom de la vue à utiliser pour présente le modèle.

• Dans l’exemple on retourne " hello" comme nom de la vue.



Web MVC• Création des vues JSP

• Spring MVC supporte plusieurs types de vues pour differentestechnologies de presentation.

• JSPs, HTML, PDF, Excel worksheets, XML, XSLT, JSON, RSS feeds, etc.

• Mais, Généralement on utilise les templates JSP écrits avec JSTL.

• L’exemple de la vue hello dans /WEB-INF/hello/hello.jsp:

<html> <head> <title> Titre de la page</title> </head> <body> <h2>${message}</h2> </body> </html>



Web MVC : Example• L'exemple suivant montre comment écrire une application web simple

basée avec Spring MVC.

• les étapes à suivre:Etape Description

1. Créer un projet web (Dynamic Web Project) nommé HelloWeb et créer un package exemple.spring dans le dossier src du projet créé.

2. Ajouter les bibliothèques de Spring nécessaires dans le dossier WebContent/WEB-INF/lib.

3. Créer une classe java HelloController dans le package exemple.spring

4. Créer les fichiers de configuration de Spring Web.xml et HelloWeb-servlet.xml sous le dossier WebContent/WEB-INF.

5. Créer un sous dossier nommée jsp dans WebContent/WEB-INF. Créer le fichier de la vue hello.jsp dans ce sous dossier.

6. La dernière étape consiste à créer le contenu des fichiers source et de configuration et d'exporter l'application



Web MVC : Example• la liste de bibliothèques à inclure dans l’application

Web.• commons-logging-x.y.z.jar

• org.springframework.asm-x.y.z.jar

• org.springframework.beans-x.y.z.jar

• org.springframework.context-x.y.z.jar

• org.springframework.core-x.y.z.jar

• org.springframework.expression-x.y.z.jar

• org.springframework.web.servlet-x.y.z.jar

• org.springframework.web-x.y.z.jar

• spring-web.jar



Web MVC : Example

• La classe HelloController.java

package exemple.spring; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.ui.ModelMap; @Controller @RequestMapping("/hello") public class HelloController{ @RequestMapping(method = RequestMethod.GET) public String printHello(ModelMap model) { model.addAttribute("message", "Hello Spring MVC Framework!"); return "hello"; } }



Web MVC : Example• Le fichier de configuration web.xml

<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <display-name>Spring MVC Application</display-name> <servlet> <servlet-name>HelloWeb</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>HelloWeb</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app>







Web MVC : Example• Le fichier de configuration HelloWeb-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <context:component-scan base-package= " exemple.spring" /> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsp/" /> <property name="suffix" value=".jsp" /> </bean> </beans>










Web MVC : Example• Le fichier de la vue hello.jsp

<%@ page contentType="text/html; charset=UTF-8" %><html> <head> <title>Hello World</title> </head> <body> <h2>${message}</h2> </body> </html>



Web MVC : Example• Une fois, on a terminé la création des fichiers source et de

configuration, on exporte l'application.

• Avec un clic droit sur l'application et utiliser Exporter>War file option etenregistrer le fichier HelloWeb.war dans le dossier webapps de Tomcat.

• Démarrer le serveur Tomcat

• On essaye d'accéder à l'URL http://localhost:8080/HelloWeb /hello

• si tout va bien, on doit voir le résultat suivant:



Web MVC : Example

• Il est à noter que dans l’URL tapée, HelloWeb est le nom del’application et hello est un sous dossier virtuel mentionnée dans lecontrôleur en utilisant @RequestMapping("/hello").

• On peut utiliser la racine directement lors du mapping de URL avec@RequestMapping("/")

• Dans ce cas on peut accéder à la même avec l’URLhttp://localhost:8080/HelloWeb/

• èMais il est conseillé d’ avoir différentes fonctionnalités dansdifférents dossiers.



Web MVC Exemple de traitement de formulaire

• Il s’agit d’un exemple simple de traitement d’un formulaire

• On affiche un formulaire avec 3 champs représentant les attributsd’un étudiant ,

• Puis afficher les valeurs saisies par l’utilisateur.

• On créera la classe Etudiant, deux pages de vues etudiant.jsp etresult.jsp et les fichiers de configuration nécessaires



Web MVC Exemple de traitement de formulaire• La classe Etudiant (Etudiant.java)

package exemple.spring;

public class Etudiant {String nom;int age, id;public String getNom() {return nom;}public void setNom(String nom) {this.nom = nom;}public int getAge() {return age;}

public void setAge(int age) {this.age = age;}public int getId() {return id;}public void setId(int id) {this.id = id;}

}



Web MVC Exemple de traitement de formulaire• Le contrôleur (EtudiantController.java)

package exemple.spring;

import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; import org.springframework.ui.ModelMap;

@Controllerpublic class EtudiantController{ @RequestMapping(value = "/etudiant", method = RequestMethod.GET) public ModelAndView etudiant() { return new ModelAndView("etudiant", "command", new Etudiant()); }



Web MVC Exemple de traitement de formulaire• Le contrôleur (EtudiantController.java)

@RequestMapping(value = "/ajoutEtudiant", method = RequestMethod.POST) public String ajoutEtudiant(@ModelAttribute("gestionEtudiant")Etudiant etudiant, ModelMap model) { model.addAttribute("nom", etudiant.getNom()); model.addAttribute("age", etudiant.getAge()); model.addAttribute("id", etudiant.getId()); return "result"; } }



Web MVC Exemple de traitement de formulaire• La vue (etudiant.jsp)

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Formulaire</title></head><body><h2> Informations Etudiant</h2><form:form method="POST" action="/gestionEtudiant/ajoutEtudiant"><table><tr> <td><form:label path="nom">Nom</form:label></td><td><form:input path="nom" /></td> </tr><tr> <td><form:label path="age">Age</form:label></td><td><form:input path="age" /></td> </tr><tr> <td><form:label path="id">id</form:label></td><td><form:input path="id" /></td> </tr><tr> <td colspan="2"> <input type="submit" value="Submit"/> </td> </tr></table></form:form></body></html>


http://www.w3.org/TR/html4/loose.dtd

http://www.springframework.org/tags/form


Web MVC Exemple de traitement de formulaire• La vue (result.jsp)

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Etudiant ajouté</title></head><body><h2> Informations envoyées, Etudiant</h2><table><tr> <td>Nom :</td> <td>${nom}</td> </tr><tr> <td>Age :</td> <td>${age}</td> </tr><tr> <td>ID :</td> <td>${id}</td> </tr></table></body></html>


http://www.w3.org/TR/html4/loose.dtd


Web MVC Exemple de traitement de formulaire• Le fichier web.xml

<web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"><display-name>Spring MVC Form Handling</display-name><servlet> <servlet-name>gestionEtudiant</servlet-name><servlet-class> org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet><servlet-mapping><servlet-name>gestionEtudiant</servlet-name><url-pattern>/</url-pattern> </servlet-mapping></web-app>







Web MVC Exemple de traitement de formulaire• Le fichier gestionEtudiant-servlet.xml

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"><context:component-scan base-package="exemple.spring" /><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /></bean></beans>










Web MVC Exemple de traitement de formulaire• Exportation du fichier war (gestionEtudiant.war) et test


Plateforme de développement JEE - zlitni.comzlitni.com/courses/jee-p3.pdf · • Module Web MVC de...

Documents

Transcript of Plateforme de développement JEE - zlitni.comzlitni.com/courses/jee-p3.pdf · • Module Web MVC de...