Mi a függőség-injektálás (Dependency Injection)…

A függőségi injekció (DI) jellemzője, hogy az objektum függőségeinek létrehozása és kezelése kívül, általában az IoC-konténerben (Inversion of Control) történik. Az objektum nem maga hozza létre vagy találja meg a függőségeit, hanem kívülről "injektálódnak" bele.

A DI fő előnyei és jellemzői:

Felelősségek szétválasztása: A osztály nem felelős a függőségei létrehozásáért.
Tesztelhetőség: A függőségek könnyen helyettesíthetők mock vagy stubs segítségével moduláris tesztelés során.
Rugalmasság: A függőségek implementációinak módosítása könnyű anélkül, hogy a kódot, amely használja őket, meg kellene változtatni.
Kevesebb kötöttség: A komponensek kevésbé szorosan kapcsolódnak egymáshoz, ez javítja a karbantarthatóságot.

Implementációs módok:

Konstruktoron keresztül (Constructor Injection): A függőségek a osztály konstruktorán keresztül kerülnek átadásra. Ez a legpreferáltabb módszer, mivel garantálja a függőségek meglétét a objektum létrehozásának pillanatától.

// Függőséggel rendelkező osztály
public class MyService {
    private MyDependency dependency;

    // Injektálás konstruktoron keresztül
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Függőség használata
    public void doSomething() {
        dependency.performAction();
    }
}

// Függőség
public interface MyDependency {
    void performAction();
}

// Függőség implementáció példája
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("Művelet végrehajtva!");
    }
}

Setteren keresztül (Setter Injection): A függőségek nyilvános setter metódusokon keresztül kerülnek átadásra. Ez lehetővé teszi az objektumok kérés szerinti létrehozását függőségekkel, de null ellenőrzéseket igényel, és nem garantálja az összes függőség azonnali meglétét.

// Függőséggel rendelkező osztály
public class AnotherService {
    private AnotherDependency dependency;

    // Üres konstruktor
    public AnotherService() {
    }

    // Setteren keresztüli injektálás
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Függőség használata
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("A függőség nincs beállítva!");
        }
    }
}

// Függőség
public interface AnotherDependency {
    void anotherAction();
}

// Függőség implementáció példája
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("Másik művelet végrehajtva!");
    }
}

Mezőn keresztül (Field Injection): A függőségek közvetlenül a osztály mezőibe injektálódnak annotációk segítségével. Ez a legegyszerűbb szintaxis, de az osztály függ a DI-keretrendszertől, és megnehezíti a tesztelést nélküle.

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

// Függőséggel rendelkező osztály
public class SomeOtherService {

    // Mezőn keresztüli injektálás (Spring annotációval)
    @Autowired
    private YetAnotherDependency dependency;

    // Függőség használata
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Függőség
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Függőség implementáció példája
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("Még egy művelet végrehajtva!");
    }
}

Összehasonlítás az implementációs módokról:

Mód	Előnyök	Hátrányok
Konstruktoron keresztül	Garantálja a függőségek meglétét, könnyű tesztelés, változatlan	A konstruktor paramétereinek száma növekedhet, "paraméterfüggőség" alakulhat ki
Setteren keresztül	A függőségek opcionálisak, lehetőség a függőségek későbbi módosítására	Null ellenőrzéseket igényel, nem garantálja az összes függőség azonnali meglétét
Mezőn keresztül	Rövid szintaxis	Erős függőség a DI-keretrendszertől, nehezíti a tesztelést nélküle

A DI kulcsfontosságú elv sok modern keretrendszerben (pl. Spring, CDI) és támogatja a laza kapcsolódású, könnyen tesztelhető alkalmazások kialakítását.

Mi a függőség-injektálás (Dependency Injection) sajátossága?