Co je závislá integrace a jaký má přínos?

Vazební injekce (Dependency Injection, DI) je návrhový vzor, při kterém komponenty získávají závislosti zvenčí, místo toho, aby si je samy vytvářely. Jedná se o jeden z principů Inversion of Control (IoC).

Výhody DI:

1. Zlepšení testovatelnosti: Snadnější nahrazení závislostí pomocí mocků/stubů při modulárním testování.
2. Uvolnění vazby (Loose Coupling): Komponenty jsou méně závislé na konkrétních implementacích závislostí.
3. Zvýšení flexibility a rozšiřitelnosti: Snadná změna implementací závislostí bez úpravy hlavního kódu.
4. Zlepšení čitelnosti a údržby: Jasně vidět, jaké závislosti jsou požadovány komponentou.

Příklad bez DI a s DI:

Bez DI:

// Třída, která vytváří závislost uvnitř sebe
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Silná vazba: explicitně vytváříme konkrétní implementaci
        this.dbConnection = new OracleConnection(); 
    }

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

S DI (přes konstruktor):

// Rozhraní závislosti
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Různé implementace
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Připojování k Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Odpojení od Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Připojování k MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Odpojení od MySQL...");
    }
}

// Třída, která přijímá závislost zvenčí
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Vstup závislosti přes konstruktor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// Kód konfigurace
public class Application {
    public static void main(String[] args) {
        // Vytvoření závislosti
        DatabaseConnection connection = new MySQLConnection(); 
        // Vložení závislosti do ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Nebo změna závislosti bez úpravy ServiceB
        DatabaseConnection anotherConnection = new OracleConnection();
         ServiceB anotherService  = new ServiceB(anotherConnection);
         anotherService.doSomething();
    }
}

Metody zavádění:

• Přes konstruktor (Constructor Injection): Závislosti jsou předávány přes konstruktor třídy. Preferováno pro povinné závislosti.
• Přes setter (Setter Injection): Závislosti jsou předávány přes metody setterů. Vhodné pro volitelné závislosti.
• Přes pole (Field Injection): Závislosti jsou přímo vkládány do polí třídy (obvykle s frameworky, vyžaduje reflexi). Nedoporučuje se bez DI frameworků kvůli složitosti testování a skrytí závislostí.

DI je často realizováno pomocí DI kontejnerů/frameworků, jako jsou Spring, Guice, Dagger, které spravují životní cyklus objektů a automatizují proces injektáže.