Ce este integrarea dependentă și ce beneficii aduce…

Injecția de dependințe (Dependency Injection, DI) este un model de proiectare în care componentele primesc dependențele din exterior, în loc să le creeze singure. Este unul dintre principiile inversiunii controlului (Inversion of Control, IoC).

Beneficiile DI:

Îmbunătățirea testabilității: Este mai ușor să înlocuiți dependențele cu mocks sau stubs în timpul testelor unitare.
Reducerea cuplajului (Loose Coupling): Componentele depind mai puțin de implementările specifice ale dependențelor.
Mai multă flexibilitate și extensibilitate: Este ușor să schimbați implementările dependențelor fără a modifica codul principal al componentei.
Îmbunătățirea lizibilității și întreținerii: Este clar ce dependențe sunt necesare pentru un component.

Exemplu fără DI vs cu DI:

Fără DI:

// Clasa care creează o dependență în interior
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Cuplaj puternic: creăm o implementare concretă
        this.dbConnection = new OracleConnection(); 
    }

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

Cu DI (prin constructor):

// Interfața dependenței
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Diferite implementări
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectare la Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Deconectare de la Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectare la MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Deconectare de la MySQL...");
    }
}

// Clasa care primește dependența din exterior
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Injectare de dependență prin constructor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// Cod care efectuează injectarea (configurare)
public class Application {
    public static void main(String[] args) {
        // Creăm dependența
        DatabaseConnection connection = new MySQLConnection(); 
        // Injectăm dependența în ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Sau schimbăm dependența fără a modifica ServiceB
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Metode de injectare:

Prin constructor (Constructor Injection): Dependențele sunt furnizate prin constructorul clasei. Preferabil pentru dependențe obligatorii.
Prin setter (Setter Injection): Dependențele sunt furnizate prin metode setter. Potrivit pentru dependențe opționale.
Prin câmp (Field Injection): Dependențele sunt injectate direct în câmpurile clasei (de obicei cu framework-uri, necesită reflecție). Ne recomandă fără framework-uri DI din cauza dificultăților de testare și ascunderii dependențelor.

DI se implementează adesea cu ajutorul containerelor/framework-urilor DI, precum Spring, Guice, Dagger, care gestionează ciclul de viață al obiectelor și automatizează procesul de injectare.

Ce este integrarea dependentă și ce beneficii aduce?