V čem spočívá vlastnost zavádění závislostí…

Vlastnost zavádění závislostí (DI) spočívá v tom, že tvorba a správa závislostí objektu je přesunuta z něj samotného ven, obvykle do IoC kontejneru (Inversion of Control). Místo toho, aby si objekt sám vytvářel nebo hledal své závislosti, jsou "vkládány" zvenčí.

Hlavní výhody a vlastnosti DI:

Oddělení odpovědností: Třída nenese odpovědnost za tvorbu svých závislostí.
Testovatelnost: Závislosti lze snadno nahradit mocky nebo záložními objekty při modulárním testování.
Flexibilita: Snadno měnit implementace závislostí bez změny kódu, který je používá.
Méně propojení: Komponenty jsou méně pevně propojené, což zlepšuje udržovatelnost.

Způsoby zavádění:

Přes konstruktor (Constructor Injection): Závislosti jsou předávány přes konstruktor třídy. Nejpreferovanější způsob, protože zaručuje přítomnost závislostí od okamžiku vytvoření objektu.

// Třída se závislostí
public class MyService {
    private MyDependency dependency;

    // Vkládání přes konstruktor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Použití závislosti
    public void doSomething() {
        dependency.performAction();
    }
}

// Závislost
public interface MyDependency {
    void performAction();
}

// Příklad implementace závislosti
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("Akce provedena!");
    }
}

Přes setter (Setter Injection): Závislosti jsou předávány přes veřejné setter metody. Umožňuje vytvářet objekty s závislostmi na požádání, ale vyžaduje kontroly na null a nezaručuje okamžitou přítomnost všech závislostí.

// Třída se závislostí
public class AnotherService {
    private AnotherDependency dependency;

    // Prázdný konstruktor
    public AnotherService() {
    }

    // Vkládání přes setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Použití závislosti
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("Závislost není nastavena!");
        }
    }
}

// Závislost
public interface AnotherDependency {
    void anotherAction();
}

// Příklad implementace závislosti
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("Jiná akce provedena!");
    }
}

Přes pole (Field Injection): Závislosti jsou přímo vkládány do polí třídy pomocí anotací. Nejjednodušší syntaxe, ale činí třídu závislou na DI-frameworku a ztěžuje testování bez něj.

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

// Třída se závislostí
public class SomeOtherService {

    // Vkládání přes pole (s použitím Spring anotace)
    @Autowired
    private YetAnotherDependency dependency;

    // Použití závislosti
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Závislost
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Příklad implementace závislosti
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("Ještě jedna akce provedena!");
    }
}

Porovnání způsobů implementace:

Způsob implementace	Výhody	Nevýhody
Přes konstruktor	Zaručuje přítomnost závislostí, snadné testování, neměnnost	Může vést k "závislosti na parametrech" v konstruktoru při velkém počtu závislostí
Přes setter	Volitelnost závislostí, možnost změny závislostí po vytvoření	Vyžaduje kontroly na null, nezaručuje úplný stav objektu po vytvoření
Přes pole	Krátká syntaxe	Silná závislost na DI-frameworku, ztěžuje testování bez něj

DI je klíčovým principem v mnoha moderních frameworkech (například Spring, CDI) a přispívá k vytváření slabě propojených a snadno testovatelných aplikací.

V čem spočívá vlastnost zavádění závislostí (Dependency Injection)?