Spring

MVC, IOC, AOP

• Réalisé par:
Mustapha EL-KABOUS
 Qu'est ce que Spring
• Framework pour construire et définir l'infrastructure d'une
application java.

• Conteneur léger, c'est-à-dire une infrastructure similaire à un serveur

d'application J2EE. Il prend donc en charge la gestion de cycle de vie
des objets.

• Le gros avantage par rapport aux serveurs d'application est qu'avec

SPRING, vos classes n'ont pas besoin d'implémenter une quelconque
interface pour être prises en charge par le framework (des EJBs
comme exemple).
 Spring VS Struts
• Le framework Struts ne s'intéresse qu'à la couche web et n'apporte
pas d'outils pour les deux autres couches du 3tier.

• Le framework Spring, apparu plus récemment que Struts, a tout

d'abord été apprécié pour les outils qu'il apportait pour la
construction des architectures 3tier.
• Le concept (IOC) de Spring permet notamment de construire une
architecture 3tier avec des couches indépendantes les unes des
autres.

• Spring apporte des outils pour construire la couche d'accès aux

données grâce à des classes d'intégration de frameworks tels que
Hibernate ou JPA.
 Composant de Spring
Le coeur de Spring Framework 3.0 est composé d'un ensemble d'une
vingtaine de modules qui sont regroupés en plusieurs parties:

• Spring Core Container: regroupe les modules de base pour mettre

en oeuvre le conteneur
• AOP and Instrumentation : permet de mettre en oeuvre l'AOP
• Data Acces/Integration : regroupe les modules d'accès aux
données
• Web : regroupe les modules pour le développement d'applications
web
• Test : propose des fonctionnalités pour les tests automatisés avec
Spring
 Spring IOC
• Le coeur de SPRING et ce qui fait sa très grande force est la mise en
œuvre du design pattern « Inversion Of Control » ou encore «
Dependency Injection »

• L'idée du pattern IOC est très simple, elle consiste, lorsqu'un objet A
a besoin d'un objet B, à déléguer à un objet C la mise en relation de
A avec B.

• Par défaut, SPRING suppose que les fabriques déclarées sont des
fabriques de type « singleton ».
 Spring IOC
Dependency de Spring core IOC (Maven):
</properties>
<spring.version>3.2.5.RELEASE</spring.version>
</properties>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
Spring IOC
 Spring IOC
• Autocablage (autowiring) des beans en spring :
@Autowired

• Sepecification de reference de bean: @Qualifier

@Autowired
@Qualifier(« userbean »)
private User user;

• Autoriser les annotation dans le declaration

<context:annotation-config />
 Spring IOC
Fichier de déclaration des beans Spring-Customer.xml
 Spring IOC
Test Main:
 Spring MVC
• Rappel sur MVC :
MVC : est un patron de conception visant a découper
les applications en couches aux roles distinctes.
• Spring MVC aide à la création d'applications Web
flexibles et faiblement couplés en basant sur le
modèle de conception Modèle-Vue-Contrôleur
• EN JEE:
– les vues sont les pages jsp
– Le controller c’est la servlet
– Le model c’est les JavaBeans
 Spring MVC
• Etapes de fonctionnement de SpringMVC
Quand une requête est envoyée à l'infrastructure Spring MVC la
séquence suivante d'événements se produit:
– Le DispatcherServlet reçoit la première demande.
– Le DispatcherServlet consulte le HandlerMapping et appelle
le contrôleur associé à la demande.
– Le contrôleur traite la demande en appelant les méthodes de service
appropriés et renvoie un objet ModeAndView au DispatcherServlet .
Le ModeAndView objet contient les données de modèle et le nom de la
vue.
– Le DispatcherServlet envoie le nom de la vue à un ViewResolver de
trouver la réelle Voir invoquer.
– Maintenant, le DispatcherServlet passera l'objet de modèle à la vue pour
rendre le résultat.
– La vue à l'aide des données du modèle rendra le résultat à l'utilisateur.
 Spring MVC
Schéma globale de Spring MVC
 Spring MVC
• Mise en œuvre de Hello World en Spring MVC
1. Creation d’un projet Maven Web
Ajouter le dependencys
<!-- Spring MVC framework -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- JSTL -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.1.2</version>
</dependency>
 Configuration de fichier web.xml
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- si on declarre les beans dans un fichier separer -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/action-servlet.xml</param-value>
</context-param>
Création de DispatcherServlet action-servlet.xml
 Création de contrôleur (class java)

@Controller
public class UserController {
@RequestMapping(value="/",method=RequestMethod.GET)
public String getIndex(){
return "index";
}
@RequestMapping(value="/home", method=RequestMethod.GET)
public ModelAndView getHome(){
ModelAndView model=new ModelAndView();
model.addObject("msg", « Hello world »);
model.setViewName("home");
return model;
}
 Création des Vues
Création des vues :
• Index.jsp
• Home.jsp // afficher le contenu de msg

-- Proposition d’une amélioration

Spring IOC et MVC
--Mapping des ressources
<mvc:resources mapping="/js/**"
location="/ressource/js/" />
 Spring AOP + AspectJ Annotation
• Spring AOP: est un module du framework Spring qui permet une
mise en oeuvre d'une partie des fonctionnalités de l'AOP.
• Programmation Orientée Aspect ( AOP ) complète la
programmation orientée objet (POO) en fournissant une autre
façon de penser la structure du programme. En plus des classes,
AOP vous donne aspects .
• Spring AOP: c'est juste un intercepteur à intercepter certains
processus, par exemple, quand une méthode est exécuter, Spring
AOP peut détourner la méthode d'exécution, et d'ajouter des
fonctionnalités supplémentaires avant ou après l'exécution de la
méthode.
• Spring AOP utilise des proxys ce qui ne nécessitent pas d'outils
particulier comme c'est le cas avec AspectJ pour réaliser le
tissage (classloader ou compilateur dédié).
 Spring AOP + AspectJ Annotation
Quelques annotations :
• @Aspect: class d’interseptation des process
• @Before: avant l’exécution de la méthode
• @After: apres l’exécution de la methode
• @ AfterReturning : Exécuter après la méthode
retourne un résultat, d'intercepter le résultat
retourné aussi.
• @ AfterThrowing - Exécuter après la méthode
lève une exception
Spring AOP + AspectJ Annotation
Jars et dépendances:
• Les jars de spring core
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId> <version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId>
<version>1.6.11</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId> <version>1.6.11</version>
</dependency>
Configuration de AspectJ
Création de class de LoggingAspectJ
 Test main
ApplicationContext context =
new ClassPathXmlApplicationContext(new String[] {"Spring-
Customer.xml"});
User user= (User)context.getBean("userbean");
System.out.println(user.sayHello("Mustapha"));
System.out.println("votre nom :"+user.getNom());

• Mais avant,on doit crée une classe User

contient la méthode sayHello