Wat is afhankelijke integratie en welke voordelen…

Dependency Injection (DI) is een ontwerppatroon waarbij componenten hun afhankelijkheden van buitenaf ontvangen, in plaats van ze zelf te creëren. Het is een van de principes van Inversion of Control (IoC).

Voordelen van DI:

Verbeterde testbaarheid: Het is gemakkelijker om mocks of stubs te gebruiken voor afhankelijkheden tijdens unittests.
Vermindering van koppeling (Loose Coupling): Componenten zijn minder afhankelijk van specifieke implementaties van afhankelijkheden.
Meer flexibiliteit en uitbreidbaarheid: Het is eenvoudig om implementaties van afhankelijkheden te wijzigen zonder de hoofdcode van het component aan te passen.
Verbeterde leesbaarheid en onderhoudbaarheid: Het is duidelijk welke afhankelijkheden een component nodig heeft.

Voorbeeld zonder DI vs met DI:

Zonder DI:

// Klasse die afhankelijkheid intern creëert
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Sterke koppeling: creëert een concrete implementatie
        this.dbConnection = new OracleConnection(); 
    }

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

Met DI (via constructor):

// Afhankelijkheidsinterface
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Verschillende implementaties
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Verbinden met Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Verbinding met Oracle verbreken...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Verbinden met MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Verbinding met MySQL verbreken...");
    }
}

// Klasse die afhankelijkheid van buiten ontvangt
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Dependency injection via constructor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// Code dat de injectie uitvoert (configuratie)
public class Application {
    public static void main(String[] args) {
        // Maak de afhankelijkheid
        DatabaseConnection connection = new MySQLConnection(); 
        // Injecteer de afhankelijkheid in ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Of wijzig de afhankelijkheid zonder ServiceB te wijzigen
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Injektie methoden:

Via constructor (Constructor Injection): Afhankelijkheden worden via de constructor van de klasse geleverd. Voorkeur voor verplichte afhankelijkheden.
Via setter (Setter Injection): Afhankelijkheden worden via setter-methoden geleverd. Geschikt voor optionele afhankelijkheden.
Via veld (Field Injection): Afhankelijkheden worden direct in de velden van de klasse geïnjecteerd (meestal met frameworks, vereist reflectie). Niet aanbevolen zonder DI-frameworks vanwege testmoeilijkheden en verborgen afhankelijkheden.

DI wordt vaak geïmplementeerd met behulp van DI-containers/frameworks zoals Spring, Guice, Dagger, die de levenscyclus van objecten beheren en het injectieproces automatiseren.

Wat is afhankelijke integratie en welke voordelen biedt het?