Care este caracteristica injecției de dependențe…

Caracteristica principală a injecției de dependență (DI) constă în faptul că crearea și gestionarea dependențelor unui obiect sunt externalizate, de obicei în containerul IoC (Inversion of Control). În loc ca obiectul să își creeze sau să găsească propriile dependențe, acestea sunt "injectate" din exterior.

Principalele avantaje și caracteristici ale DI:

Separarea responsabilităților: Clasa nu este responsabilă pentru crearea dependențelor sale.
Testabilitate: Dependențele pot fi ușor înlocuite cu mock-uri sau stubs în timpul testării modulare.
Flexibilitate: Este ușor să schimbi implementările dependențelor fără a modifica codul care le utilizează.
Mai puțină legătură: Componentele devin mai puțin strâns legate, ceea ce îmbunătățește întreținerea.

Modalități de implementare:

Prin constructor (Constructor Injection): Dependențele sunt transmise prin constructorul clasei. Este cea mai recomandată metodă, deoarece garantează prezența dependențelor de la momentul creării obiectului.

// Clasă cu dependență
public class MyService {
    private MyDependency dependency;

    // Injectare prin constructor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Utilizarea dependenței
    public void doSomething() {
        dependency.performAction();
    }
}

// Dependență
public interface MyDependency {
    void performAction();
}

// Exemplu de implementare a dependenței
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("Acțiune realizată!");
    }
}

Prin setter (Setter Injection): Dependențele sunt transmise prin metode setter publice. Permite crearea obiectelor cu dependențe la cerere, dar necesită verificări pentru null și nu garantează prezența tuturor dependențelor imediat.

// Clasă cu dependență
public class AnotherService {
    private AnotherDependency dependency;

    // Constructor gol
    public AnotherService() {
    }

    // Injectare prin setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Utilizarea dependenței
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("Dependența nu este setată!");
        }
    }
}

// Dependență
public interface AnotherDependency {
    void anotherAction();
}

// Exemplu de implementare a dependenței
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("Altă acțiune realizată!");
    }
}

Prin câmp (Field Injection): Dependențele sunt injectate direct în câmpurile clasei folosind adnotări. Este cea mai simplă sintaxă, dar face clasa dependentă de framework-ul DI și complică testarea fără framework.

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

// Clasă cu dependență
public class SomeOtherService {

    // Injectare prin câmp (cu adnotarea Spring)
    @Autowired
    private YetAnotherDependency dependency;

    // Utilizarea dependenței
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Dependență
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Exemplu de implementare a dependenței
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("Yana bir harakat bajarildi!");
    }
}

Compararea modurilor de implementare:

Mod de implementare	Avantaje	Dezavantaje
Prin constructor	Garantează prezența dependențelor, testare ușoară, imutabilitate	Poate duce la "dependență de parametri" în constructor dacă există multe dependențe
Prin setter	Opționalitatea dependențelor, posibilitatea de a modifica dependențele după creare	Necesită verificări pentru null, nu garantează starea completă a obiectului după creare
Prin câmp	Sintaxă scurtă	Dependență puternică de framework-ul DI, complică testarea fără framework

DI este un principiu cheie în multe framework-uri moderne (de exemplu, Spring, CDI) și contribuie la crearea de aplicații slab cuplate și ușor de testat.

Care este caracteristica injecției de dependențe (Dependency Injection)?