Kas ir atkarīga integrācija un kādas priekšrocības tā…

Atkarības injekcija (Dependency Injection, DI) ir dizaina paraugs, kurā komponenti saņem atkarības no ārpuses, nevis tās pašas izveido. Tas ir Inversijas kontroles (Inversion of Control, IoC) princips.

DI ieguvumi:

Testēšanas uzlabošana: Moduļu testēšanā ir vieglāk aizstāt atkarības ar aizstājējiem (mocks/stubs).
Vājā saistība (Loose Coupling): Komponenti ir mazāk atkarīgi no konkrētām realizācijām.
Elastības un paplašināmības palielināšana: Var viegli mainīt atkarību realizācijas bez galvenā koda izmaiņām.
Lasāmības un uzturēšanas uzlabošana: Skaidri redzamas nepieciešamās atkarības komponentam.

Piemērs bez DI un ar DI:

Bez DI:

// Klase, kas izveido atkarību iekšā
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Spēcīga saistība: tieši izveido konkrētu realizāciju
        this.dbConnection = new OracleConnection(); 
    }

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

Ar DI (caur konstruktoru):

// Atkarības interfeiss
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Dažādas realizācijas
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Savienojums ar Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Atvienojās no Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Savienojums ar MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Atvienojās no MySQL...");
    }
}

// Klase, kas saņem atkarību no ārpuses
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Atkarības injekcija caur konstruktoru
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

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

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

// Kods, kas veic injekciju (konfigurācija)
public class Application {
    public static void main(String[] args) {
        // Izveido atkarību
        DatabaseConnection connection = new MySQLConnection(); 
        // Injektē atkarību ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Vai maina atkarību bez ServiceB izmaiņām
        DatabaseConnection anotherConnection = new OracleConnection();
         ServiceB anotherService  = new ServiceB(anotherConnection);
         anotherService.doSomething();
    }
}

Injekcijas veidi:

Caur konstruktoru (Constructor Injection): Atkarības tiek nodrošinātas caur klases konstruktoru. Piemērots obligātām atkarībām.
Caur sētāju (Setter Injection): Atkarības tiek nodrošinātas caur sētāju metodēm. Derīgs izvēles atkarībām.
Caur lauku (Field Injection): Atkarības injekcijas tieši klases laukos (bieži izmanto ar framework'iem, prasa refleksiju). Nav ieteicams bez DI framework'iem, jo sarežģī testēšanu un slēpj atkarības.

DI bieži tiek realizēta ar DI konteineriem/framework'iem, piemēram, Spring, Guice, Dagger, kas pārvalda objektu dzīves ciklu un automatizē injekcijas procesu.

Kas ir atkarīga integrācija un kādas priekšrocības tā sniedz?