Spring IO

C d i Dumoulin
Cedric
D
li
Plan
 Bibliographie
 Qu’est‐ce que Spring
Q ’
S i et Spring
S i MVC ?
 Spring container
 Spring MVC
 Installer Spring SPS
 Spring MVC Hello World
Bibliographie
g p
 Spring Framework
 http://docs.spring.io/spring/docs/3.2.5.RELEASE/spring
htt //d
i i / i /d /
RELEASE/ i
‐framework‐reference/htmlsingle/#overview
 http://docs.spring.io/spring/docs/4.2.3.RELEASE/spring
http://docs spring io/spring/docs/4 2 3 RELEASE/spring
‐framework‐reference/html/
 Designing and Implementing a Web Application with Spring
 http://spring.io/guides/tutorials/web/
http://spring io/guides/tutorials/web/
Bibliographie
g p
 Spring IO
 http://spring.io/
p // p g /
 Developing a Spring Framework MVC application step‐by‐step (2.5)
 http://docs.spring.io/docs/Spring‐MVC‐step‐by‐step/
http://docs spring io/docs/Spring MVC step by step/
 Spring MVC Framework Tutorial
 http://www.tutorialspoint.com/spring/spring_web_mvc_fra
p
p
p g p g
mework.htm
 Wikipedia
 http://en.wikipedia.org/wiki/Spring_Framework
http://en wikipedia org/wiki/Spring Framework
 Quick start
 http://projects.spring.io/spring‐framework/#quick‐start
Bibliographie
 Spring 3.x tutorials
 http://www.roseindia.net/spring/spring3/index.shtml
htt //
i di
t/ i / i
/i d
ht l
 http://yannart.developpez.com/java/spring/tutoriel/
 http://www.theserverside.com/tutorial/Spring‐30‐
h
//
h
id
/
i l/S i
Tutorial‐Setting‐Up‐Configuring‐The‐Environment
 Spring
S i 4.x tutorials
t t i l
 http://crunchify.com/simplest‐spring‐mvc‐hello‐world‐
example tutorial spring model view controller tips/
example‐tutorial‐spring‐model‐view‐controller‐tips/
 http://www.tutorialspoint.com/spring/spring_web_mvc
_framework.htm
framework htm
Guides
 Accessing Data with JPA
 http://spring.io/guides/gs/accessing‐data‐jpa/
htt // i i / id / /
i d t j /
 Designing and Implementing a Web Application with Spring
ith S i
 http://spring.io/guides/tutorials/web/
Q
Qu’est‐ce que Spring
q
p g
 Un Framework  Constitué de caractéristiques organisées en 20 modules
C
tit é d té i ti
i é d l
Core Container
 Fournit les mécanismes :
 d’inversion de contrôle
d’i
i d t ôl
 D’injection
 De fabrique d’objets (BeanFactory) D f b i
d’ bj (B
F
) Web
 Web
 Fournit les fonctionalité web de base
 Sevlet
 Fournit Spring MVC
 Permet de séparer le model Domaine et les pages web
 Struts
 Integration Struts 1. Deprecated (utiliser Struts‐Spring integration
 Portlet
 Pour un environement avec des Portlet
Test
 Pour les test avec Junit et TestNG
Scénarios d’utilisation
Scénarios d’utilisation
 Custom business logic  can be implemented with simple POJOs  and managed by Spring's IoC container
 Transactions
 Managed by container (like in EJB container)
 Additional services
 email and  validation
 ORM support 
integrated with JPA, Hibernate, JDO and iBatis
 Form controllers
Obtenir les librairies
 Maven (préféré)
 Créer un projet web dynamic
 Le transformer en projet Maven

Click droit‐>configure‐>convert to Maven Project
 Ajouter les dépendances vers Maven
j
p
 Voir http://crunchify.com/simplest‐spring‐mvc‐hello‐world‐
example‐tutorial‐spring‐model‐view‐controller‐tips/
 SPS ‐ Spring Tool Suite
 Permet de créer un projet pré‐initialisé
pré
initialisé
<dependencies>
<dependency>
<groupId>org springframework</groupId>
<groupId>org.springframework</groupId>
<artifactId>spring‐context</artifactId>
<version>4.1.1.RELEASE</version>
<scope>runtime</scope>
</dependency>
</dependencies>
R t
Retour sur le modèle MVC
l
dèl MVC
Une application 3tier classique: Une application 3tier avec MVC:
La vision de SpringMVC
La vision de SpringMVC
La org.springframework.web.servlet.DispatcherServlet
g p g
p
est le point d’entrée p
générique qui délègue les requêtes à des Controller
Un org.springframework.web.servlet.mvc.Controller prend en charge une requête, et utilise la couche métier pour y répondre.
et utilise la couche métier pour y répondre
Un Controller fabrique un modèle sous la forme d’une java.util.Map contenant les
éléments de la réponse.
Un Controller
C
ll choisit une org.springframework.web.servlet.View
h i i i f
k
b
l
i
qui sera i paramétrée par la Map pour donner la page qui sera affichée. Traitement type d’une
Traitement type d
une requête
requête
Pour faire fonctionner Spring
Pour
faire fonctionner Spring MVC, MVC
il faut :
 Front Controler
  servlet DispatcherServlet
 Déclaration dans web.xml
l
d
b
l
 Controllers
 Ce sont des POJO annotés @Controller
 Des vues
 Choix possible de la technologie
 Ex: jsp
 Un mapping request  Controller
 Un mapping nom_logique_de_vue => implementation_de_la_vue
 Des objets métiers
j
 Objet Spring
 Ou Objets JEE
Ateliers
 Vous allez essayer 2 méthodes pour créer un projet MVC Spring
p g ((sujet complet dans atelier1.pdf)
j
p
p )
 Méthode 1
 Créer un projet web dynamique et installer les dépendances avec Maven
 Méthode 2
 Installer Spring Tool Suite –
Suite STS
 Créer un projet MVC HelloWorld
 Spring Project ‐> Spring MVC Project
 Laquelle préférez‐vous ?
Le « Front Controller »
 Il est chargé de traiter les requêtes de l’extérieur
 Il analyse l
Il analyse l’url
url, et appelle le contrôleur correspondant
et appelle le contrôleur correspondant
 Le contrôleur renvoie un modèle et le nom logique de la p g
page servant à construire la page
p g
 Le front contrôleur appelle la page demandée
 La page construit la réponse
 Le front contrôleur renvoie la réponse
Implémentation
Implémentation du Front Controller
 C’est un servlet
 Déclaré dans META‐INF/web.xml
Dé l é d META INF/ b
l
Le servlet
<servlet>
<servlet‐name>appServlet</servlet‐name>
<servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
<init‐param>
<param name>contextConfigLocation</param name>
<param‐name>contextConfigLocation</param‐name>
<param‐value>/WEB‐INF/spring/appServlet/servlet‐context.xml</param‐value>
</init‐param>
<load‐on‐startup>1</load‐on‐startup>
Le fichier de </servlet>
<servlet‐mapping>
<servlet‐name>appServlet</servlet‐name>
<url pattern>/</url pattern>
<url‐pattern>/</url‐pattern>
</servlet‐mapping>
configuration de Spring
Le nom et les urls
traitées par le servlet
La configuration de Spring
g
p g
<?xml version="1.0" encoding="UTF‐8"?>
g
<beans:beans
<!‐‐ DispatcherServlet Context: defines this servlet's request‐processing infrastructure ‐‐>
Indique d’interpreter
d
interpreter les annotations
<!‐‐ Enables the Spring MVC @Controller programming model ‐‐>
<annotation‐driven />
<!‐‐ Resolves views selected for rendering by @Controllers to g y @
.jsp resources in the /WEB‐INF/views directory ‐‐>
<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<beans:property name="prefix" value="/WEB‐INF/views/" />
Spécifie le mapping
<beans:property
p p
y name="suffix" value=".jsp" />
ff
j p
nom logique => l
</beans:bean>
<context:component‐scan base‐package="ipint13.spring.tuto" />
</beans:beans>
 Fichier [servletName]-context.xml
vues
Chemin des classes annotées a scanner
Rôle d’un contrôleur
 Un contrôleur sert à traiter une requête http
 http://monserveur/monappli/unepage?name=jule
htt //
/
li/
?
j l
 Spring permet  de mapper l’url de la requête avec une méthode d’un d
l’ l d l
h d d’
contrôleur
 De mapper les paramètres de la requête avec les D l èt d l êt l arguments de la méthode
 De mapper des objets du contexte de la requête avec les arguments de la méthode
Controller simple
p
Déclare un contrôleur
@Controller
public class GreetingController {
L’url associée a ce ctrl
M
Mapping
i paramètre url => èt l @RequestMapping("/greeting")
argument
g
public String greeting(
@RequestParam(value="name", required=false, defaultValue="World") String name, Model model) {
Model model) {
model.addAttribute("name", name);
return "greeting";
Le model qui sera passé à la }
page
}
Un attribut qui sera passé à la page
p
g
Nom logique de la page
Controller
Spécifie le type de requete
q
/**
* Simply selects the home view to render by returning its name.
*/
Demande l’objet Locale
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home(Locale locale, Model model) {
logger.info("Welcome home! The client locale is {}.", locale);
(
)
Date date = new Date();
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
(
)
String formattedDate = dateFormat.format(date);
model.addAttribute("serverTime", formattedDate
d l dd
ib
("
i " f
d
)
);
return "home";
}
Controller
 Peut contenir plusieurs méthodes avec différentes URL
L
Les paramètres des méthodes sont «
è
d é h d libre
lib »
 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.
Atelier
 Contrôleur : Récupérer un paramètre de l'URL
Technologies supportées
g
pp
 Spring permet différente technologie pour les vues:
 Struts, Tiles
St t Til
 Tapestry
 JSP
Spring
p g et JSP
 JSP sert de template à la réponse renvoyé par le front controlleur
 Les données viennent des modèles renvoyé par le controlleur
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>
< t >
<html>
<head>
<title>Getting Started: Serving Web Content</title>
<meta http‐equiv="Content‐Type" content="text/html; charset=UTF‐8" />
</head>
/
Remplacé par la valeur <body>
<p/>
trouvé dans le modèle
Hello again ${name} !
</body>
/
y
</html>
Mapping
pp g nom logique => vues
gq
 Les vues sont séparées des contrôleurs
 Un contrôleur spécifie le nom logique de la vue qui U ôl é ifi l l i
d l i doit être utilisée
 Il peut envoyer une vue différente en fonction du résultat Il diffé
f
i d é l (ok, cancel, …)
 Un mapper se charge de mapper les noms logiques U h
d l l i
vers les noms physiques
Déclaré dans le fichier de config [nom]_config.xml
Déclaré dans le fichier de config [nom]
config ml
Ex: <!‐‐ 
<!
Resolves views selected for rendering by @Controllers to
Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB‐INF/views directory ‐‐>
<beans:bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<beans:property name="prefix" value="/WEB‐INF/views/" />
<beans:property name=
name "suffix"
suffix value=
value ".jsp
jsp" />
/>
</beans:bean>
Où placer les vues ?
p
 Dans un répertoire sous WEB INF
WEB‐INF
Atelier
 Utiliser plusieurs vues
L’entéte
 views/contact.jsp
<%@ page language="java" contentType="text/html; charset=ISO‐8859‐1"
pageEncoding="ISO‐8859‐1"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<html>
<head>
<title>Spring 3 MVC Series ‐ Contact Manager</title>
</head>
<body>
<h2>Contact Manager</h2>
<h2>Contact Manager</h2>
…
Le form
Le form
L’url où la requête est L
url où la requête est envoyée
y
<form:form method="post" action="addContact.html">
<table>
<tr>
<td><form:label path="firstname">First Name</form:label></td>
<td><form:input path="firstname" /></td>
</tr>
<tr>
t
<td><form:label path="lastname">Last Name</form:label></td>
<td><form:input path="lastname" /></td>
</tr>
<tr>
<td><form:label path="lastname">Email</form:label></td>
<td><form:input path="email" /></td>
</tr>
<tr>
<td><form:label path=
path="lastname">Telephone</form:label></td>
lastname >Telephone</form:label></td>
<td><form:input path="telephone" /></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Add Contact"/>
i
t t
" b it"
l
"Add C t t"/
</td>
</tr>
</table>
</form:form>
</body>
</html>
Le nom d un attribut Le nom d’un attribut dans l’objet ‘command’
j
Le contrôleur
@Controller
@SessionAttributes
public class ContactController {
L’url où la requête est envoyée
y
L’url où la requête est envoyée
y
@RequestMapping(value = "/addContact.html", method = RequestMethod.POST)
public String addContact(@ModelAttribute("contact")
Contact contact, BindingResult result, Model model) {
System.out.println("First Name:" + contact.getFirstname() +
"Last Name:" + contact.getLastname());
contact.setEmail(contact.getFirstname() + "." + contact.getLastname());
model.addAttribute("command", contact);
(
,
);
return "contact";
// return "redirect:contacts.html";
}
@RequestMapping("/contacts.html")
public ModelAndView showContacts() {
Pour connaitre les erreurs lors du Bind
On peut demander des redirection vers une URL
return new ModelAndView("contact", "command", new Contact("name", "lastname"));
}
}
L’objet passé entre le ctrl et le form
j p
 Classe POJO
public class Contact {
private String firstname;
private String lastname;
private String email;
private String telephone;
// Getter and setters …
}
@ModelAttribute sur les les
p
parametres
 An @ModelAttribute on a method argument indicates the argument should be retrieved from the model. the argument should be retrieved from the model
 If not present in the model, the argument should be instantiated first and then added to the model instantiated first and then added to the model.  Once present in the model, the argument’s fields should be populated from all request parameters that have matching names.  This is known as data binding in Spring MVC, a very Thi i k
d t bi di i S i MVC useful mechanism that saves you from having to parse each form field individually.
each form field individually
Comment initialiser un objet dans Comment
initialiser un objet dans
le model
 Utiliser @ModelAttribute sur une méthode
/**
* Initialize attribute in the model.
* Use default name 'contact' (name of the returned type).
* @return
*/
@ModelAttribute
public Contact initContact() {
Contact contact = new Contact();
contact.setFirstname("set firstname");
contact.setLastname("set lastname");
(
)
return contact;
}
Atelier
 Formulaire simple
Le cœur de l’environnement Spring est un « conteneur léger »
Un conteneur léger sert à contenir un ensemble d’objets instanciés et initialisés, formant un contexte initial (ou une hiérarchie de contextes) pour une application.
Ce contexte initial est souvent construit à partir d’une description
externe (xml) décrivant les objets à créer, les valeurs initiales et les
( l) dé i
l bj à é l l
i i i l l
dépendances entre objets.
Les dépendances (liens) entre objets sont automatiquement créées à partir de la description (on parle d’injection de dépendances) et non par les objets eux‐mêmes par programmation. l
b
C’est le Design Pattern de l’Inversion du Contrôle : IoC
g
Exemple simplifié:
Avec les classes:
class Personne { String nom; Voiture car; }
class Voiture {String nom;}
et la description de contexte Spring (servlet-context.xml):
<beans:beans>
<beans:bean id="user" class="ipint14.spring.helloworld.bean.Person">
<beans:property name="name" value=" ean"/>
<beans:property name= "car" ref= "vehicule"/>
</beans:bean>
<beans:bean id="vehicule" class="ipint14.spring.helloworld.bean.Car">
<beans:property name="name" value="megane"/>
</beans:bean>
</beans:beans>
Le contexte initial de l application dans le conteneur SPRING sera:
Le contexte initial de l’application dans le conteneur SPRING sera:
Personne
user
nom:jean
j
car:
Voiture
nom:megane
vehicule
Injecter un Bean dans une classe
j
@Controller
public class HomeController {
@Inject
protected Person person;
...
}
SpringMVC est un framework de présentation, pour application WEB, suivant le modèle MVC, et fondé sur le conteneur léger de SPRING
Dans le cas de SpringMVC le conteneur va servir à créer:
p g
‐Le contexte de l’application Web
‐Les objets traitant les requêtes (Controller)
‐Les objets créant les pages HTML (View)
‐Les objets données des formulaires (Command)
‐Les liens avec les couches métiers et BD
‐Et pleins d’autres
‐Le mapping des URL vers les contrôleurs
‐Le mapping des vues , etc.
L’inversion du contrôle permet ensuite de changer le comportement
de l’application, en modifiant la description xml du conteneur, sans changer les éléments programmés!
g
p g
Atelier
 Créer des Beans
SPS ‐ Spring
p g Tool Suite
 Plugins Eclipse pour le développement avec Spring
 http://spring.io/tools/sts/all
htt // i i /t l / t / ll
 Installation
 Par le marketplace
l
k l
 Ou all‐in‐one distribution  Ou Update zip
 Ou Update site (pour ajouter dans une application existante).
i
)
Instalation par le marketplace
p
p
 Choisir le plugin correspondant à votre version d’Eclipse
Instalation par updatesite
p
p
 http://spring.io/tools/sts/all
 Choisir le updatesite
correspondant à votre d t à t version d’Eclipse
Installer un exemple avec STS
p
 File ‐> New ‐> Import Spring
Getting Started Content
 Installe aussi les jars necessaire
I
ll i l j i
à la compilation et l’execution
 Ce sert de Maven
C d M
  les jar sont dans .m2
 http://spring.io/guides/gs/sts/
Exécuter un exemple
p
 Construire le jar et le lancer :
clean package && java ‐jar target/gs‐serving‐web‐content‐0
 mvn clean package && java ‐jar target/gs‐serving‐web‐content‐0.1.0.jar
clean package && java jar target/gs serving web content 00.1.0.jar
1 0 jar
 Notes:
 Ce n
Ce n’est pas un war
est pas un war 
 Le jar contient un serveur embarqué

Projet ‘boot’
Projet boot
 Certain fichiers de base manquent (web.xml, …)

Ils sont déduits des classes et annotations
 Approche non recommandé pour la production (et même pour le développement).
p
pp
)
Convertir un projet Convertir
un projet ‘boot
boot ’
en war
apply
apply
 http://spring.io/guides/gs/convert‐ apply
apply
jar‐to‐war/
apply
 Modifier le build.gradle
 Ajouter apply plugin: 'war‘
 Modifier jar en war
j
 Ajouter la classe  HelloWebXml extends
SpringBootServletInitializer
 ./gradlew
/gradlew clean build
 Vous obtenez un war
 Déployer le war dans votre serveur
plugin: 'java'
plugin: 'eclipse'
plugin: eclipse
plugin: 'idea'
plugin: 'spring‐boot'
plugin: 'war'
plugin: war
war {
baseName = 'gs‐serving‐web‐content'
version = '0.1.0'
}
hello/HelloWebXml.java
/
j
package hello;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.SpringBootServletInitializer;
public class HelloWebXml extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder
configure(SpringApplicationBuilder application) {
return
t
application.sources(Application.class);
li ti
(A li ti
l
)
}
}
Créer un nouveau projet
p j
 New ‐>Other‐>Spring‐>Spring Project
 Choisir Spring MVC Project
 Utiliser le même nom pour le nom de projet et le Utiliser le même nom pour le nom de projet et le ‘top level
top level package
package’
Nouveau projet
p j
 Ce projet peut être compilé sous Eclipse.
 Il peut être déployé dans Glassfish
Il ê dé l é d Gl fi h
Spring
p g MVC
Gradle
 Outils similaire a Maven
 Chaque exemple de Spring
Ch
l d S i vient avec un bin
i bi
permettant de lancer gradle
  ouvrir une console
i l
 ./gradlew clean build


Charge les jar gradle
Ch
l j dl
Execute build.gradle