Sprnig - Boot

Pr. Y. EL GHAYAM
 Plan
●
Introduction
●
Définition
●
Spring IoC
✔
IoC
✔
IoC avec Spring

Spring MVC

Spring Data

Spring Boot
Introduction

• Produit Informatique
Une solution répondant à un besoin particulier dans un future proche. Exprimé
dans un cahier des charges.
✔ Contraint par une durée de réalisation.
✔ Respecte une démarche de réalisation (cycle en V, méthode agile) et soumis
à une planification : étape – période.
✔ Critiqué selon plusieurs contraintes de qualité.
✔ Besoin d’amélioration
✔ Limité par un budget.
✔ Application Web : cas typique d’un produit informatique.
Introduction
• Exigences d’un produit Informatique
✔ Exigences Fonctionnelles
➢ Satisfaire les besoins fonctionnels (métier) de l’entreprise : exprimés par les cas
d’utilisation dans un diagramme de use cases,
✔ Exigences Techniques
➢ Performances
 Temps de réponse
 Problème de montée en charge : une architecture distribuée scalable
 Tolérances aux panes

➢ Maintenance : l’application doit être facile à maintenir

 Une application doit être pouvoir évoluer dans le temps
 L’application doit être fermée à la modification et ouverte à l’extension

➢ Sécurité : L’application doit prévoir des solutions pour toutes les failles de sécurités
➢ Persistances des données dans des SGBD appropriés : Gestion des Transactions
➢ Exigences financières : Le coût du logiciel doit respecter les contraintes budgétaires
Définition
 Spring est un framework open source à base de Java qui fournit une infrastructure transparente et
compréhensive pour développer des applications d’entreprise.
✔ Entreprise : assurer les différentes taches des différents intervenants d’une entreprise tout en couvrant les
différents aspects d’une application : sécurité, portabilité, scalabilité, accessibilité, manageabilité, …
✔ Le développeur se concentre plus sur la logique métier de l’application plutôt que sur la configuration de
l’application.
✔ Toutes les configurations, à base de fichier XML ou à base de Java sont manipulées par le framework de
Spring.
● Considéré comme une technologie alternative d’EJB (Entreprise Java Bean). Spring est plus simple et plus
léger.
✔ EJB définit des objets -beans- dépendant du framework : un framework lourd.

● Spring utilise le modèle de programmation POJO (Plain Old Java Object).

✔ Une classe est définie par des attributs, un ou plusieurs constructeurs et des setters et getters.

✔ N’hérite d’aucune classe et n’implémente aucune interface du framework et n’a pas besoin de créer aucune
méthode callback.
✔ Facile à utiliser entre les couches et à transférer à travers le réseau.

✔ Facile à tester.

==> Un framework léger.

Définition
 Spring se base sur un conteneur -container- qui ne dépend pas de ses propres API.
✔ N’a pas besoin d’être délpoyé dans un serveur purement JEE.

 Un conteneur est principalement responsable de fournir les services suivants :

✔ Gestion de cycle de vie des objets,

✔ Résolution de dépendance,

✔ Configuration de l’application.

 En plus, un conteneur devrait fournir aussi ces services :

✔ Gestion des transactions,

✔ Sécurité,

✔ Gestion des threads,

✔ Pooling des objets et des ressources,

✔ Accès distant des composants,

✔ Extensibilité et personnalisation du conteneur.

Définition

 Le coeur du framework est le conteneur IoC (Inversion of Control)

✔ Permet de rassembler les différentes parties d’une application en assurant une cohérente architecture.

✔ Lier entre les objets d’une application et gérer leurs cycles de vie.

✔ Les composants dépendants ne sont pas créés par l’opérateur new. Les composants sont injectés par le

conteneur au momemt de l’exécution.

 Se base sur un ensemble de designs patterns : Injection de dépendance (DI), Proxy, ..

 Utilise la programmation orientée aspect AOP (Aspect-Oriented Programming),

Architecture
 Spring est composé de plusieurs modules.
✔ Permet d’utiliser les modules selon le besoin.

Regroupés selon :
 Web : fournir un support pour la création des
applications web. se base sur d’autres modules (AOP,
Core, Context, ..)
 Data Access : essentiellement assure la communication
avec la base des données.
 AOP : permet une programmation orientée aspect.
Facilite largement l’intégration des fonctionalités tel
que la gestion d’accès dans un projet Spring.
 Spring Core : assure l’inversion de controle (IoC) et la
l’injection des dépendances (DI).
 Test : permet les tests unitaires avec Junit.
Inversion de controle (IoC)
Couplage fort et couplage faible
 Couplage fort : Une classe A est liée à une classe B : la classe
A est fortement couplée à la classe B.
La classe A ne peut fonctionner qu’en présence de la classe B.
✔ S’il y a une nouvelle version de la classe B
==> obligé de modifier la classe A.
class A{
private B b;
...
public A(B b) { this.b = b;} class B{
public double calcul() { ...
return [Link](); public double getValue() { ...}
} }
}

public static void main(...) { class B2{

... ...
B b = new B(); public double getValue() { ...}
A a = new A(b); }
}
Inversion de controle (IoC) interface IB {
public double getValue();
}
Couplage fort et couplage faible
class BImpl implements IB {
 Couplage faible : peut être réalisé en se basant sur les public double getValue(){ ...}
}
interfaces.
 On définit une interface IB implémentée par la classe B. La
classe A est liée à l’interface IB : class AImpl {
✔ la classe A est faiblement couplée à la classe B. private IB b;
...
== >La classe A peut fonctionner avec n’importe quelle classe public A(IB b) { this.b = b;}
qui implémente l’interface IB. public double calcul() {
return [Link]();
}
}

public static void main(...) {

IB b = new Bimpl(); // new BImpl2();
A a = new A(b);
}
Inversion de controle (IoC)
Couplage fort et couplage faible

 L’exécution du programme dépend toujours de B.

✔ Il s’agit d’une instanciation statique.
✔ Le changement de B implique la modification du public static void main(...) {
programme. IB b = new BImpl(); // new BImpl2();
A a = new A(b);
 Instatiation dynamique : Rendre la responsabilité de }
chargement des classes à un composant externe.
 Cas d’un projet java basique :
public static void main(...) {
✔ Mettre B dans un fichier de configuration. Scanner scanner=
new Scanner(new File("[Link]"));
✔ Charger la version de B par [Link](BImpl). String BImpl=[Link]();
== > Instantiation dynamique : Inversion de controle. Class Classe_BImpl=[Link](BImpl);
IB ib= (IB) Classe_Bimpl.newInstance();

A a = new A(ib);
}
}
Inversion de controle (IoC)
Définition

 Un principe de conception qui vise à déléguer la responsabilité de la création et de la manipulation - le controle -

des objets à un autre composant en dehors de ces objets eux même.
✔ Rendre la dépendance entre les objets plus flexible : un couplage plus faible
== > le projet devient plus extensiblse, maintenables et tesable.
✔ Le développeur s’occupe seulement de son propre traitement.
 IoC est aussi connu -réalisé- par l’Injection de dépemdance (ID).
 Pratiquement l’IoC est implémentée en se basant sur plusieurs patrons de conceptions (design patterns).
Inversion de controle (IoC)
IoC en Spring
 Spring implémente l’IoC en adoptant Spring IoC Container.
 IoC Container est le composant qui est responsable de gérer les objets.
✔ Instancier, configurer et assembler les beans.
✔ Représenté par l’interface ApplicationContext :
✔ BeanFactory est l’interface de base de ApplicationContext. Fournit les fonctionnalités de base.
 Le conteneur reçoit les instructions sur les objets à manipuler à partir des données de configuration -meta données-.
 Le conteneur est instantié par :
✔ ApplicationContext contexte = new ClassPathXmlApplicationContext("[Link]", “[Link]”);
✔ Charge la configuration à partir d’un fichier XML. Le fichier est récupéré depuis le CLASSPATH.

✔ ApplicationContext contexte = new FileSystemXmlApplicationContext("c:/../[Link]");

✔ Charge la configuration depuis un chemin absolu.

 Les données de configurations sont définies dans :

✔ Un fichier de configuration XML.
✔ Des annotations (Spring 2.5).
✔ Le code Java (Spring 3.0).
Inversion de controle (IoC)
IoC en Spring
Inversion de controle (IoC)
Configuration à base d’un fichier XML
 C’est la configuration par défaut.
 Tous les beans sont inclus dans la balise englobante <beans/>.
 Chaque bean est déclaré dans une balise <bean/>.
 Un bean est identifié par son id dans l’application qui represénte un objet de la classe indiquée par l’attribut class.
 La structure de base d’une configuration à base de XML :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
 Utiliser le conteneur : xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
utiliser getBean pour récupérer [Link]
les instances. <bean id=" " class=" ">
<!-- collaborators and configuration for this bean go here -->
</bean>
ApplicationContext contexte = <bean id=" " class=" ">
new ClassPathXmlApplicationContext <!-- collaborators and configuration for this bean go here -->
("[Link]"); </bean>
<!-- more bean definitions go here -->
UnBean bean = </beans>
[Link]("beanID",
[Link]);
 package x.y;
Inversion de controle (IoC) public class ThingOne {
...
public ThingOne(ThingTwo thingTwo,
ThingThree thingThree, int a, String b) {
Fichier XML : DI par le constructeur // ...
}
}
 Un constructeur avec des arguments, chaque argument <beans>
<bean id="beanOne" class="[Link]">
représente une dépendance. <constructor-arg ref="beanTwo"/>
 Utiliser <constructor-arg ref=".."/> dans une <bean/>. <constructor-arg ref="beanThree"/>
<constructor-arg type="int" value="75"/>
 Pour des arguments de types primitifs on on utilise <constructor-arg type="[Link]"
value="42"/>
l’attribut type. </bean>
<bean id="beanTwo" class="[Link]"/>
 On peut utiliser l’attribut index pour se baser sur la <bean id="beanThree" class="[Link]"/>
position de l’argument. Les indices commencent par 0. </beans>
<beans>
<bean id="beanOne" class="[Link]">
<constructor-arg>
<ref bean="beanTwo"/>
<constructor-arg>
<constructor-arg ref="beanThree"/>
<constructor-arg index="2" value="75"/>
<constructor-arg type="int" value="1"/>
</bean>
<bean id="beanTwo" class="[Link]"/>
<bean id="beanThree" class="[Link]"/>
</beans>
 public class ExampleBean {
Inversion de controle (IoC) private AnotherBean beanOne;
private YetAnotherBean beanTwo;
private int i;
Fichier XML : DI par les setters public void setBeanOne(AnotherBean beanOne) {
[Link] = beanOne;
}
 Exige un constructeur sans paramètres.
public void setBeanTwo(YetAnotherBean beanTwo) {
 Utiliser <property name=”..” ref=” ..”> dans un [Link] = beanTwo;
}
<bean/>
public void setIntegerProperty(int i) {
 Plus pratique dans une dépendance circulaire. this.i = i;
}
}

<bean id="exampleBean" class="ExampleBean">

<property name="beanOne">
<ref bean="anotherBean"/>
</property>

<pro an"/>
<property name="integerProperty" value="1"/>
</bean>

<bean id="anotherExampleBean" class="[Link]"/>

<bean id="yetAnotherBean" class="[Link]"/>
 Inversion de controle (IoC)
Fichier XML : DI par les setters

Beans internes
public class OuterClass {
 Le bean interne représente une classe qui définit ses private InnerClass innerClass;
propres dépendances. public void setInnerClass(InnerClass inner) {
✔ N’a pas besoin de ID. [Link] = inner;
}
✔ Créé comme un objet anonyme.
}
✔ Sa portée dépend de la portée du bean principal.
<bean id="outer" class="OuterClass"> public class InnerClass {
<property name="innerClass"> private String name;
<bean class="InnerClaas"> <!-- inner bean --> private int age;
<property name="name" value="Fiona Apple"/>
<property name="age" value="25"/> public void setName(String name) {
</bean> [Link] = name;
</property> }
</bean>
public void setIntegerProperty(int age) {
[Link] = age;
}
}
Inversion de controle (IoC)
Fichier XML : DI par les setters

depends-on
 Exprimé pour forcer l’initialisation d’un ou plusieurs
beans.
✔ Demander au conteneur de charger les beans
indiqués dans depends-on.
✔ Utile pour définir le moment d’initialisation des
objets.
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
<property name="manager" ref="manager" />
</bean>

<bean id="manager" class="ManagerBean" />

<bean id="accountDao" class="[Link]" />
Inversion de controle (IoC)
Fichier XML : init-method, destroy

 init-method indique une méthode d’initialisation au

moment de l’initialisation de l’objet.
 destroy-method permet au conteneur de faire appel à une
méthode au moment de sa destruction. public class ExampleBean {
public void init() {
// do some initialization work
}
}

<bean id="exampleInitBean" class="[Link]" init-method="init"/>

public class ExampleBean {

public void cleanup() {

// do some destruction work (like releasing pooled connections)
}
}

<bean id="exampleInitBean" class="[Link]" destroy-method="cleanup"/>

Inversion de controle (IoC)
Bean
 Exprimé en POJO, représente les objets créés et gérés par le
conteneur.
 Peut avoir un identifiant. Dans une configuration à base de <bean id="accountDao" class="[Link]"/>
XML l’attribut id est utilisé.
✔ L’identifiant d’un bean peut être aussi défini en utilisant @Component("accountDao")
l’attribut name. Utilisé pour définir plusieurs noms. public class AccountDaoImpl implements
AccountDao {
Considérés comme des alias. //...
}
✔ Un bean peut supporter un autre nom dans un deuxième
fichier XML.
✔ l’attribut class indique le nom complet d’appartenance : @Configuration
public class BeanConfiguration {
package. @Bean(name={"accountDao,accountDaoInMemory"})
public AccountDao foo() {
 Dans une configuration à base d’une annotation on utilise AccountDaoInMemoryImpl bean =
@Component en indiquant le nom de bean. ``````````new AccountDaoInMemoryImpl();
//...
 Dans une configuration à base de Java on utilise @Bean. }

✔ Détient un attribut name qui supporte plusieurs valeurs.

Inversion de controle (IoC)
Portée des beans (scope)
 Un bean est considéré comme une recette pour créer
des objets de la classe défini par ce bean.
✔ Permet de créer plusieurs instances d’un même bean.
 La portée des objets créés par les beans peut être <bean id="account" class="[Link]" scope="singleton"/>
controlée au niveau de la définition de bean :
 Singleton : par défaut. Une seule instance créée est
partagée entre toutes les références à ce même bean.
✔ Une seule instancce créé par conteneur.
✔ Mis en cache.
✔ Utilisé pour des beans stateless.
✔ Différent du pattern Singleton : un seul objet
créé par ClassLoader.
✔ Une connexion à une base de données est un
exemple typique pour un bean singleton.
Inversion de controle (IoC)
Portée des beans (scope)
 Prototype : le bean est créé à chaque référence. <bean id="account" class="[Link]" scope="prototype"/>

 Le conteneur ne gère pas la destruction des objets de

ces beans.
✔ Devrait être géré par le client.
✔ Utiliser l’interface BeanPostProcessor pour
controler sa destruction.
 Utilisé pour des beans statefull.
 Les portées de type requête, Session et Application
sont utilisées pour le web.
Inversion de controle (IoC)
Chargement des beans

 Par défaut les beans singleton sont initialisés dès la création

du conteneur.
✔ Utile pour découvrir les erreurs de configuration.
 Certains beans sont couteux au chargement : on utilise
lazy-init
✔ Chargé à la demande.
<bean id="lazy" class="[Link]" lazy-init="true"/>
<bean name="[Link]" class="[Link]"/>
 TP 2
Refaire le TP 1 en intégrant Spring.
Inversion de controle (IoC)
Annotations

 Mettre des indications sur le même fichier de définition de la

classe pour exprimer les dépendances des objets:
 Exige d’inclure, au besoin, une balise de context dans le fichier de
configuration XML : <context:annotation-config/>

 Les principales annotations : <?xml version="1.0" encoding="UTF-8"?>

✔ @Required <beans xmlns="[Link]
xmlns:xsi="[Link]
✔ @Autowired xmlns:context="[Link]
xsi:schemaLocation="[Link]
✔ @Qualifier [Link]
[Link]
[Link]
[Link]">
<context:annotation-config/>
</beans>
 import [Link];

Inversion de controle (IoC) public class Student {

private int age;
private String name;
@Required
Annotations : @Required public void setAge(int age) {
[Link] = age;
}
public Integer getAge() {
return age;
 Appliquée sur les méthodes setters d’un bean. }
@Required
 Oblige l’injection à base d’un setter au moment de public void setName(String name) {
la configuration. [Link] = name;
}
 Indique que la valeur de la propriété du bean public String getName() {
return name;
devrait être injectée. }
}
 Deprecated depuis la version Spring 5.1
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "[Link]
xmlns:xsi = "[Link]
xmlns:context = "[Link]
xsi:schemaLocation = "[Link]
[Link]
[Link]
[Link]
<context:annotation-config/>
<!-- Definition for student bean -->
<bean id = "student" class = "Student">
<property name = "name" value = "Ahmed" />
<property name = "age" value = "21"/>
</bean>
`</beans>
 public class TextEditor {
Inversion de controle (IoC) private SpellChecker spellChecker;
@Autowired
public void setSpellChecker( SpellChecker spellChecker )
Annotations : @Autowired {
[Link] = spellChecker;
}
..
 Permet de spécifier le bean dépendant. }
public class TextEditor {
 Appliquée sur un constructeur, sur un attribut @Autowired
ou sur un setter. private SpellChecker spellChecker;
...
 Utile s’il y a plusieurs constructeurs. }

✔ Autowired permet d’indiquer au conteneur le public class TextEditor {

private SpellChecker spellChecker;
constructeur à utiliser. @Autowired
public TextEditor(SpellChecker spellChecker){
 Autowired n’a pas le même degré d’importance [Link] = spellChecker;
que required pour décrire la dépendance. }
...
✔ @Autowired(required = false)
<!-- Definition for textEditor bean without constructor-arg -->
<bean id = "textEditor" class = "[Link]">
</bean>

<!-- Definition for spellChecker bean -->

<bean id = "spellChecker" class = "[Link]">
</bean>
 package [Link];
Inversion de controle (IoC) import [Link];
import [Link];
public class Profile {
@Autowired
Annotations : @Qualifier @Qualifier("student1")
private Student student;
public Profile(){
[Link]("Inside Profile constructor." );
 Permet de qualifier un bean parmi plusieurs. }
public void printAge() {
[Link]("Age : " + [Link]() );
}
public void printName() {
[Link]("Name : " + [Link]() );
}
}

<!-- Definition for profile bean -->

<bean id = "profile" class = "[Link]"></bean>

<!-- Definition for student1 bean -->

<bean id = "student1" class = "[Link]">
<property name = "name" value = "Zara" />
<property name = "age" value = "11"/>
</bean>

<!-- Definition for student2 bean -->

<bean id = "student2" class = "[Link]">
<property name = "name" value = "Nuha" />
<property name = "age" value = "2"/>
</bean>
Inversion de controle (IoC)
Annotations : @Value

 Permet de donner des valeurs par défauts aux @Value("Default DBConfiguration")

private String defaultName;
attributs et aux paramètres des méthodes.
@Value("true")
private boolean defaultBoolean;

@Value("10")
private int defaultInt;

@Value("Test")
public void printValues(String s, String v){ }
//both 's' and 'v' values will be 'Test'

public void printValues(@Value("Test")String s, String v){ }

//only 's' value will be 'Test'
Inversion de controle (IoC) @Configuration
public class AppConfig {
@Bean
public BeanOne beanOne() {
Configuration à base de Java : Spring 3.0 return new BeanOne(beanTwo());
}
@Configuration ...
}
 @Configuration est une annotation au niveau d’une classe.
 Indique que la classe a pour rôle de définir les beans et leurs
inter-dépendances. Est équivalent à :
 Le conteneur est instancié en utilisant l’implémentation <beans>
AnnotationConfigApplicationContext. <bean id="beanOne" class="BeanOne"/>
</beans>

public static void main(String[] args) {

ApplicationContext ctx = new

AnnotationConfigApplicationContext([Link]);

BeanOne myBean = [Link]([Link]);

[Link]();
}
 @Configuration
Inversion de controle (IoC) @ComponentScan("[Link]")
public class ConfigA {

Configuration à base de Java : Spring 3.0 @Bean

public A a() {
@Configuration }
return new A();

 Les classes de configurations peuvent être }

imbriquées en utilisant @Import([Link]) dans la @Configuration

classe ConfigB. @Import([Link])
public class ConfigB {
✔ Le conteneur est créé en faisant appel seulement à la classe
@Bean
ConfigB. public B b() {
return new B();
 @ComponentScan permet de détecter les classes d’un package }
et prendre en considération les beans de ces classes. }

✔ Peut prendre comme paramètre basepackage pour indiquer

un ou plusieurs packages. public static void main(String[] args) {
✔ Ce package représente un package parent. ApplicationContext ctx = new
AnnotationConfigApplicationContext([Link]);

}
Inversion de controle (IoC)
Configuration à base de XML :

Configuration à base de Java <beans>

<bean id="transferService" class="TransferServiceImpl"/>
@Bean </beans>

@Configuration
public class AppConfig {
 @Bean est une annotation au niveau d’une méthode. @Bean
@Description(“une description”)
✔ Equivalente à la balise <bean/>. public TransferService transferService() {
✔ Indique que la méthode instancie, configure et return new TransferServiceImpl();
}
initialise un nouvel objet pour être géré par le }
conteneur Spring IoC.
 Par défaut, le nom du bean est le même @Configuration
public class AppConfig {
que le nom de la méthode. @Bean
public TransferService transferSrv(AccountRepo accountRepo)
 @Bean({“nom1”, ..}) pour définir {
des alias. return new TransferSrvcImpl(accountRepo);
}

@Bean("myThing")
public Thing thing() {
return new Thing();
}
}
 public class BeanOne {
public void init() {
Inversion de controle (IoC) // initialization logic
}
}
Configuration à base de Java public class BeanTwo {
public void cleanup() {
@Bean }
// destruction logic

}
@Configuration
public class AppConfig {
 Peut utiliser les méthodes callbacks de cycle de vie telles
que initMethod et destroyMethod. @Bean(initMethod = "init")
public BeanOne beanOne() {
return new BeanOne();
 @Scope(…) pour indiquer la portée : }
@Bean(destroyMethod = "cleanup")
✔ Singleton, par défaut, public BeanTwo beanTwo() {
return new BeanTwo();
✔ @Scope(“prototype”) }
}
 Supporte la dépendance : une méthode appelle une
deuxième méthode.
@Configuration
public class AppConfig {
@Bean
public ClientService clientService() {
Return new ClientServiceImpl(clientDao());
}
@Bean
public ClientDao clientDao() {
return new ClientDaoImpl();
}
}
 TP 3
●
Développer une application de gestion de
commandes selon le diagramme de classe
indiqué.
●
On se base sur Spring pour la définition
des beans et sur l’IoC de Spring pour la
création des objets.
●
Dans la mathode main:
– On prépare un stock de 4 produits.
– On définit un client.
– Le client effectue une commande sur
un produit.