Le document explique les diverses méthodes d'injection de dépendances dans Spring, y compris l'injection par setter, constructeur et directement dans les champs, ainsi que les frameworks associés. Il met en avant l'importance de la gestion des dépendances dans le développement logiciel moderne afin de répondre aux exigences fonctionnelles et techniques. De plus, il fournit des exemples de configuration XML et d'annotations pour simplifier cette gestion dans des applications Java.

1. 1
Spring Ioc

2. L’Injection de Dépendances
• A la base, il s’agit simplement d’injecter un objet dans un Autre
public class TodosServiceImpl {
private UserService userService;
}
2
userService doit être injecté

3. L’injection par setter
• 1ère méthode, «classique» : l’injection par setter
• ○ Utilise la convention Java Bean
public class TodosServiceImpl {
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
}
3
Spring va appeler cette méthode

4. L’injection par constructeur
• 2Ème méthode, relativement populaire : utiliser le constructeur de l’objet
public class TodosServiceImpl {
private UserService userService;
public TodosServiceImpl(UserService userService) {
this.userService = userService;
}
}
4
Spring va construire l’objet correctement

5. L’injection dans un champ
• 3ème méthode : Spring injecte directement dans le champ
oMéthode «magique» : en fait les champs «private» en Java peuvent être modifiés (si
vous venez d’avoir un cours sur Java, on vous a menti)
oDe plus en plus populaire car la méthode la plus simple
public class TodosServiceImpl {
private UserService userService;
}
5
Spring injecte directement dans le champ

6. 6
Inversion de contrôle
ou
Injection de dépendances
dans Spring

7.  Exigences Fonctionnelles
• Satisfaire les besoins fonctionnels (métiers) de l’entreprises
 Exigences Techniques
• Performances : l’application doit être performante
 Temps de réponse
 Problème de montée en charge : Vers une architecture Distribuée scalable
 Equilibrage de charges et Tolérances aux panes
• Maintenance : l’application doit être facile à maintenir
 Une application doit é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
• Créer différents types de clients pour accéder à l’application : Web, Mobile, Desktop,
 Exigences financières : Le coût du logiciel doit respecter les contraites budgétaires
Exigences d’un projet informatique
7

8. Constat
 Il est très difficile de développer un système logiciel qui respecte ces exigences sans
utiliser l’expérience des autres :
◦ Bâtir l’application sur une architecture d’entreprise:
 JEE
◦ Framework pour l’Inversion de contrôle:
 Permettre au développeur de s’occuper uniquement du code métier
(Exigences fonctionnelles) et c’est le Framework qui s’occupe du code
technique (Exigences Techniques)
 Spring (Conteneur léger)
 EJB (Conteneur lourd)
◦ Frameworks :
 Mapping objet relationnel (ORM ) : JPA, Hibernate, Toplink, …
 Applications Web : Struts, JSF, SpringMVC
◦ Middlewares :
 RMI, CORBA : Applications distribuées
 Web Services :
 JAXWS pour Web services SOAP
 JAXRS pour les Web services RESTful
 Communication asynchrone entre les application :
 JMS :
 AMQP :
8

9. Exemple : sans utiliser d’inversion de contrôle
Exemple : sans utiliser d’inversion de contrôle
public void virement(int c1, int c2, double mt) {
/* Création d’une transaction */
EntityTransaction transaction=entityManager.getTransaction();
/* Démarrer la transaction */
transaction.begin();
try {
/* Code métier */
retirer(c1,mt);
verser(c2,mt);
/* Valider la transaction */
transaction.commit();
} catch (Exception e) {
/* Annuler la transaction en cas d’exception */
transaction.rollback();
e.printStackTrace();
}
}
Code Technique
Code Technique
Code Métier
9

10. Exemple : sans utiliser d’inversion de contrôle
Code Métier
@Transactional
public void virement(int c1, int c2, double mt) {
retirer(c1,mt);
verser(c2,mt);
}
Ici, avec l’annotation @Transactional, nous avons
délégué la gestion des transactions au conteneur
Spring IOC
10

11.  Quand une classe A est lié à une classe B, on dit que la classe A est fortement couplée à la
classe B.
 La classe A ne peut fonctionner qu’en présence de la classe B.
 Si une nouvelle version de la classe B (soit B2), est crée, on est obligé de modifier dans la
classe A.
 Modifier une classe implique:
◦ Il faut disposer du code source.
◦ Il faut recompiler, déployer et distribuer la nouvelle application aux clients.
◦ Ce qui engendre un cauchemar au niveau de la maintenance de l’application
Couplage fort
A
b:B
Calcul(): double
B
11

12. Couplage Faible
IA
Calcul(): double
IB
getValue()
 Pour utiliser le couplage faible, nous devons utiliser les interfaces.
 Considérons une classe A qui implémente une interface IA, et une classe B qui implémente une interface IB.
 Si la classe A est liée à l’interface IB par une association, on dit que le classe A et la classe B sont liées par un
couplage faible.
 Cela signifie que la classe B peut fonctionner avec n’importe quelle classe qui implémente l’interface IA.
 En effet la classe B ne connait que l’interface IA. De ce fait n’importe quelle classe implémentant cette interface
peut être associée à la classe B, sans qu’il soit nécéssaire de modifier quoi que se soit dans la classe B.
 Avec le couplage faible, nous pourrons créer des application fermée à la modification et ouvertes à l’extension.
AImpl
b:IB
Calcul(): double
BImpl
getValue() 12

13. Injection des dépendances
 Injection par instanciation statique :
import metier.MetierImpl;
import dao.DaoImpl;
public class Presentation {
public static void main(String[] args) {
DaoImpl dao=new DaoImpl();
MetierImpl metier=new MetierImpl();
metier.setDao(dao);
System.out.println(metier.calcul());
}
}
13

14. Injection des dépendances
 Injection par instanciation dynamique par réflexion :
• Fichier texte de configuration : config.txt
ext.DaoImp
metier.MetierImpl
import java.io.*;import java.lang.reflect.*;
import java.util.Scanner; import metier.IMetier;
import dao.IDao;
public class Presentation {
public static void main(String[] args) {
try {
Scanner scanner=new Scanner(new File("config.txt"));
String daoClassname=scanner.next();
String metierClassName=scanner.next();
Class cdao=Class.forName(daoClassname);
IDao dao= (IDao) cdao.newInstance();
Class cmetier=Class.forName(metierClassName);
IMetier metier=(IMetier) cmetier.newInstance();
Method meth=cmetier.getMethod("setDao",new Class[]{IDao.class});
meth.invoke(metier, new Object[]{dao});
System.out.println(metier.calcul());
} catch (Exception e) { e.printStackTrace(); }
}
}
14

15. Injection des dépendances avec Spring.
 L'injection de dépendances est souvent la base de tout programme moderne.
 L'idée en résumé est de déporter la responsabilité de la liaison des composants du programme dans
un framework afin de pouvoir facilement changer ces composants ou leur comportement.
 Parmi les leaders du marché Java, il y a Spring IoC, Guice, Dagger ou encore le standard « Java EE »
CDI qui existe depuis Java EE 6.
 Spring IOC commence par lire un fichier XML qui déclare quelles sont différentes classes à
instancier et d’assurer les dépendances entre les différentes instances.
 Quand on a besoin d’intégrer une nouvelle implémentation à une application, il suffirait de la
déclarer dans le fichier xml de beans spring.
15

16. Injection des dépendances dans une application java standard
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd" >
<beans>
<bean id="d" class="dao.DaomImpl"></bean>
<bean id="metier" class="metier.MetierImpl">
<property name="dao" ref="d"></property>
</bean>
</beans>
D:DaoImpl
getValue()
Metie:MetieImpl
IDao dao
Calcul(): double 16

17. Injection des dépendances dans une application java standard
package pres;
import metier.IMetier;
import org.springframework.context.support.*;
public class Presentation {
public static void main(String[] args) {
ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc.xml");
IMetier metier=(IMetier) context.getBean("metier");
System.out.println(metier.calcul());
}
}
17

18. • Annotations compatibles Java 5 et plus
• Objectifs
– Simplifier la configuration (convention over configuration)
– Limiter les fichiers de configuration XML
• Annotations dans Spring
– Annotations spécifiques à des couches d’architecture
• Présentation / Service / DAO (Data Access…)
Configuration par annotations
18

19. • Gestion des dépendances par annotations
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config />
<bean id="..." class="..." />
</beans>
Balise pour « activer » les annotations
Inclusion du namespace context
Configuration XML pour l’injection
19

20. • Injection automatique des dépendances
• 2 annotations pour la même fonction
– @Autowired : annotation Spring
– @Inject : annotation JSR-330
• Spring supporte les 2 annotations
– @Autowired dispose d’une propriété (required) que n’a pas l’annotation @Inject. Ceci
est utile pour indiquer le caractère facultatif d’une injection.
• Résolution par type
– Se base sur le type de l'objet pour retrouver la dépendance à injecter.
@Autowired ou @Inject
20

21. import org.springframework.beans.factory.annotation.Autowired;
public class HelloWorldCaller {
@Autowired
private HelloWorld helloWorldService;
public void callHelloWorld(){
helloWorldService.sayHello();
}
}
@Autowired sur un attribut
• Utilisation de @Autowired pour injecter helloWorld
21

22. @Autowired sur un mutateur
• Utilisation de @Autowired pour injecter helloWorld
import org.springframework.beans.factory.annotation.Autowired;
public class HelloWorldCaller {
private HelloWorld helloWorldService;
@Autowired
public void setHelloWorldService(HelloWorld helloWorldService){
this.helloWorldService=helloWorldService;
}
public void callHelloWorld(){
helloWorldService.sayHello();
}
}
22

23. • Injection à partir de l’identifiant du bean
• Nécessite Java 6 ou plus
• Se place devant un attribut ou un setter
• Par défaut, le nom est déduit du nom de la méthode (setter) ou de l’attribut
@Resource
package com.spring.formation;
import javax.annotation.Resource;
public class MovieManager {
@Resource(name="myMovieDAO")
private MovieDAO movieDAO;
public MovieManager() {}
public void setMovieDAO(MovieDAO movieDAO) {
this.movieDAO = movieDAO;
}
}
23

24. @Component : composant générique
@Service : Services métier
@Repository : accès aux données (DAO)
@Controller : contrôleur pour interface graphique (Web)
Stéréotype selon l’usage
24

25. • A utiliser conjointement à une annotation @Component ou dérivée
• Définit la portée d’un bean
– Par défaut (si non présent) : singleton
package com.spring.formation;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component("monComposant")
@Scope("prototype")
public class MyComponent {
}
@Scope
25

26. 26

27. Injection des dépendances dans une application web
 Dans une application web, SpringIOC est appelé au démarrage du serveur en déclarant le listener
ContextLoaderListener dans le fichier web.xml
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring-beans.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
 Dans cette déclaration, ContextLoaderListener est appelé par Tomcat au moment du démarrage de l’application.
Ce listener cherchera le fichier de beans spring « spring-beans.xml » stocké dans le dossier WEB-INF. ce qui permet
de faire l’injection des dépendances entre MetierImpl et DaoImpl
27

28. Les composants de Spring
● Un Application Context (une des implémentations de l’interface
org.springframework.context.ApplicationContext) représente le conteneur Spring :
il est chargé de démarrer les beans, de les injecter, de les gérer, de les détruire
● Il en existe plusieurs sortes : WebApplicationContext pour les applications Web
par exemple
● Le rôle de cette classe est de prendre vos objets et votre configuration, et de
faire fonctionner l’ensemble
28
Objets métier
Configuration
Spring Application prête !

29. Création d’un contexte spécifique aux configurations d’annotations:
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
MovieDAO mDAO = (MovieDAO) context.getBean("movieDAO");
}
Chargement du contexte
29

30. Encore plus facile en Spring Boot
@SpringBootApplication
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
// same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
30