exemple.spring - Tarek ZLITNI Offcial Web Site

publicité
Plateforme de
développement JEE
Tarek ZLITNI
[email protected]
Partie 3:
La plateforme SPRING
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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
3
Spring : Introduction
•
Spring est un framework créé et supporté par l'entreprise
SpringSource
•
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 et
est devenu un standard dans l'industrie du développement
logiciel basé sur la plateforme Java, surtout dans le
développement Java EE.
•
Spring est un conteneur léger qui facilite le développement
avec des POJO (Plain Old Java Object), c'est-à-dire avec des
classes Java qui n'ont pas besoin de s'exécuter dans un
conteneur spécifique ou dans un serveur d'applications.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
4
Spring
•
Il se compose d'un noyau (core) et de plusieurs modules qui
ajoutent des fonctionnalités.
•
Les principaux éléments du core de Spring peuvent être utilisés
dans le développement de n'importe quelle application Java
•
Spring assure des applications performantes, facilement
vérifiables, avec un code réutilisable.
•
mais il existe des extensions pour construire des applications
web à base de la plate-forme JEE.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
5
Avantages de Spring
•
Spring permet aux développeurs de développer
applications 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 la
possibilité d'utiliser seulement un conteneur de servlet robuste
comme Tomcat par exemple.
Spring est organisé d’une façon modulaire.
•
•
des
Même si le nombre de packages et les classes sont importantes, il
faut se préoccuper uniquement sur ceux que vous voulez et ignorer
le 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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
6
Avantages de Spring
•
Le test d’une application développé Spring est simple car il n y
a pas une dépendance du code à l’environnement dans ce
framework.
•
•
•
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ées
de test.
le framework web de Spring est un framework MVC Web bien
conçu, qui offre une excellente alternative aux frameworks tels
que Struts ou autre sur les frameworks web conçus ou moins
populaires.
Spring fournit une interface de gestion de transaction
cohérente, qui peut réduire à une opération locale (en utilisant
une seule base de données, par exemple) et d'intensifier les
opérations mondiales (en utilisant JTA, par exemple).
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
7
l’Inversion du Contrôle (IoC)
•
•
•
•
•
IoC est un concept général, et il peut être défini de différentes
façons.
L'inversion de contrôle permet de laisser à un conteneur comme
Spring la responsabilité de gérer le cycle de vie des objets d'une
application plutôt que de le faire manuellement.
Lors de l'écriture d'une application Java complexe, les classes
d'application devraient être aussi indépendante que possible des
autres classes Java pour augmenter la possibilité de réutiliser ces
classes et de les tester indépendamment des autres classes tout en
faisant des tests unitaires
Sans IoC il est nécessaire de faire la création d'objets avec des new ce
qui augmente les dépendances entre classes concrètes
avec l'IoC on essaye de ne référencer que des interfaces ou des
classes plus génériques ce qui permet d'avoir un code plus propre,
réutilisable et facilement testable.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
8
Injection de dépendance
(Dependency Injection (DI) )
•
•
•
•
•
Dependency Injection (DI) est est le cœur du Framework
Spring
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. Par
exemple, la classe A dépend de la classe B.
•
l'injection, cela signifie que la classe B va se injectée dans la classe A
par le Ioc.
L'injection de dépendance peut se produire dans la façon de
passer des paramètres au constructeur ou par postconstruction en utilisant des méthodes de réglage.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
9
Programmation Orientée Aspects(AOP)
•
L‘ AOP ou Programmation Orientée Aspects permet de
séparer les aspects qui se retrouvent de manière transverse
dans différentes parties d'une application permettant ainsi de
minimiser le code répétitif qui devient complexe et peu
maintenable.
•
L'AOP ne remplace donc pas la POO mais la complète en
proposant des solutions mises en œuvre de façon élégante à
certaines de ses limitations ou des fonctionnalités
manquantes.
•
AOP permet de facilement implémenter des fonctionnalités
transverses de façon modulaire.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
10
Programmation Orientée Aspects(AOP)
•
L'AOP s'utilise souvent pour écrire des Logs, mesurer les
performances ou pour la gestion de transactions.
•
la programmation orientée aspect (AOP) est considérée L'un
des composants clés du framework spring.
•
Le module AOP de Spring fournit une implémentation de la
programmation orientée aspect
•
permet de définir la méthode-intercepteurs et pointcuts de
dissocier proprement le code qui implémente des fonctionnalités
qui doivent être séparés.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
11
Architecture du
framework Spring
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.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
13
Architecture du framework Spring
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
14
Architecture du framework Spring
Core Container
• Le Core Container est composé des modules du Core, des
Beans, du Contexte (Context) et le Langage d’expression
(Expression Language )
• Le
module Core fournit les parties fondamentales du
framework, contenant les éléments duIoC et Dependency
Injection.
• Le module Bean fournit BeanFactory ; une implémentation
sophistiquée du modèle de conception (factory pattern).
• L’ interface
ApplicationContext est le point principal du
module de Context.
• le langage d’expression (Expression Language) un langage
puissant pour l'interrogation et la manipulation d'un graphe
d’objet à l'exécution.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
15
Architecture du framework Spring
Accè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 de
Transaction modules
Le module JDBC fournit une couche d’abstraction de JDBC qui évite la
nécessité de faire JDBC relié au code.
Le module ORM fournit des couches integration des APIs de mapping
objet-relationnel (JPA, JDO, Hibernate, iBatis).
Le module OXM une couche d’abstraction qui supporte des
implementations 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 des
messages.
Le module de transaction prend en charge la gestion programmatique
et déclarative transaction pour les classes qui implémentent des
interfaces spéciales et pour tous les POJOs.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
16
Architecture du framework Spring
Web
•
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.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
17
Architecture du framework Spring
Web
•
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.
•
Le module Web-Struts contient un support des classes pour
l’integration le tiers web classique de Struts web dans une
application Spring.
•
Le module Web-Portlet fournit une implémentation MVC afin de
l’utiliser dans environnement portlet et reflète la fonctionnalité
du module Web-Servlet.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
18
Architecture du framework Spring
Miscellaneous
•
Il existe d’autres modules importants comme les modules de
AOP, Aspects, Instrumentation, Web et le Test
•
Le module AOP fournit une
programmation orientée aspect
•
Le module Aspects offre une intégration avec AspectJ ; un
framework puissant programmation orientée aspect .
•
Le module Instrumentation offre des implémentations des
classes instrumentation et de chargement utilisées par certains
serveurs d’ applications.
•
Le module Test supporte the test des composants Spring avec les
frameworks JUnit ou TestNG.
©Tarek ZLITNI ([email protected])
implémentation
de
Plateforme de développement JEE
la
19
Installation de
l’environnement Spring
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 est
téléchargée, décompresser la dans l’emplacement désiré ( C:\commonslogging-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 à la
variable d’environnement CLASSPATH
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
21
Installation de l’environnement Spring
•
•
•
•
•
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 à la
variable d’environnement CLASSPATH, si
vous utiliser un IDE autre que Eclispe (Avec
Eclipse, il n'est pas nécessaire de définir
CLASSPATH)
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
22
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 droit
sur le nom du pojet
HelloSpring et puis
choisir l’option suivante
dans le menu de context :
Build Path>Configure
Build Path pour afficher
la fenetre de Java Path :
•
Utiliser le bouton Add
External JARs pour
ajouter les jars désirés
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
24
Le premier exemple avec Spring
•
•
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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
25
Le premier exemple avec Spring
• Etape 3 : Création des fichiers sources
•
Pour créer les fichiers sources du projet HelloSpring, créons d’abord
un package nommé example.spring.
•
•
Pour se faire, click droit sur src dans l’explorateur de packages et choisir
l’ option : New -> Package.
Créer les fichiers HelloWorld.java et MainApp.java files sous le
package example.spring.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
26
Le premier exemple avec 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);
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
27
Le premier exemple avec Spring
• Etape 3 : Création des fichiers sources : MainApp.java
package example.spring;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicationConte
xt;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
28
Le premier exemple avec Spring
• 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’application
APIClassPathXmlApplicationContext().
•
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 le
fichier dans le fichier de configuration.
2. La deuxième étape est chargée e récupéré le bean desire
en 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 peut
invoquer ses méthodes.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
29
Le premier exemple avec Spring
•
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-beans3.0.xsd">
<bean id="helloWorld" class= “example.spring.HelloWorld">
<property name="message" value="Hello World!"/>
</bean>
</beans>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
30
Le premier exemple avec Spring
• Etape 5 : Exécuter le programme
•
Une fois on a terminé avec la création de fichiers sources et de
configuration des beans, Il ne reste que la compilation et l'exécution
du programme.
•
Pour ce faire, Gardez onglet fichier MainApp.Java actif et utiliser
l'option Exécuter disponible dans l'IDE Eclipse ou utiliser Ctrl + F11
pour compiler et exécuter l’application MainApp., On affichera le
message suivant dans la console Eclipse IDE:
Your Message : Hello World!
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
31
Les conteneurs IoC de
Spring (IoC containers)
Les conteneurs IoC de Spring
•
Le conteneur IoC (container) de Spring est le module principal de cette
framework.
•
Le conteneur va créer les objets, les associer ensemble, les configurer
et 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és
Spring beans.
•
Le conteneur reçoit les instructions sur ce que les objets à instancier,
configurer, assembler et par la lecture des métadonnées de
configuration.
•
Les métadonnées de configuration peut être représenté soit par XML,
les annotations Java, ou un code Java.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
33
Les conteneurs IoC de Spring
• Vue globale du schéma de fonctionnement de Spring.
•
Le conteneur IoC de Spring utilise des classes Java POJO et les
métadonnées de configuration pour produire une application
entièrement configuré et exécutable.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
34
Les conteneurs IoC de Spring
•
•
•
Spring fournit deux types différents de conteneurs :
Spring BeanFactory Container
Spring ApplicationContext Container
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
35
Les conteneurs IoC de Spring
•
Spring BeanFactory Container
•
Un conteneur simple fournit les fonctionnalités basic de DI et défini par
l’interface org.springframework.beans.factory.BeanFactory. BeanFactory
et les interfaces en relations avec, comme BeanFactoryAware,
InitializingBean, DisposableBean, sont encore présents dans Spring pour les
fins 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 dans
Spring. L’implémentation couramment utilisée est la classe
XmlBeanFactory.
•
Il lit les métadonnées de configuration à partir d'un fichier XML et l'utilise
pour créer une application.
•
Il est conseillé lorsque les ressources sont limitées comme les appareils
mobiles ou des applications de base de l'applet.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
36
Les conteneurs IoC de Spring
•
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();
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
37
Les conteneurs IoC de Spring
•
Spring ApplicationContext Container
•
Ce conteneur ajoute plus de fonctionnalités spécifiques comme la capacité de
résoudre des messages textuels à partir d'un fichier proprieties et la
possibilité de publier des événements aux écouteurs. Il est défini par
l’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 fichier
XML. 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.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
38
Les conteneurs IoC de Spring
•
Spring ApplicationContext Container : Exemple
package example.Spring;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.FileSystemXmlApplicationC
ontext;
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();
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
39
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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
41
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 (argument
de constrcuteur)
properties
utilisé pour injecter les dépendances (les propriétés d’un bean)
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
42
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-initialization
mode
Un bean déclaré lazy-initialized appelle le conteneur IoC
pour créer une instance du bean lorsqu’il est demandé la
première fois ou au démarrage.
initialization
method
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.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
43
Définition des beans
• Les métadonnées de configuration de Spring
•
Le conteneur IoC de Spring est totalement indépendant du format dans
laquelle ces métadonnées de configuration sont écrites.
•
Trois méthodes importantes pour créer les métadonnées de
configuration:
1. Configuration à base d’un fichier XML.
2. Configuration à base d’annotation.
3. Configuration à base d’un code Java.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
44
Cycle de vie des beans
Cycle de vie des beans
•
Quand un bean est instancié, il peut être nécessaire d'effectuer une
initialisation de l'obtenir dans un état utilisable. De même, lorsque il n'est
plus 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 la
destruction d’un bean, nous se limitons à ce niveau uniquement à deux
méthodes importantes dans le cycle de vie d’un bean, qui sont requises au
moment d’initialisation et de destruction.
•
Pour la configuration et la destruction d’un bean, on déclare simplement
le 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édiatement
lors de l’instanciation du bean.
•
De même , destroy-method spécifie une méthode qui peut être invoquée juste avant
que le bean est supprimé du conteneur.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
46
Cycle de vie des beans
•
Initialisation
•
Implémentation de l’interface InitializingBean
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// un code d’initialisation
}
}
•
Ou bien , avec une configuration à base d’XML
<bean id="exampleBean"
class="examples.ExampleBean" init-method="init"/>
public class ExampleBean {
public void init() {
// un code d’initialisation
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
47
Cycle de vie des beans
•
Destruction
•
Implémentation de l’interface DisposableBean
public class ExampleBean implements DisposableBean {
public void destroy(){
// un code de destruction
}
}
•
Ou bien , avec une configuration à base d’XML
<bean id="exampleBean"
class="examples.ExampleBean" destroy-method="destroy"/>
public class ExampleBean {
public void destroy() {
// un code de destruction
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
48
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 destruction
ou avec le même nom, on n’a pas besoin de déclarer init-method et destroymethod pour chaque bean. Spring offre la possibilité de configurer cette
situation en utilisant les attributs par défaut : default-init-method and defaultdestroy-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/bean
s
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
49
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 la
définition du parent. La définition du fils peut réécrire quelques valeurs ou
ajouter d’autres , selon le besoin.
•
L’héritage des définitions n’a aucune relation avec l’héritage des classes
mais le concept est le même.
•
•
On peut définir la configuration du bean parent comme un modèle et les beans fils
héritent la configuration nécessaire du parent.
Avec une configuration basée XML, on peut spécifier la définition du bean
fils moyennant l’attribut parent, qui spécifie le bean parent comme valeur
de cet attribut.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
51
•
Héritage de définition des beans
Exemple :Beans.xml
<?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/sche
ma/beans
http://www.springframework.org/schema/beans/springbeans-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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
52
•
Héritage de définition des beans
Exemple : HelloWorld.java
Package 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);
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
53
•
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); }}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
54
•
Héritage de définition des beans
Exemple : MainApp.java
Package example.spring;
import org.springframework.context.ApplicationContext;
import
org.springframework.context.support.ClassPathXmlApplicat
ionContext;
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();}}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
55
•
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!
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
56
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éfinitions
de beans des enfants sans mettre beaucoup d'efforts. Lors de la définition d'un modèle
de 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 beans
abstract est utilisé comme un parent qui nécessite par la suite la définition des
enfants
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
57
Injection de
dépendance
Héritage de définition des beans
•
Chaque application java a un ensemble d’objets qui communiquent
ensemble pour présenter le résultat final à l’utilisateur.
•
Lors de développement d'une application Java complexe, les classes
d'application devraient être indépendantes le maximum possible des
autres classes pour augmenter la possibilité de réutiliser ces classes et
de les tester indépendamment.
•
L’injection de dépendance (wiring) permet d’attacher ces classes
ensemble et en même temps en les maintenir indépendantes.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
59
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 avec
un certain nombre d'arguments, chacun représentant une dépendance
sur 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 beans
désirés après une invocation d’un constructeur sans arguments ou une
méthode statique de création pour instancier un bean.
•
On peut mixer les deux types, mais il est conseillé d’utiliser le DI
basée constructeur pour les dépendances obligatoires et la DI basée
setters pour celles optionnelles
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
60
Héritage de définition des beans
•
•
Injection de dépendance (DI) basée constructeur
•
Exemple package x.y;
Il peut y avoir une ambiguïté en passant des arguments au constructeur
en 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 dans
une définition de bean est l'ordre dans lequel ces arguments.
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
61
Héritage de définition des beans
•
•
Injection de dépendance (DI) basée constructeur
•
Exemple
Le conteneur peut également utiliser le type correspondant à des types
simples si on spécifie explicitement le type de l'argument du
constructeur en utilisant l'attribut type.
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
62
Héritage de définition des beans
•
•
Injection de dépendance (DI) basée constructeur
•
Exemple
On peut également passer des arguments de constructeur, utiliser
l'attribut d'index pour spécifier explicitement l'indice de arguments du
constructeur
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
63
•
•
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() {
package com.example;
public class Car{
String name
public Car() {
}
Void setMyCar( Car c){
mycar=c;}
}
}
Void setName( String n){
name=n;}
}
<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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
64
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 des
applications web flexibles et faiblement couplées.
•
Le modèle MVC en résulte de la séparation des différents aspects de
l'application (données, traitement, et présentation), par un couplage
faible de ces composants.
•
Le Modèle englobe les données de l’application et en général ils sont
composées des POJO.
•
La Vue est responsable de l’affichage (rendering) des données du
modèle
•
•
Généralement , elle génère une réponse HTML interprétable par le navigateur du
client.
Le Controleur est responsable de traitement des requêtes utilisateur et
la création d’un modèle approprié pour l’envoyer à la vue pour
l’affichage.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
66
Web MVC
•
Le modèle web MVC de Spring :
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
67
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 le
HandlerMapping pour appeler le Contrôleur(Controller) approprié.
2.
Le Contrôleur récupère la requite la requête et appellee les methods
de services appropriées basée sur la méthode GET ou POST. La
méthode de service modifie les données du modèle(model) selon la
logique métier définie et retourne le nom de la vue (view) à
DispatcherServlet.
3.
DispatcherServlet se servit de ViewResolver pour récupérer la vue
définie pour la requête.
4.
Une fois la vue (view) est finalisée, DispatcherServlet passe les
données du modèle à la vue , qui est finalement affichée dans le
navigateur.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
68
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
69
Web MVC
•
•
La configuration requise
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 / WEBINF de l'application.
•
•
L’élement <servlet-mapping> indique que les URLs à traiter par
DispatcherServlet.
•
•
Dans le cas de l’exemple, le fichier sera HelloWeb-servlet.xml.
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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
70
Web MVC
• La configuration requise
<web-app...>
<!-------- definition de DispatcherServlet ICI ---->
....
<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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
71
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
72
Web MVC
•
•
Le fichier [servlet-name]-servlet.xml
•
<context:component-scan...> sera utilisé pour activer les annotation de
scannage de Spring MVC qui permet d’utiliser les annotations comme
@Controller ,@RequestMapping etc.
•
InternalResourceViewResolver aura des règles définies pour résoudre les
noms 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 la
vue dans / WEB-INF / jsp / hello.jsp.
[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ême
nom dans la portée globale.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
73
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 le
rô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";
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
74
Web
MVC
• Définir un Contrôleur (Controller)
•
Dans cet exemple, la première utilisation de @RequestMapping
indique que toutes les méthodes de ce contrôleur sont relatives au
chemin /hello.
•
L’annotation suivante :
@RequestMapping(method = RequestMethod.GET) est utilisée
pour déclarer la méthode printHello() comme la méthode de service
par 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"; }
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
75
Web MVC
• Définir un Contrôleur (Controller)
•
L ‘attribute value indique l'URL vers laquelle la méthode de traitement
est mappé et l'attribut method définit la méthode de service pour
gé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 seront
accessibles 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.
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
76
Web MVC
• Création des vues JSP
•
Spring MVC supporte plusieurs types de vues pour differentes
technologies 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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
77
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 HelloWebservlet.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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
78
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
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
79
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";
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
80
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
81
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
82
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
83
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 et
enregistrer 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:
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
84
Web MVC : Example
•
Il est à noter que dans l’URL tapée, HelloWeb est le nom de
l’application et hello est un sous dossier virtuel mentionnée dans le
contrô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
http://localhost:8080/HelloWeb/
•
èMais il est conseillé d’ avoir différentes fonctionnalités dans
différents dossiers.
©Tarek ZLITNI ([email protected])
à
la
même
avec
Plateforme de développement JEE
l’URL
85
Web MVC
Exemple de traitement de formulaire
•
•
Il s’agit d’un exemple simple de traitement d’un formulaire
•
•
Puis afficher les valeurs saisies par l’utilisateur.
On affiche un formulaire avec 3 champs représentant les attributs
d’un étudiant ,
On créera la classe Etudiant, deux pages de vues etudiant.jsp et
result.jsp et les fichiers de configuration nécessaires
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
86
Web MVC
Exemple de traitement de formulaire
•
La classe Etudiant (Etudiant.java)
public void setAge(int age) {
this.age = age;
}
public class Etudiant {
public int getId() {
String nom;
return id;
int age, id;
}
public String getNom() {
public void setId(int id) {
return nom;
this.id = id;
}
public void setNom(String nom) }
{
}
this.nom = nom;
}
public int getAge() {
return age;
}
package exemple.spring;
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
87
Web MVC
Exemple de traitement de formulaire
•
Le contrôleur (EtudiantController.java)
package exemple.spring;
import
import
import
import
import
import
org.springframework.stereotype.Controller;
org.springframework.web.bind.annotation.ModelAttribute;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.servlet.ModelAndView;
org.springframework.ui.ModelMap;
@Controller
public class EtudiantController
{
@RequestMapping(value = "/etudiant", method = RequestMethod.GET)
public ModelAndView etudiant() {
return new ModelAndView("etudiant", "command", new Etudiant());
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
88
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";
}
}
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
89
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>
90
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
Web MVC
Exemple de traitement de formulaire
•
La vue (result.jsp)
<%@ page language="java" contentType="text/html; charset=ISO8859-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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
91
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
92
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>
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
93
Web MVC
Exemple de traitement de formulaire
•
Exportation du fichier war (gestionEtudiant.war) et test
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
94
Web MVC
Exemple de traitement de formulaire
•
Exportation du fichier war (gestionEtudiant.war) et test
©Tarek ZLITNI ([email protected])
Plateforme de développement JEE
95
Téléchargement