Care este diferența dintre inversiunea de control…

Inversiunea controlului (IoC) este un principiu general de proiectare conform căruia fluxul de control al unui program se schimbă: în loc să gestioneze explicit dependențele și logica apelurilor lor, componenta se bazează pe un framework sau container extern care gestionează acest flux.

Injecția de dependențe (DI) este unul dintre modelele specifice care implementează principiul IoC. Aceasta constă în transmiterea dependențelor (obiecte de care depinde componenta curentă) către componentă din exterior, în loc ca aceasta să le creeze sau să le caute singură.

Prin urmare, DI este o modalitate de a realiza IoC.

Principalele diferențe:

IoC — principiu/concept.
DI — model/implementare.
IoC poate fi implementat în diferite moduri (de exemplu, metodă de fabrică, localizator de servicii), DI fiind unul dintre aceste moduri.
IoC transferă responsabilitatea de a crea și lega obiecte de componentă către framework sau container.
DI realizează această transferare, transmitând dependențele prin constructor, setter sau interfață.

Exemplu de DI (constructor):

// clasă dependentă de Service
public class Client {
    private final Service service;

    // Constructorul primește dependența (Service)
    public Client(Service service) {
        this.service = service;
    }

    public void doSomething() {
        service.execute();
    }
}

// Interfața de dependență
public interface Service {
    void execute();
}

// Implementarea concretă a dependenței
public class ServiceImpl implements Service {
    @Override
    public void execute() {
        System.out.println("Executarea serviciului...");
    }
}

// Clasa responsabilă pentru "injecție"
public class AppConfig {
    public static void main(String[] args) {
        Service myService = new ServiceImpl(); // Crearea dependenței
        Client client = new Client(myService); // Injecție de dependență prin constructor
        client.doSomething();
    }
}

În acest exemplu, clasa Client nu creează direct ServiceImpl. În schimb, ServiceImpl este creat în altă parte (AppConfig) și transmis (injecționat) în Client prin constructorul său. Acest lucru implementează principiul IoC, deoarece controlul creării și legării Service este inversat — nu se află în Client.

Care este diferența dintre inversiunea de control (IoC) și injecția de dependențe?