Présentation du

Framework Spring
Spring
 Framework Open Source qui fournit une solution légère
pour la construction de grandes applications Java
 Simplifie et structure les développements
 Favorise les bonnes pratiques
 Utilisation des patrons de conception
 Modularité
 Découplage
 Facilite la mise en œuvre des tests
Historique
 Août 2003 Spring 1.0 M1
 Mars 2004 Spring 1.0
 Septembre 2004 Spring 1.1
 Mai 2005 Spring 1.2
 Octobre 2006 Spring 2.0
 Novembre 2007 Spring 2.5
 Décembre 2009 Spring 3.0
 Décembre 2012 Spring 3.2
 Décembre 2013 Spring 4.0
 Juillet 2015 Spring 4.2
 Juin 2016 Spring 4.3
 Septembre 2017 Spring 5.0
 Octobre 2020 Spring 5.3 ( LTS )
 Novembre 2022 Spring 6
 …
Avantages
 Les applications Spring sont faiblement couplées grâce
à l’injection de dépendance.
 Spring fournit des modèles pour manipuler JDBC,
Hibernate, JPA, etc
il n’y a pas besoin d’écrire trop de code.
 Le test des applications est devenu facile en utilisant
l’injection de dépendance.
 Spring est léger en raison de sa mise en œuvre POJO.
 Spring propose une très bonne intégration avec des
frameworks open source(Struts, Jsf, Hibernate, etc…).
Inconvénients

 Les livrables peuvent avoir une taille importante

à cause de nombreuses librairies requises par Spring et
ses dépendances.
Les modules du framework Spring
 Le framework Spring fournit environ 20 modules qui
peuvent être utilisés sur la base d’une application.
 Dans ce cours, nous allons voir les principaux modules :
Les modules du framework Spring
 Spring Core : le noyau, qui contient à la fois un ensemble de
classes utilisées par toutes les briques du framework et le
conteneur léger.
 Spring AOP : le module de programmation orientée aspect,
qui s’intègre fortement avec AspectJ, un framework de POA à
part entière.
 Spring DAO : qui constitue le socle de l’accès aux dépôts de
données, avec notamment une implémentation pour JDBC.
D’autres modules fournissent des abstractions pour l’accès
aux données (solutions de mapping objet-relationnel, LDAP)
qui suivent les mêmes principes que le support JDBC. La
solution de gestion des transactions de Spring fait aussi partie
de ce module.
Les modules du framework Spring
 Spring ORM : qui propose une intégration avec des outils
populaires de mapping objet-relationnel, tels que Hibernate,
JPA, EclipseLink ou iBatis.
 Spring WEB : le module comprenant le support de Spring
pour les applications Web. Il contient notamment Spring Web
MVC, la solution de Spring pour les applications Web, et
propose une intégration avec de nombreux frameworks Web
et des technologies de vue.
 Spring Context : Ce module supporte l’internationalisation
(I18N), EJB, JMS, Basic Remoting.
Résumé
 Spring est un conteneur dit « léger » qui peut prendre en
charge:
 l’instanciation d’objets et leurs référencements
 la gestion transactionnelle
 une politique de sécurité
 Spring joue aussi un rôle transverse dans l’intégration
 de frameworks d’interface Web
 de Web Services ou micro-services
 de frameworks de persistance
 avec des systèmes externes
 Spring peut faciliter la mise en œuvre de tests
 Spring est peu intrusif
Concepts de Spring
 Les concepts du "conteneur léger" Spring
 "Séparation des préoccupations"
 ( SoC : Separation of Concerns )
 "Inversion de contrôle"
 ( IoC : Inversion of Control )
 "Injection de dépendances"
 ( DI : Dependency Injection )
 Gestion du cycle de vie des objets
 ( Factory, Singleton, ... )
 "Programmation Orientée Aspect"
 ( AOP : Aspect Oriented Programming )
Séparation des préoccupations
 En anglais "Separation Of Concerns" ( SOC )
 Pris isolément, chaque problème est plus facile à traiter
=> séparation en couches, domaines, …
 Principe qui consiste à isoler les différentes
problématiques à traiter, par exemple :
 Présentation ( IHM, ... )
 Services Métiers
 Persistance
 etc...
 Notion de composants spécialisés
Inversion de contrôle
 En anglais "Inversion Of Control" ( IOC )
 Modèle de conception utilisé par de nombreux
frameworks
 Illustré par le "principe d'Hollywood"
 Hollywood principle :
 "Don't call us, we'll call you "
Injection de dépendance
 En anglais "Dependency Injection" ( D.I. )
 Pour pouvoir fonctionner un composant a généralement
besoin d'autres composants ...
 L'injection de dépendance permet de "fabriquer" les
composants et de leur "injecter" automatiquement les
composants nécessaires
Projets connexes
 Spring IO : dépendances cohérentes pour le framework,
construction d’applications
 SpringBoot : kit de développement simplifié
 Spring Cloud : patterns de distribution, implémentation de
micro-services
 Spring Cloud Data Flow : orchestration de micro-services
 Spring Data : couche d’accès aux données (BD
relationelles ou pas, map-reduce…)
 Spring Security : support d’authentification et
d’autorisation
Librairies Spring
 Gérées par dépendances Maven
 Beaucoup de dépendances à placer
 Ou par une seule dépendance à SpringBoot
Première application Spring
Etapes de création
 Pour créer une application Spring, il faut suivre les étapes
suivantes :
 Créer un projet Java,
 Ajouter les bibliothèques nécessaires (jar files) ou transformer
le projet en un projet Maven et ajouter les dépendances
nécessaires
 Créer une classe bean java,
 Créer le ficher “applicationContext.xml”
 Créer une classe pour exécuter notre application.
Créer la classe Cours dans un projet Java
package first.app.spring;

public class Cours {

private int id;
private String libelle;

public Cours(int id, String libelle) {

this.id = id;
this.libelle = libelle;
}

public void afficher() {

System.out.println(id + " " + libelle);
}

}
 Ajout du fichier “applicationContext.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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema
/beans

http://www.springframework.org/schema/beans/spring-
beans-3.0.xsd">

<bean id="c" class="first.app.spring.Cours">

<constructor-arg value="22" type="int"></constructor-arg>
<constructor-arg value="java"
type="String"></constructor-arg>
</bean>

</beans>
Ajout de la classe Main
package first.app.spring;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Main {

public static void main(String[] args) {
Resource r = new ClassPathResource("applicationContext.xml");
BeanFactory fac = new XmlBeanFactory(r);
Cours cours = (Cours)fac.getBean("c");
cours.afficher();
Il Faut ajouter les Jars
//
nécessaires ou convertir le
}
projet en un projet Maven et
} ajouter les dépendances Spring
Core
Ajouter des dépendances externes
Convertir le projet en un MavenProject
Ajouter les dépendances Maven
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-
4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>PremiereSpring</groupId>
<artifactId>PremiereSpring</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
</dependencies>
<build>
Résultat de l’exécution du Main
 L’objet est bien injecté avec les bons paramètres du
constructeur :
 Id : 22
 Libelle : java
Deuxième méthode
public static void main(String[] args) {
Resource r = new ClassPathResource("applicationContext.xml");
BeanFactory fac = new XmlBeanFactory(r);
Cours cours = (Cours) fac.getBean("c");
cours.afficher();

ApplicationContext ctx = new

ClassPathXmlApplicationContext("applicationContext.xml");
cours = (Cours) ctx.getBean("c");
cours.afficher();
}
qui fait recours à la dépendance spring-context :

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
Voir Projet « SpringExamples »
Application
 TD1