Kāda ir atkarību injekcijas (Dependency Injection)…

Atkarības ieviešanas (DI) īpatnība ir tā, ka objekta atkarību izveidi un pārvaldību pārņem ārpus tā, parasti IoC konteinerā (Inversion of Control). Tā vietā, lai objekts pats veidotu vai atrastu savas atkarības, tās "ievada" no ārpuses.

Galvenās DI priekšrocības un īpatnības:

Atbildības sadalījums: Klase neuzņemas atbildību par savām atkarībām.
Testējamība: Atkarības viegli aizstājamas ar moki vai aizvietotājiem moduļu testēšanā.
Elastība: Vieglāk mainīt atkarību realizācijas bez koda maiņas, kas tās izmanto.
Mazāka sasaistība: Komponenti kļūst mazāk cieši saistīti, tas uzlabo uzturēšanu.

Ieviešanas veidi:

Caur konstruktoru (Constructor Injection): Atkarības tiek nodotas caur klases konstruktoru. Visizplatītākais veids, jo garantē atkarību esamību no objekta izveides brīža.

// Ar atkarību klasi
public class MyService {
    private MyDependency dependency;

    // Caur konstruktoru
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Izmantojot atkarību
    public void doSomething() {
        dependency.performAction();
    }
}

// Atkarība
public interface MyDependency {
    void performAction();
}

// Piemērs atkarības realizācijai
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("Darbība veikta!");
    }
}

Caur iestatīšanas metodi (Setter Injection): Atkarības tiek nodotas caur publiskiem seteriem. Atļauj izveidot objektus ar atkarībām pēc pieprasījuma, bet prasa papildu pārbaudes par null un nesniedz garantiju, ka visas atkarības ir uzreiz.

// Ar atkarību klasi
public class AnotherService {
    private AnotherDependency dependency;

    // Tukšs konstruktors
    public AnotherService() {
    }

    // Caur iestatīšanas metodi
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Izmantojot atkarību
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("Atkarība nav iestatīta!");
        }
    }
}

// Atkarība
public interface AnotherDependency {
    void anotherAction();
}

// Piemērs atkarības realizācijai
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("Vēl viena darbība veikta!");
    }
}

Caur lauku (Field Injection): Atkarības tiek tieši ievietotas klases laukos, izmantojot anotācijas. Visvienkāršākais sintaktiski, bet padara klasi atkarīgu no DI karkasa un sarežģī testēšanu bez tā.

import org.springframework.beans.factory.annotation.Autowired;

// Ar atkarību klase
public class SomeOtherService {

    // Caur lauku (ar Spring anotāciju)
    @Autowired
    private YetAnotherDependency dependency;

    // Izmantojot atkarību
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Atkarība
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Piemērs atkarības realizācijai
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("Vēl viena darbība veikta!");
    }
}

Salīdzinājums starp ieviešanas veidiem:

Ieviešanas veids	Priekšrocības	Trūkumi
Caur konstruktoru	Garantē atkarību esamību, viegli testēt, nemaināma	Var novest pie "parametru atkarības" konstruktorā, ja ir daudz atkarību
Caur iestatīšanas metodi	Izvēles iespēja ar atkarībām, iespēja mainīt atkarības pēc izveides	Prasa pārbaudes par null, nesniedz garantiju, ka objekts ir pilnībā sagatavots pēc izveides
Caur lauku	Īss sintakses veids	Smaga atkarība no DI karkasa, sarežģī testēšanu bez tā

DI ir galvenais princips daudzos mūsdienu karkasos (piemēram, Spring, CDI) un veicina vāji saistītu un viegli testējamu lietojumprogrammu izveidi.

Kāda ir atkarību injekcijas (Dependency Injection) īpatnība?