L'inversion de contrôle (IoC) et l'injection de dépendances (DI) sont deux concepts fondamentaux du Spring Framework. Traditionnellement, les objets sont responsables de la création et de la gestion de leurs propres dépendances. Cependant, IoC renverse cette responsabilité en confiant le contrôle de la création d'objets et de la gestion des dépendances à un framework comme Spring.

Ce changement offre plusieurs avantages :

• Échange d'implémentation plus facile : différentes implémentations peuvent être échangées avec des modifications minimes de la base de code.
• Modularité accrue : les composants d'application deviennent plus modulaires, facilitant la séparation des préoccupations.
• Testabilité améliorée : les composants peuvent être testés de manière isolée, ce qui simplifie les stratégies de simulation et d'autres tests.

IoC peut être implémenté via divers mécanismes, y compris des modèles de conception tels que le modèle d'usine, le modèle de stratégie ou le modèle de localisateur de services. Cependant, le moyen le plus courant et le plus puissant d’atteindre l’IoC consiste à utiliser l’injection de dépendances.

Comprendre l'injection de dépendances

Dependency Injection (DI) est une technique dans laquelle le framework injecte des dépendances dans un objet plutôt que dans l'objet créant lui-même les dépendances. Il existe différents types de DI au printemps :

• Injection de constructeur : les dépendances sont fournies via le constructeur de la classe.
• Setter Injection : les dépendances sont injectées via des méthodes setter.
• Injection de champ : les dépendances sont directement affectées aux champs à l'aide d'annotations.

Par exemple, dans une classe de service simple, vous pourriez voir quelque chose comme ceci :

@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processOrder(Order order) {
        paymentService.processPayment(order.getPaymentDetails());
    }
}

Ici, PaymentService est injecté dans OrderService via l'injection de constructeur, ce qui est généralement préféré pour ses dépendances claires et sa facilité de test.

Conteneur IoC : BeanFactory contre ApplicationContext

Spring fournit un conteneur IoC chargé de gérer le cycle de vie des beans (objets gérés par Spring). L'interface de base de ce conteneur est BeanFactory. Cependant, la plupart des applications utilisent ApplicationContext, qui étend BeanFactory et offre des fonctionnalités supplémentaires.

BeanFactory

• Conteneur IoC de base : il fournit des fonctionnalités de base pour créer et gérer des beans.
• Initialisation paresseuse : les beans sont créés lorsqu'ils sont demandés pour la première fois.

Contexte d'application

• Conteneur IoC avancé : en plus des fonctionnalités de base de BeanFactory, il fournit :
  • Prise en charge de l'internationalisation (i18n)
  • Propagation et gestion des événements
  • Traitement des requêtes asynchrones
  • Intégration avec la programmation orientée aspect (AOP)
• Initialisation hâtive : les beans peuvent être instanciés au démarrage de l'application, les rendant ainsi disponibles pour une utilisation immédiate.

Exemple:

// Getting a bean from the ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyBean myBean = context.getBean(MyBean.class);

Dans cet exemple, ApplicationContext est utilisé pour récupérer un bean. Si vous utilisiez un BeanFactory de base, il offrirait des fonctionnalités similaires mais sans les avantages supplémentaires d'ApplicationContext.

Accéder au contexte d'application

Il existe deux manières courantes d'accéder au ApplicationContext actuel :

1. Autowired : injectez le ApplicationContext directement dans votre composant.
   

   @Autowired
   private ApplicationContext applicationContext;
   

2. ApplicationContextAware : implémentez l'interface ApplicationContextAware, qui vous permet de récupérer l'ApplicationContext selon vos besoins.
   

   public class MyBean implements ApplicationContextAware {
       private ApplicationContext applicationContext;
   
       @Override
       public void setApplicationContext(ApplicationContext context) throws BeansException {
           this.applicationContext = context;
       }
   }
   

Cycle de vie d'une application Spring

Lorsqu'une application Spring démarre, une série d'étapes ont lieu :

1. Variables et propriétés de l'environnement de traitement : l'objet Environnement est créé, incorporant les paramètres de application.properties ou application.yml.

2. Création du ApplicationContext : le type ApplicationContext approprié est déterminé et instancié. Par exemple, une application Spring Boot peut utiliser AnnotationConfigServletWebServerApplicationContext pour les configurations basées sur Java.

3. Chargement des définitions de bean : Spring charge les définitions de bean à partir de plusieurs sources, telles que des classes annotées, des classes @Configuration ou des fichiers XML. Chaque définition de bean inclut des informations sur le type, la portée, les dépendances et les rappels du cycle de vie du bean.

4. Processing BeanFactoryPostProcessors : ces processeurs modifient les définitions des beans avant que les beans réels ne soient créés.

5. Résolution des dépendances et création de beans : ApplicationContext résout les dépendances et crée les beans. Si un bean a des dépendances sur d'autres beans, ces dépendances sont créées en premier.

Champs d'application des haricots au printemps

Spring prend en charge diverses portées de bean, qui définissent le cycle de vie et la visibilité d'un bean dans le conteneur :

• Singleton (par défaut) : une seule instance du bean est créée pour l'ensemble du contexte de l'application.
• Prototype : une nouvelle instance est créée à chaque fois que le bean est demandé.
• Requête : Une nouvelle instance de bean est créée pour chaque requête HTTP (applications Web).
• Session : une nouvelle instance de bean est créée pour chaque session HTTP (applications Web).

Exemple:

@Bean
@Scope("prototype")
public MyPrototypeBean myPrototypeBean() {
    return new MyPrototypeBean();
}

Dans cet exemple, une nouvelle instance de MyPrototypeBean est créée chaque fois qu'elle est demandée au conteneur.

Objets proxy dans les étendues du bean

Considérons un scénario dans lequel un bean de portée Singleton dépend d'un bean de portée Prototype. Normalement, le bean prototype ne serait créé qu'une seule fois lors de l'initialisation du singleton. Pour garantir qu'une nouvelle instance du bean prototype est fournie à chaque fois, Spring utilise des objets proxy.

Exemple avec des proxys :

@Component
@Scope(value = "singleton")
public class SingletonBean {

    @Autowired
    @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
    private PrototypeBean prototypeBean;

    public void showMessage() {
        System.out.println(prototypeBean.getMessage());
    }
}

Ici, ScopedProxyMode.TARGET_CLASS garantit qu'une nouvelle instance de PrototypeBean est renvoyée à chaque fois que getMessage() est appelé.

Différence entre Spring Framework et Spring Boot

Spring Boot est une extension de Spring Framework qui simplifie la configuration et le développement de nouvelles applications Spring. Il fournit :

• Serveurs d'applications intégrés : exécutez facilement des applications Spring en tant qu'applications autonomes avec Tomcat, Jetty ou Undertow intégrés.
• Configuration automatique : configure automatiquement les beans en fonction du chemin de classe et d'autres paramètres.
• Emballage simplifié : emballez les applications sous forme de fichiers JAR ou WAR exécutables.
• Surveillance et contrôles de santé intégrés : points de terminaison intégrés pour surveiller la santé et l'état de l'application.

Configuration automatique dans Spring Boot

La configuration automatique est une fonctionnalité puissante de Spring Boot qui configure de nombreuses choses pour vous en fonction des dépendances de votre chemin de classe. Ceci est contrôlé par des annotations conditionnelles telles que :

• @ConditionalOnClass
• @ConditionalOnMissingClass
• @ConditionalOnBean
• @ConditionalOnMissingBean

Exemple:

Par exemple, si vous avez Jackson sur votre chemin de classe, Spring Boot configurera automatiquement un ObjectMapper pour la sérialisation JSON :

@Configuration
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {
    // Configuration details...
}

Si ObjectMapper est présent, cette configuration est automatiquement appliquée. Sinon, il est ignoré.

Affichage des configurations automatiques actives

Vous pouvez enregistrer les configurations automatiques actives au démarrage en ajoutant les éléments suivants à votre application.properties :

logging.level.org.springframework.boot.autoconfigure=DEBUG

Cela générera un rapport détaillé indiquant quelles configurations ont été appliquées et lesquelles ne l'ont pas été, vous aidant à dépanner ou à comprendre la configuration de l'application.

Conclusion

L'inversion de contrôle et l'injection de dépendances sont des concepts fondamentaux qui permettent la flexibilité, la modularité et la testabilité qui rendent Spring si puissant. En comprenant comment fonctionne le conteneur IoC de Spring, comment les beans sont gérés et comment Spring Boot étend ces fonctionnalités, vous pouvez développer plus efficacement des applications robustes et maintenables.