Qu'est-ce que l'intégration dépendante et quels…

L'injection de dépendances (Dependency Injection, DI) est un patron de conception dans lequel les composants reçoivent leurs dépendances de l'extérieur, plutôt que de les créer eux-mêmes. C'est l'un des principes de l'inversion de contrôle (Inversion of Control, IoC).

Avantages de la DI :

Amélioration de la testabilité : Il est plus facile de substituer des mocks ou stubs pour les dépendances lors des tests unitaires.
Réduction du couplage (Loose Coupling) : Les composants dépendent moins des implémentations spécifiques des dépendances.
Plus de flexibilité et d'extensibilité : Il est facile de changer les implémentations des dépendances sans modifier le code principal du composant.
Amélioration de la lisibilité et de la maintenabilité : Il est clair quelles dépendances un composant requiert.

Exemple sans DI vs avec DI :

Sans DI :

// Classe qui crée une dépendance en interne
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Forte dépendance : création d'une implémentation concrète
        this.dbConnection = new OracleConnection(); 
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }
}

Avec DI (via le constructeur) :

// Interface de la dépendance
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Différentes implémentations
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connexion à Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Déconnexion d'Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connexion à MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Déconnexion de MySQL...");
    }
}

// Classe recevant la dépendance de l'extérieur
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Injection de dépendance via le constructeur
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }

    public void setDbConnection(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }
}

// Code effectuant l'injection (configuration)
public class Application {
    public static void main(String[] args) {
        // Création de la dépendance
        DatabaseConnection connection = new MySQLConnection(); 
        // Injection de la dépendance dans ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Ou changer la dépendance sans modifier ServiceB
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Méthodes d'injection :

Via le constructeur (Constructor Injection) : Les dépendances sont fournies via le constructeur de la classe. C'est la méthode préférée pour les dépendances obligatoires.
Via le setter (Setter Injection) : Les dépendances sont fournies via des méthodes setters. Convient pour les dépendances optionnelles.
Via le champ (Field Injection) : Les dépendances sont injectées directement dans les champs de la classe (généralement avec des frameworks, nécessite de la réflexion). Non recommandé sans frameworks DI en raison de la difficulté de test et de l'opacité des dépendances.

La DI est souvent réalisée à l'aide de conteneurs/frameworks DI, tels que Spring, Guice, Dagger, qui gèrent le cycle de vie des objets et automatisent le processus d'injection.

Qu'est-ce que l'intégration dépendante et quels avantages en tire-t-on?