Was ist abhängige Integration und welchen Nutzen…

Dependency Injection (DI) ist ein Entwurfsmuster, bei dem Komponenten ihre Abhängigkeiten von außen erhalten, anstatt sie selbst zu erstellen. Es ist eines der Prinzipien der Inversion of Control (IoC).

Vorteile von DI:

Verbesserung der Testbarkeit: Es ist einfacher, Mocks oder Stubs für Abhängigkeiten bei Unit-Tests zu verwenden.
Reduzierung der Kopplung (Loose Coupling): Komponenten sind weniger abhängig von konkreten Implementierungen der Abhängigkeiten.
Erhöhte Flexibilität und Erweiterbarkeit: Es ist einfach, Implementierungen von Abhängigkeiten zu ändern, ohne den Hauptcode der Komponente zu modifizieren.
Verbesserung der Lesbarkeit und Wartbarkeit: Es ist klar ersichtlich, welche Abhängigkeiten eine Komponente benötigt.

Beispiel ohne DI vs mit DI:

Ohne DI:

// Klasse, die eine Abhängigkeit intern erstellt
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Starke Kopplung: konkrete Implementierung wird erstellt
        this.dbConnection = new OracleConnection(); 
    }

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

Mit DI (über den Konstruktor):

// Schnittstelle der Abhängigkeit
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Verschiedene Implementierungen
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Verbindung zu Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Verbindung zu Oracle trennen...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Verbindung zu MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Verbindung zu MySQL trennen...");
    }
}

// Klasse, die die Abhängigkeit von außen erhält
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Dependency Injection über den Konstruktor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// Code, der die Injektion durchführt (Konfiguration)
public class Application {
    public static void main(String[] args) {
        // Erstellen der Abhängigkeit
        DatabaseConnection connection = new MySQLConnection(); 
        // Injektion der Abhängigkeit in ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Oder die Abhängigkeit ändern, ohne ServiceB zu modifizieren
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Methoden der Injektion:

Über den Konstruktor (Constructor Injection): Abhängigkeiten werden über den Konstruktor der Klasse bereitgestellt. Bevorzugt für verpflichtende Abhängigkeiten.
Über den Setter (Setter Injection): Abhängigkeiten werden über Setter-Methoden bereitgestellt. Gut geeignet für optionale Abhängigkeiten.
Über das Feld (Field Injection): Abhängigkeiten werden direkt in die Felder der Klasse injiziert (meist mit Frameworks, erfordert Reflexion). Nicht empfohlen ohne DI-Frameworks wegen erschwerter Tests und versteckter Abhängigkeiten.

DI wird häufig mit Hilfe von DI-Containern/Frameworks wie Spring, Guice, Dagger umgesetzt, die den Lebenszyklus der Objekte verwalten und den Injektionsprozess automatisieren.

Was ist abhängige Integration und welchen Nutzen bringt sie?