Mis on sõltuvuste sisestamise (Dependency Injection)…

Sõltuvuste juurutamise (DI) eripära seisneb selles, et objekti sõltuvuste loomine ja haldamine võetakse üle väljastpoolt, tavaliselt IoC-konteinerisse (Inversion of Control). Selle asemel, et objekt ise looks või leiaks oma sõltuvused, "toimetatakse" need talle väljastpoolt.

DI peamised eelised ja omadused:

Vastutuse jagamine: Klass ei kanna vastutust oma sõltuvuste loomise eest.
Testitavus: Sõltuvused on kergesti asendatavad mokkide või varjunditega moodulitest testimisel.
Paindlikkus: Sõltuvuste realiseeringuid on lihtne muuta ilma koodi muutmata, mis neid kasutab.
Vähem seotud: Komponendid muutuvad vähem tihedalt seotud, mis parandab hooldatavust.

Juhtumid:

Konstruktorite kaudu (Constructor Injection): Sõltuvused edastatakse klassi konstruktoriga. Kõige eelistatum viis, kuna tagab sõltuvuste olemasolu objekti loomise hetkest.

// Sõltuvusega klass
public class MyService {
    private MyDependency dependency;

    // Konstruktoriga sisestamine
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Sõltuvuse kasutamine
    public void doSomething() {
        dependency.performAction();
    }
}

// Sõltuvus
public interface MyDependency {
    void performAction();
}

// Näide sõltuvuse realiseerimisest
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("Tegevus teostatud!");
    }
}

Setter meetodi kaudu (Setter Injection): Sõltuvused edastatakse läbi avalike setter-meetodite. Annab võimaluse luua objekte sõltuvustega vastavalt vajadusele, kuid nõuab täiendavaid nullkontrolle ning ei garanteeri kõigi sõltuvuste olemasolu kohe.

// Sõltuvusega klass
public class AnotherService {
    private AnotherDependency dependency;

    // Tühi konstruktor
    public AnotherService() {
    }

    // Setter meetodiga
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Sõltuvuse kasutamine
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("Sõltuvus pole määratud!");
        }
    }
}

// Sõltuvus
public interface AnotherDependency {
    void anotherAction();
}

// Näide sõltuvuse realiseerimisest
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("Teine tegevus teostatud!");
    }
}

Välja (Field Injection): Sõltuvused sisestatakse otse klassi väljad, kasutades annotatsioone. Kõige lihtsam süntaktiliselt, kuid muudab klassi sõltuvaks DI raamistikust ning raskendab testimist ilma raamistikuta.

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

// Sõltuvusega klass
public class SomeOtherService {

    // Välja sisestamine (Spring annotatsiooniga)
    @Autowired
    private YetAnotherDependency dependency;

    // Sõltuvuse kasutamine
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Sõltuvus
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Näide sõltuvuse realiseerimisest
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("Veel üks tegevus teostatud!");
    }
}

Võrdlus:

Juhtum	Eelised	Miinused
Konstruktorite kaudu	Tagab sõltuvuste olemasolu, lihtne testida, muutumatu	Võib põhjustada "parameetrite sõltuvust" konstruktoris, kui palju sõltuvusi
Setter meetodi kaudu	Valikuline sõltuvus, võimalus muuta sõltuvusi pärast loomist	Vajab nullkontrolle, ei garanteeri objekti täielikku olekut pärast loomist
Välja kaudu	Lühike süntaks	Tugev sõltuvus DI raamistikust, raskendab testimist ilma selleta

DI on üks võtmeprintsiipidest paljudes kaasaegsetes raamistikus (nt Spring, CDI) ning soodustab nõrgalt seotud ja kergesti testitavate rakenduste loomist.

Mis on sõltuvuste sisestamise (Dependency Injection) omadus?