Presentation Spring, Spring MVC

Présentation générale du framework Spring Auteur: RICHAND Nathaniel

Spring ?
Présentation générale
Architecture
Spring IOC
IOC?
Spring IOC
Spring MVC
Rappel sur le pattern MVC
Spring MVC
Divers
Web Services : Spring Remoting
Spring DAO et ORM
Autres
Spring IDE pour Eclipse
Bilan

Spring?

Spring est un framework de développement Java basé sur la notion de conteneur léger .
Spring existe depuis 2002 , la dernière version est la 2.5 . Cette version est toujours compatible avec java 1.4 .
Spring est un projet Open Sources de licence Apache dont le support et les évolutions sont réalisées par la société Interface21.
Spring est composé de très nombreuses briques , mais l’on peut utiliser uniquement les parties qui nous intéresse sans se soucier des autres.
Spring met en avant les concepts de
Robustesse,
Extensibilité,
Réutilisabilité.

Spring Core IOC AOP Spring DAO Spring Context Spring Remoting … Spring ORM Spring JDBC Spring Web RMI Web Services … JDO Hibernate … Spring MVC Struts JSF …

Spring IOC
L’IOC n’est pas une lubie , mais un enjeu primordial pour un développement propre et structuré. Inversion Of Control

L’IOC est un Design-Pattern
Remplacement du schéma classique :
Schéma de l’IOC :
Classe A Classe B Dépendance Interface I Classe A Dépendance Classe B

//Un controller qui va utiliser nos classes
public class FormController{
FormulaireInterface form ;
//Standard JavaBean
public void setForm(FormulaireInterface f) {
this.form = f;
}
… .
afficheForm( form .getNomForm());
…
}
+getNomForm() : String +getNomForm() : String FormulaireImpl FormulaireInterface Ceci est plutôt du traitement « métier » Comment se fait le lien entre les deux couches?

Le lien entre les couches métier et contrôle est fait par la définition de « beans » dans Spring :
< beans >
< bean id = "controllerForm" class = "mypackage.FormController" >
< property name = " form " ref = " formulaire " />
</ bean >
< bean id = " formulaire " class = "mypackage.FormulaireImpl" / >
</ beans >
Spring prend en charge la création des objets et réalise les injections de donnés en se servant des « setter » (méthode conseillée).
Les couches sont nettement séparées , sans dépendances , plus facilement maintenable et très facilement testables unitairement.

Spring MVC

MVC est un pattern de conception visant à découper les applications en couches aux rôles distinctes.
En J2EE la vue est classiquement réalisée par des JSP, le controller par une Servlet et le model par un JavaBean.
Schéma récapitulatif :

DispatcherServlet Controller View Model Request Response

<? xml version = "1.0" encoding = "UTF-8" ?>
< web-app 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" version = "2.4" >
< servlet >
< servlet-name > kickstart </ servlet-name >
< servlet-class >
org.springframework.web.servlet.DispatcherServlet
</ servlet-class >
< load-on-startup > 0 </ load-on-startup >
</ servlet >
< servlet-mapping >
< servlet-name > kickstart </ servlet-name >
< url-pattern > *.htm </ url-pattern >
</ servlet-mapping >
</ web-app >

import org.springframework.web.servlet.mvc.SimpleFormController; public class FormController extends SimpleFormController { // Méthode appelée avant l’affichage du formulaire, retourne un bean associé au formulaire protected Object formBackingObject(HttpServletRequest request) { MyBean bean = (MyBean) request.getSession().getAttribute( "myBean" ); if (bean == null ) bean = new MyBean(); return bean; } // Méthode appelée lors du POST du formulaire, reçois le bean associé au formulaire protected ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object springBean, BindException errors) throws Exception { MyBean bean = (MyBean) springBean; request.getSession().setAttribute( "myBean" , bean); return new ModelAndView(); } }

GET POST Retourne une instance de la « command » (JavaBean) associée. Initialisation des binders, convertisseurs des données de la requête. Permets de binder des données complémentaires. Typiquement les contenus de listes déroulantes. Le modèle est exposé et la vue est appelée.

Liste des tags :
• checkbox
• errors
• form
• hidden
• input
• label
• option
• options
• password
• radiobutton
• select
• textarea
La taglib de Spring MVC permet de réaliser automatiquement le binding entre le formulaire HTML et le javaBean adossé.
Exemple :
<html>
< form:form commandName = "myBean" method = "post" >
< form:hidden path = "id" />
< form:input path = "firstName" id = "firstName" />
< form:errors path = "firstName" cssClass = "fieldError" />
<br />
< form:input path = "lastName" id = "lastName" />
< form:errors path = "lastName" cssClass = "fieldError" />
</form:form>
</html>

Handler mapping (mapping requête => controller)
View resolution (sélection de la vue)
Mécanisme de validation et de gestion des erreurs avancés (géré dans le cycle de vie d’une requête)
Binding des données personnalisable. Evite le parsing manuel des données de formulaire.
Support de plusieurs modèle de vue (Velocity, FreeMarker,…)
…

Divers

Spring permet de simplifier la création et l’utilisation de Web Services grâce au module Spring Remoting. Il intègre les deux solutions classiques du marché : Axis et Xfire, en les simplifiant grandement.
Création de Web Services :
Exposition d’un POJO en tant que Web Services
très simple en utilisant Xfire, création de la WSDL
automatique par introspection. Plus besoins de
générer les WSDL et Handler par tâche ANT!
Utilisation de Web Services :
Définition d’un JavaBean comme un client du Web
Services, transparent pour le reste de l’application.
Transformation des exceptions propre à chaque
fournisseur en exceptions génériques.

Spring apporte son aide sur la couche DAO et sur les solutions de mapping objet/relationnel :
en facilitant la création d’une couche DAO grâce à l’inversion de contrôle et à la séparation des couches.
en simplifiant et standardisant l’utilisation des transactions dans la couche d’accès aux données.
en proposant une hiérarchie d’exceptions standardisés . On retrouve ainsi les mêmes exceptions dans les couches supérieures, quelle que soit la technologie de persistance utilisée.
en proposant des classes utilitaire simplifiant considérablement le nombres de lignes de code à produire pour chacune des technologies.

Spring facilite l’intégration de services et d’API tierces, comme :
Tiles ( http://tiles.apache.org ), mécanismes élégant de templates de pages web (Tiles 2 est géré mais requiert Java 5)
Intégration d’ AJAX (DWR, Prototype, Scipt.aculo.us)
...
Spring WebFlow permettant de définir les Flux et les modèles de navigations entre pages.
Spring AOP , permettant de faire simplement de la programmation par aspect. Intégration de AspectJ.
Spring Security (ACEGI)
Spring Batch
… ( http://www.springframework.org/sub-projects )

Aide sur l’écriture de fichiers XML :
AutoComplétion
Vérification structure des fichiers
Contrôle des références et des dépendances
Ajout d’un builder
Affichage sous forme graphique des beans permettant de voir les liens et les dépendances
Un récapitulatif des fonctions est disponible ici :
http://springide.org/project/wiki/SpringideGuide
Beans Graph Beans View

La configuration par XML rend la configuration très verbeuse et difficile à lire sur de grosses applications.
Elements de solutions :
Utiliser la configuration par annotations de Spring 2.5 (nécessite Java 5)
Utiliser les outils d’affichage de graphe de dépendance tel Spring IDE ou BeanDoc (JavaDoc évolué avec les graphes de Spring)
Spring est très ouvert et ne limite pas les comportements :
Pour un même problème il existe parfois une multitude
de solutions différentes, ce qui peut être déroutant.
Même si Spring est devenu un standard « de facto », ce n’est cependant pas une norme comme JSF ou les EJB.
Si Spring facilite l’intégration et l’utilisation de librairies tierces, la compréhension et la connaissance de celles-ci reste nécessaire.

Spring a largement pénétré le monde industriel et jouit d’une communauté importante et dynamique.
Sa prise en main est très facile et très intuitive basée sur le principe « Convention over Configuration »
La documentation est très importante et très bien réalisé : le manuel de référence fait 568 pages et est à jour!
Spring encadre les développements en instaurant les best practices Java et J2EE.
Spring est très modulaire et surtout très peu intrusif , on peut se passer de Spring sur un composant et effectuer la configuration à la main ou avec d’autres outils. On ne se lit pas « ad vitam eternam » à Spring.

Site officiel :
http://springframework.org/
Articles :
http://zekey.developpez.com/articles/spring/
http://www.springhub.com/
http://blog.interface21.com/main/
Forum :
Anglais : http://forum.springframework.org/
Français : Forum developpez.com
Livres :
Spring par la pratique (édition eyrolles)
Spring in action 2 nde édition (édition Manning)

http://www.richand.info	591
http://www.slideshare.net	63
http://s150084531.onlinehome.fr	10
http://static.slideshare.net	1
http://www.google.com	1

Presentation Spring, Spring MVC

by Nathaniel Richand on Nov 19, 2007

Accessibility

Categories

Tags

Upload Details

Usage Rights

5 Embeds 666

Statistics

Presentation Spring, Spring MVC — Presentation Transcript