Cedric Dumoulin

Bibliographie
 Spring IO
 [Link]
 Developing a Spring Framework MVC application
step-by-step (2.5)
 [Link]
 Spring MVC Framework Tutorial
 [Link]
[Link]
 Wikipedia
 [Link]
 Quick start
 [Link]
Guides
 Accessing Data with JPA
 [Link]

 Serving Web Content with Spring MVC (2016)

 [Link]
 Rappel Spring MVC
serveur applis servlets ctrls views
url=ctrl1
appli1
‘/’
select view1
‘appli1/ctrl1’
servlet1 view1

requete select appli2

url=ctrl2 select

view2
appli3 pages view2

url=ctrl3
view3

view2

reponse
 Rappel Spring MVC
viewResolver
déclaré ds spring-
[Link]

serveur applis servlets ctrls views

url=ctrl1
appli1
‘/’
select view1
‘appli1/ctrl1’
servlet1 view1

requete select appli2

url=ctrl2 select

view2
appli3 pages view2

url=ctrl3
view3

view2

reponse

déclaré dans Dans une JSP dans

web-inf Classe WEB-INF
Différentes approches
 Eclipse
 Créer un projet Web dynamique
 Le rendre « Maven » compatible
 Ajouter les dépendances
 SPS
 Créer un projet « Spring legacy »
 Choisir projet Web MVC
 Le projet est prêt a fonctionner
 Spring Boot
 C’est Spring + des librairies permettant de faire tourner l’appli
comme une appli Java (avec un main() )
Atelier
 Créer un nouveau projet Spring dans Eclipse (avec
STS)
 Nom : [Link].atelier2
 Packages : [Link].atelier2

 Tester !!
Rôle d’un contrôleur
 Un contrôleur sert à traiter une requête http
 [Link]
 Spring permet
 de mapper l’url de la requête avec une méthode d’un
contrôleur
 De mapper les paramètres de la requête avec les
arguments de la méthode
 De mapper des objets du contexte de la requête avec les
arguments de la méthode
Controller simple Déclare un contrôleur

L’url associée a ce ctrl

@Controller
public class HomeController {

@RequestMapping(value = "/home", method = [Link])

public String home(Locale locale, Model model) {

String formattedDate = getFormattedDate(locale);

[Link]("serverTime", formattedDate );

return "home_rendu"; Le model qui sera passé à la

} page

Un attribut qui sera passé à la

page
Nom logique de la page
Controller simple
Spécifie le type de
requete (GET ou POST)
@Controller
public class HomeController {

@RequestMapping(value = "/home", method = [Link])

public String home(Locale locale, Model model) {

String formattedDate = getFormattedDate(locale); Demande l’objet Locale

[Link]("serverTime", formattedDate );

return "home_rendu";
}
Controller
 Peut contenir plusieurs méthodes avec différentes URL
 Les paramètres des méthodes sont « libre »
 C’est le type ou l ’annotation qui est détecté
 L’annotation @RequestMapping peut se faire sur la
classe
 Toute les url de méthodes sont alors relative a l’url de la
classe.
Spécifier le type de requêtes
 Optionnel
 GET
 Le plus courant : demande une page
 POST
 Suite à la soumission d’un formulaire

 2 possibilités
@RequestMapping(value = "/home", method = [Link])

@GetMapping(value = "/home")
Atelier
 Créer un nouveau controleur
Différentes moteurs de rendus
peuvent être utilisées
 JSP
 Thymeleaf
 Tiles
…

 Indépendant du contrôleur
ViewResolver
 Objets de configuration
 Sert à mapper
 Le nom logique de la vue (renvoyé par un controleur)
 Avec la ressource (le nom du fichier contenant la vue)

 Induit aussi le type du moteur (JSP, Thymeleag …)

 Utiliser JSF
 InternalResourceViewResolver

<!-- Resolves views selected for rendering by @Controllers to

.jsp resources in the /WEB-INF/views directory -->
<beans:bean
class=
"[Link]">

<beans:property name="prefix" value="/WEB-INF/views/" />

<beans:property name="suffix" value=".jsp" />
<beans:property name="order" value="2" />
</beans:bean>
 Utiliser Thymeleaf
 ThymeleafViewResolver
 Fait référence à un moteur
 Il faut déclarer le moteur

<beans:bean class="[Link]">
<beans:property name="templateEngine" ref="templateEngine" />
<!-- NOTE 'order' and 'viewNames' are optional -->
<beans:property name="order" value="1" />
<beans:property name="viewNames" value="*.html,*.xhtml" />
</beans:bean>
Thymeleaf – Déclaration du moteur
 Fait référence à un templateResolver
 Il faut le déclarer

<beans:bean id="templateEngine"
class="[Link]">
<beans:property name="templateResolver" ref="templateResolver" />
<!-- Enabling the SpringEL compiler with Spring 4.2.4 or newer
can speed up -->
<!-- execution in most scenarios, but might be incompatible
with specific -->
<!-- cases when expressions in one template are reused across
different data -->
<beans:property name="enableSpringELCompiler" value="true" />
</beans:bean>
Thymeleaf – Déclaration du
TemplateResolver
<beans:bean id="templateResolver"
class=
"[Link]">
<beans:property name="prefix" value="/WEB-INF/templates/" />
<beans:property name="suffix" value=".html" />
<!-- HTML is the default value, added here for the sake of
clarity. -->
<beans:property name="templateMode" value="HTML" />
<!-- Template cache is true by default. Set to false if
you want -->
<!-- templates to be automatically updated when modified. -->
<beans:property name="cacheable" value="false" />
</beans:bean>
 Thymeleaf – Dépendances

<!-- [Link]
<dependency>
<groupId>[Link]</groupId>
<artifactId>thymeleaf-spring4 </artifactId>
<version>[Link]</version>
</dependency>
Thymeleaf – Exemple
<!DOCTYPE html>
<html xmlns="[Link]
xmlns:th="[Link]
<head>
<title>Hello World Thymeleaf!!</title>
<meta http-equiv="Content-Type" content="text/html;
charset=UTF-8" />
</head>
<body>
Server time :
<p th:text="${serverTime}">Hello World Thymeleaf Offline!!</p>
</body>
</html>
Etapes
 Ajouter les dependances
 Creer le repertoire pour les templates thymleaf
 Declarer les beans de configuration
 Creer un controleur utilisant une page de rendu
thymeleaf
Bibliographie
 [Link]
[Link]#views-and-view-resolvers-in-spring-mvc
Atelier
 Atelier Utiliser une autre technique de rendu
Comment passer des parametres
 Soit un par un

<a href="[Link]?name=skywalker">skywalker !</a>

 Soit plusieurs a l'aide d'un form

Soit plusieurs a l'aide d'un form
<form action="[Link]">
<table>
<tr>
<td>name : </td><td><input type="text" name="name"/></td>
</tr>
<tr>
<td>surnname : </td><td><input type="text" name="surname"/></td>
</tr>
<tr>
<td>mail : </td><td><input type="text" name="mail"/></td>
</tr>
<tr>
<td> </td><td><input type="submit" title="Send !"/></td>
</tr>
</table>
</form>
 Comment les recuperer ?
 Dans un controleur
 Soit un par un avec @RequestParam
@RequestMapping("/greeting")
public String greeting(
@RequestParam(value="name", required=false, defaultValue="World")
String name,
Model model) {
[Link]("greeting! ");
[Link]("name", name);

// We should put the file extension in order to let the

//ViewResolver filter set in [Link] works
return "[Link]";
}
Soit a l'aide d'un objet
 Utiliser @ModelAttribute

@RequestMapping("/forms")
public String receiveForms(@ModelAttribute Person person,
Model model, Locale locale) {

[Link]("name", [Link]());

return "forms_rendu";
}
Etapes pour utiliser un formulaire
 Ecrire deux pages de rendus
 l'une affichant le formulaire
 l'autre affichant le resultat de la soumission du
formulaire
 Ecrire deux controleurs
 L'un pour afficher le formulaire
 l'action du formulaire designe l'url du controleur traitant le
formulaire
 L'autre pour recuperer les params du formulaire, puis les
afficher dans une page
Atelier
 récupérer un paramètres
 récupérer plusieurs paramètres dans un objet
Formulaire avancé
 Offre plus de possibilité que le formulaire HTML
 S’utilise avec un balise spécifique
JSP
<%@ taglib uri="[Link] prefix="c"%>
<%@ taglib
prefix="form" uri="[Link]

<form:form modelAttribute="person"
method="POST"
action="${[Link]}/[Link]">

<form:input path="name" />

<input type="submit" value="Send !" />

</form:form>
 Thymeleaf
<!DOCTYPE HTML>
<html xmlns:th="[Link]
<head>
<title>Getting Started: Handling Form Submission</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>

<form action="#" th:action="@{/[Link]}"

th:object="${person}" method="post">
<p>name: <input type="text" th:field="*{name}" /></p>
<p>surname: <input type="text" th:field="*{surname}" /></p>
<p>age: <input type="text" th:field="*{age}" /></p>
<p><input type="submit" value="Submit" />
<input type="reset" value="Reset" /></p>
</form>
</body>
</html>
Bibliographie Forms
 Spring Forms taglib doc
 [Link]
framework-reference/html/[Link]
 [Link]
Atelier
 Atelier – Formulaire avancé avec JSP
 Atelier – Formulaire avancé avec Thymeleaf
Bibliographie
 Validation
 [Link]
validations-par-la-norme-jsr-303-bean-validation/
 [Link]
mvc-form-handling-tutorial-and-example
Documentation
 [Link]
ng-framework-reference/htmlsingle/#validation

 7.8.4 Spring MVC 3 Validation

 Tutorials
 (2016) [Link]
validation-example-mvc-validator
 [Link]
g-mvc-form-validation-example-with-bean-
validation-api
Que valider ?
 Il faut valider pour se garantir :
• De mauvaises saisies dans les formulaires
• De données saisies non valables pour le métier

 Les mauvaises saisies peuvent être détectés par:

 la conversion de la requête http  objet command
 Les contraintes métiers peuvent être détectés par:
 des objets de validation
Validation
 Action de valider des données en fonction du métier
 ex: 0<= age <150

 Plusieurs possibilités avec Spring

 les technique se sont empilées avec le temps
 Les plus récentes:
 Validation explicite
 @Valid
 JSR-303 Bean Validation API
Spring 4 et la validation
 Deux méthodes (complémentaires)
 Erreurs de conversion
 Détectées quand Spring convertit les données du formulaire dans un
bean
 Bean Validation API
 a.k.a. JSR 303 for Bean Validation 1.0

 and JSR 349 for Bean Validation 1.1

 Fonctionne par annotations

 Actionnée à la demande (@Valid)

 Validator Objects
 Déclare et utilise des objets de validations

 Appel explicite du validator

Bean Validation
 Principe:
 annote le bean : @NotEmpty, @Email, @Size …
 Spécifie les messages d’erreurs
import [Link];

import [Link];
import [Link];

public class User {

@NotEmpty
@Email
private String email;

@NotEmpty(message = "Please enter your password.")

@Size(min = 6, max = 15, message = "Your password must between 6 and 15 characters")
private String password;

. . . // getters + setters
}
Validation explicite
lors de la conversion
 Utilise @Valid (JSR)

@RequestMapping(value = "/login", method = [Link])

public String doLogin(@Valid @ModelAttribute("userForm") User userForm,
BindingResult result, Model model) {

if ([Link]()) {
return "LoginForm";
}
return "LoginSuccess";
}
}
Principe
 Avoir un objet de type BindingResult dans le context
de la page de rendu
 L’objet contient des erreurs
  On peut utiliser les tags de gestion d’erreurs dans la
page de rendu
BindingResult
 BindingResult est créé et rempli lors de la validation
 Il est par défaut passé au context de la page
 Il faut le déclarer immédiatement après l’o validé l’objet
validé
 Il peut y avoir plusieurs paires objet validé/bindingResult

@RequestMapping(value = "/login", method = [Link])

public String doLogin(@Valid @ModelAttribute("userForm") User userForm,
BindingResult result, Model model) {

if ([Link]()) {
return "LoginForm";
}
return "LoginSuccess";
}
}
Affichage des erreurs - JSP
<form:errors path="email" cssClass="error"/>

<%@ taglib prefix="form" uri="[Link]

...
<form:form action="login" commandName="userForm">
…
<form:input path="email" size="30"/></td>
<form:errors path="email" cssClass="error"/>
…
</form:form>

 Le tag <form:errors .. /> permet d’afficher le message

d’erreur uniquement si la propriété indiquée est en erreur.
Affichage des erreurs Thymeleaf
<td th:if="${#[Link]('name')}" th:errors="*{name}">Name
Error</td>

<form action="#" th:action="@{/[Link]}" th:object="${person}"

method="post">
<table>
<tr>
<td>Name:</td>
<td><input type="text" th:field="*{name}" /></td>
<td th:if="${#[Link]('name')}" th:errors="*{name}">Name
Error</td>
</tr>
. . .
</table>
</form>
Librairie requises
 [Link]
 [Link]
 [Link]
idation/validation-api
 Maven :
<dependency>
<groupId>[Link]</groupId>
<artifactId>validation-api</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-validator</artifactId>
<version>[Link]</version>
</dependency>
Etapes
 Validation
 Ajouter les dépendances pour la validation
 Annoter les classes à valider
 Annoter les arguments a valider dans les controleurs
 Affichage des erreurs
 Modifier les formulaires ou les pages pour afficher les
erreurs
 Modifier les controleurs pour utiliser les pages avec
affichage d’erreurs.
Atelier
 Atelier – Formulaire et validation (jsp)
 Atelier – Formulaire et validation (thymeleaf)
Demo
Bibliographie
 Internationalization in Spring Boot
 [Link]
internationalization
 Spring MVC Internationalization (i18n) and
Localization (L10n) Example
 [Link]
internationalization-i18n-and-localization-l10n-example
Bibliographie
 [Link]
internationalization-i18n-localization-tutorial-
example/
 I18n avec changement possible du local :
 [Link]
internationalization-i18n-and-localization-l10n-example
 [Link]
internationalization
Principe
 Utilise la notion de « Locale » : Pays_langue
 FR_fr, US_en
 Dans le code, on utilise des constantes à la place du
texte
<spring:message code="[Link]"/>

 Les constantes sont définies dans des fichiers

 Un fichier par langue
Fichiers de langues
 Contiennent la définition des constantes
 Pairs nom=valeur
 A placer dans
 src/main/resources
 Un fichier par langue
 Un fichier par défaut
 Tous les fichiers ont le même nom
 Mais des extensions en fonction du locale:
 [Link]
 messages_FR_fr.properties
Alternatives:
 Des pages différentes en fonction du locale
 Possible avec Tiles
Spring MVC
Les fichiers properties
 Permet d’utiliser des constantes dans les pages
 Les définitions sont dans des fichiers *.properties
 Dans répertoire src/main/resource/*

fichier local = fr

fichier par défaut

pas définit = venant

du fichier par défaut
Configuration
 Dans le fichier de configuration Spring
 [servlet]-[Link]
 Spécifier que l’on veut utiliser les messages de
properties

<!-- Specify the source for i18n -->

<beans:bean id="messageSource"
class="[Link]">
<beans:property name="basename" value="classpath:messages" />
<beans:property name="defaultEncoding" value="UTF-8" />
</beans:bean>
 I18n avec Spring et JSP
<%@ taglib uri="[Link] prefix="c" %>
<%@taglib uri="[Link] prefix="spring"%>
<%@ page session="false" %>
<html> La taglib utilisée
<head>
<title><spring:message code="[Link]"/></title>
</head>
<body> Le message
<h1>
<spring:message code="[Link]"/>
</h1>

<P> <spring:message code="[Link]"/> ${serverTime}. </P>

</body>
</html>
I18n avec Spring et thymeleaf
 Utiliser la syntaxe #{key}
<h1 th:text="#{greeting}"></h1>
I18n avec Spring et thymeleaf
<!DOCTYPE HTML>
<html xmlns:th="[Link]

<head>
<title th:texte="#{[Link]}" /></title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<h1 th:text="#{[Link]}"></h1>

<p th:texte="#{[Link]}" > ${serverTime}. </p>

</body>
</html>
Laisser l’utilisateur
choisir sa langue
 Il faut ajouter un choix du local
 Il faut prendre en compte le changement

  voir tuto
 [2017] [Link]
internationalization
 [2016] [Link]
internationalization-i18n-localization-tutorial-example/
Changer le locale dynamiquement
 Ajouter un parametre locale=?? à la requête

[Link]

 Peut se faire grace à des liens dans les pages

<a href="/home?locale=en" >en</a>,
<a href="/home?locale=fr" >fr</a>

 Prendre en compte le changement dynamique dans

l’application
 Configurer Spring !
Prendre en compte le changement
dynamique dans l’application
 Ajouter le LocaleResolver
<beans:bean id="localeResolver" class=
"[Link]">
<beans:property name="defaultLocale" value="en" />
</beans:bean>

 Ajouter un intercepteur
 Pour intercepter le parametre locale
<interceptors>
<beans:bean class=
"[Link]">
<beans:property name="paramName" value="locale" />
</beans:bean>
</interceptors>
Etapes pour internationaliser
 Ajouter les dépendances
 Créer les fichiers ressources
 Dans src/main/resources
 Configurer Spring:
 Le bean pour chercher les resources
 Le bean interceptor pour changer la localisation
dynamiquement
 Le bean pour maintenir la localisation
 Localiser les pages (utiliser les codes a la place du texte)
 JSP
 Thymeleaf
 Modifier les pages pour permettre le choix du locale
Atelier
 Créer un nouveau projet Spring. Spring génère une
page « home ». Internationaliser cette page.
Tous les sites proposent
des pages cohérentes
 Avec un header, un footer, un body, un
menu …
 Faut-il coder ces éléments dans toutes les
pages ?
 Et si on doit modifier le footer, faut-il alors
modifier toutes les pages ?

 Solution :
 Utiliser un framework permettant de
separer le header, le footer, le body et le
menu …
 Ex: Tiles
Principe
 Définir une seule fois les parties communes:
 Un header, un footer un main menu
 Assembler les pages
 Seule le body change
  il faut coder celui-ci à part.
 Une page == body + parties communes
 Vous définissez le body
 Le framework ce charge de construire la page en
assemblant les parties pour vous
Plusieurs implémentations
 Tiles
 Initialement développé pour Struts
 Utilisées dans de nombreux moteurs (encore
aujourd’hui)
 Pour JSP

 Pour Thymeleaf
 utiliser thymeleaf-layout-dialect
 [Link]
 [Link]
Mise en œuvre avec Tiles
[Link] [Link]

[Link]

[Link] [Link]

[Link] [Link]

2) Assembler avec des définitions

1) Définir des Tiles
3) choisir la ‘view’ dans le contrôleur
Définir les assemblages
fichier de configuration xml
 Crée une définition de base ‘classicLayout’

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE tiles-definitions PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
"[Link]
<tiles-definitions>
<definition name=" classicLayout" template="/WEB-INF/views/[Link]">
<put-attribute name="title" value="My Title"/>
<put-attribute name="header"
value="/WEB-INF/views/[Link]"/>
<put-attribute name="body" value=""/>
<put-attribute name="footer"
value="/WEB-INF/views/[Link]"/>
</definition>
</tiles-definitions>
Définir les assemblages
Ajouter des vues
 Utilise mécanisme d’héritage
 Etend la définition de base
 Surcharge uniquement les attributs à modifier

<tiles-definitions>
<definition name= "view1" extends="classicLayout ">
<put-attribute name="title" value="Another Title"/>
<put-attribute name="body"
value="/WEB-INF/views/[Link]"/>
</definition>
</tiles-definitions>
[Link]
(attention aux pieges  )
<%@ page contentType="text/html;charset=UTF-8"%>
<%@ taglib uri="[Link] prefix="tiles"%>
<!DOCTYPE html>
<html lang="en" class="no-js">
<head>
<meta charset="UTF-8">
<title><tiles:insertAttribute name="title" ignore="true" /></title>
<tiles:insertAttribute name="stylecss" />
</head>
<body>
<tiles:insertAttribute name="header" />
<tiles:insertAttribute name="body" />
<tiles:insertAttribute name="footer" />
<tiles:insertAttribute name="scriptjs" />
</body>
</html>
Dépendances Maven
 [Link]
 Il faut :
 tiles-jsp
 tiles-core
 tiles-templates
 tiles-api
 tiles-servlet
 <dependency>
<groupId>[Link]</groupId>
<artifactId>tiles-core</artifactId>
<version>${tiles-version}</version>

Ajouter les
</dependency>
<dependency>
<groupId>[Link]</groupId>

dépendances <artifactId>tiles-jsp</artifactId>
<version>${tiles-version}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>tiles-api</artifactId>
<properties> <version>${tiles-version}</version>
... </dependency>
<tiles-version>3.0.8</tiles-version> <groupId>[Link]</groupId>
</properties> <artifactId>tiles-servlet</artifactId>
<version>${tiles-version}</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>tiles-template</artifactId>
<version>${tiles-version}</version>
</dependency>
 Configurer Spring
<beans:bean id="tilesConfigurer"
class="[Link]">
<beans:property name="definitions">
<beans:list>
<beans:value>/WEB-INF/views/tiles/[Link]</beans:value>
<beans:value>/WEB-INF/views/**/[Link]</beans:value>
</beans:list>
</beans:property>
</beans:bean>
<beans:bean id="tilesViewResolver"
class="[Link]">
<beans:property name="viewClass">
<beans:value>
[Link]
</beans:value>
</beans:property>
<beans:property name="order" value="0" />
</beans:bean>
 Spring MVC et Tiles
serveur applis servlets ctrls definitions tiles
url=ctrl1
appli1
‘/’
select
‘appli1/ctrl1’
servlet1 view1 lay
hea
out
der1
[Link]
foo
.jsp
requete select appli2
p
ter
url=ctrl2 select
me
[Link]
me
p
nu2 nu1.
.jsp jsp

appli3 pages view2

bo
dy1
bo
dy
[Link]
.jsp
p

url=ctrl3

view2

reponse
 Spring MVC et Tiles
TilesViewResolver
déclaré ds spring-
[Link]

serveur applis servlets ctrls definitions tiles

url=ctrl1
appli1
‘/’
select
‘appli1/ctrl1’
servlet1 view1 lay
hea
out
der1
[Link]
foo
.jsp
requete select appli2
p
ter
url=ctrl2 select
me
[Link]
me
p
nu2 nu1.
.jsp jsp

appli3 pages view2

bo
dy1
bo
dy
[Link]
.jsp
p

url=ctrl3

view2

reponse

déclaré dans Dans une fichiers jsp

[Link] sous
web-inf Classe
WEB-INF
Webographie
 Spring MVC Tiles 3 Integration Tutorial
 [Link]
[Link]

 Spring 3 MVC: Tiles Plugin Tutorial with Example in

Eclipse
 [Link]
tutorial-example-eclipse/
 Tiles
 [Link]
Utilisation dans le contrôleur
Spring
 Le contrôleur Spring doit renvoyer le nom logique de
la page a afficher
 C’est le nom spécifié dans le fichier [Link] lors de la
déclaration d’un assemblage …
Etapes pour utiliser Tiles
 Ajouter les dependances Maven
 Configurer Spring
 Ajouter les beans de dependances
 Ecrire les Tiles de base : [Link], [Link],
[Link], [Link].
 Ecrire le layout principale
 [Link]
 Ecrire la definition pour le layout principal
Etapes pour ajouter une page
utilisant Tiles
 Ecrire le body de la page
 [Link]
 Ajouter une définition pour ce body
 Dans le fichier de definition
 Elle etend ClassicLayout
 Ecrire le controleur de la page
 Il utilise le nom de la definition comme non de page de
rendu.
Atelier
 ateliers Tiles
 Header Footer Body (Tiles)
Notion de composants
Components
 Spring fournit la notion de composant
 Une classe annoté @Component
 Permet de créer des objets métier
 Permet de connecter les objets métiers entre eux (par
injections)
Connecter les composants
 Connexion par injection
 On peut injecter des composants dans d’autre
composants
 Même principe que JEE
 Déclarer un composant : @Component, @Named
 Injecter un composant:
 @Inject, @Autowired
Déclarer un composant
 Par défaut, le nom est le nom simple de la classe (commençant par une
minuscule)
 2 tags équivalent: @Component et @Named
 On peut spécifier le nom
 @Component("injectedComponent")

Déclare un composant
/**
* A simple bean that will be injected elsewhere
*/
@Component
public class InjectedBean {

private String firstname = "John";

private String lastname = "Doe";

//.. Getter an setter ..

}
Déclarer un composant (2)
 Indiquer a Spring de scanner les classes
 Dans le fichier de context (WEB-INF/[Link])
 <context:component-scan base-
package=‘’[Link]’’ />
Injecter un composant
 @Inject (et @Autowired, @Resource)
 Peut se faire sur un attribut, un setter, …
 Recherche si il existe un bean du nom de l’attribut, et compatible avec le type
 Si non recherche un bean compatible avec le type
 Si non  erreur
 On ne peut pas spécifier le nom
 Sauf pour @Resource(‘name’)

@Controller Spring injecte le bean du

public class HomeController { bon type
/**
* Try to inject a bean
*/
@Inject
protected InjectedBean injectedBean;

// ..
}
Comment relier les deux
Bibliographie
 Chapter 18. Enterprise Java Beans (EJB)
integration
 [Link]
ml
 [Link]
framework-reference/html/[Link]
Injecter des EJB Session
dans Spring
 C’est possible !
 Un Component Bean Session peut être vu comme un
Component Spring

 En deux temps:
 déclarer le Bean Session en tant que Component Spring
 injecter le component à l’endroit où on veut l’utiliser
 Déclarer le bean session en tant
que Component Spring declaration du namespace
<?xml version="1.0" encoding="UTF-8"?>
 Dans le fichier de configuration
<beans:beans xmlns="[Link]
xmlns:xsi="[Link]
xmlns:beans="[Link] la location de la def du namespace
xmlns:context="[Link]
xmlns:jee="[Link]
xsi:schemaLocation=
"[Link] [Link]
[Link] [Link]
[Link]
[Link]
[Link] [Link]

<jee:remote-slsb
id="myComponent"
jndi-name="java:global/[Link]/[Link]/MyServiceBean"
business-interface="[Link]"/>

</beans:beans>
le nom spring

l’interface du bean JEE

le nom jndi est affiché par le serveur dans ses logs
Injecter un Component dans un
contrôleur
 Méthode classique avec @Inject
@Controller
public class HomeController {

@Inject
protected MyService injectedBean;

/**
* Simply selects the home view to render by returning its name.
*/
@RequestMapping(value = "/", method = [Link])
public String home(Locale locale, Model model) {

// …
if( injectedBean == null ) {
[Link]("The bean is not injected !.");
return "home";
}
// Injection works !
[Link]("myInjectedBean", injectedBean );

return "success";
}
Accéder à un objet JNDI ou EJB
 <jee:jndi-lookup>
 Acces par JNDI
 <jee:local-slsb>
 Acces a un bean local
 <jee:remote-slsb>
 Acces à un bean distant Ou utiliser @Inject ds le bean

<jee:local-slsb
id="myComponent"
jndi-name="java:global/p1.p2/myBean"
business-interface="[Link]"
/>
Accéder à un objet JNDI ou EJB
Autre méthode
 Permet d’utiliser le nom jndi directement dans les
annotations
 A tester

<bean
class="[Link]">
<property name="alwaysUseJndiLookup" value="true" />
</bean>
Atelier
 ateliers 1
 Atelier – Spring et JavaEE
Dependances

<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>