Comment peut-on appliquer l'injection de dépendances…

Le conteneur IoC de Spring gère le cycle de vie des Spring Beans (objets). Les Beans sont les principaux blocs de construction des applications Spring. L'injection de dépendances (DI) utilisant des Beans Spring se réalise par une configuration indiquant au conteneur comment créer et lier les composants.

Il existe trois principales méthodes d'injection de dépendances dans Spring :

Injection par constructeur : Spring appelle le constructeur approprié lors de la création du Bean. C'est la méthode préférée car elle garantit que toutes les dépendances nécessaires sont initialisées lors de la création de l'objet et permet de rendre les dépendances immuables.
Injection par setter : Spring appelle les méthodes setters de la classe pour définir les dépendances après la création du Bean. Cette méthode est utile pour les dépendances optionnelles.
Injection par champ : Spring utilise la réflexion pour injecter directement les dépendances dans les champs de la classe. Non recommandé car cela complique les tests et viole l'encapsulation.

La configuration pour l'injection de dépendances peut être réalisée via :

Annotations : @Autowired, @Qualifier, @Value. Approche la plus courante dans les applications Spring modernes.

// Exemple d'injection par constructeur avec annotation
@Component // Rend la classe un Bean Spring
public class MyService {

    private final MyDependency dependency;

    @Autowired // Indique à Spring d'injecter la dépendance via le constructeur
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class MyDependency {
    // ...
}

// Exemple d'injection par setter avec annotation
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Indique à Spring d'injecter la dépendance via le setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class AnotherDependency {
    // ...
}

// Exemple d'injection par champ avec annotation (non recommandé)
@Component
public class FieldInjectedService {

    @Autowired // Indique à Spring d'injecter la dépendance dans le champ
    private FinalDependency dependency;

    // ...
}

@Component
public class FinalDependency {
    // ...
}

Configuration XML : Utilisée dans des projets plus anciens ou spécifiques.

<!-- Exemple d'injection par constructeur en XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency"/>
    </bean>
</beans>

<!-- Exemple d'injection par setter en XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

    <bean id="anotherService" class="com.example.AnotherService">
        <property name="dependency" ref="anotherDependency"/>
    </bean>
</beans>

Configuration Java (avec @Configuration et @Bean) : Approche moderne permettant de configurer le conteneur Spring via du code Java.

// Exemple de configuration Java
@Configuration // Indique que c'est une classe de configuration
public class AppConfig {

    @Bean // Déclare le Bean myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Déclare le Bean myService
    public MyService myService(MyDependency myDependency) {
        // Injection via constructeur lors de la création du Bean
        return new MyService(myDependency);
    }
}

Le conteneur IoC de Spring scanne la configuration (annotations, XML, classes Java), crée des instances de Beans, gère leur cycle de vie et injecte automatiquement les dépendances. Cela réduit le couplage des composants, facilite les tests (il est facile de remplacer les dépendances par des objets mock) et rend le code plus maintenable.

Comment peut-on appliquer l'injection de dépendances avec Spring Bean?