Wat is het verschil tussen Inversion of Control (IoC)…

Omkering van controle (IoC) is een algemeen ontwerpprincipe waarbij de stroom van controle in een programma verandert: in plaats van expliciet afhankelijkheden en de logica van hun aanroep te beheren, vertrouwt de component op een extern framework of container die deze stroom beheert.

Dependency Injection (DI) is een van de specifieke patronen die het IoC-principe implementeren. Het bestaat uit het doorgeven van afhankelijkheden (objecten waarvan de huidige component afhankelijk is) aan de component van buitenaf, in plaats van dat de component ze zelf creëert of zoekt.

Dus, DI is een manier om IoC te bereiken.

De belangrijkste verschillen:

IoC — principe/concept.
DI — patroon/implementatie.
IoC kan op verschillende manieren worden geïmplementeerd (bijvoorbeeld fabrieksmethode, service locator), DI is een van die manieren.
IoC verschuift de verantwoordelijkheid voor het maken en koppelen van objecten van de component naar het framework of de container.
DI voert deze verschuiving uit door afhankelijkheden via de constructor, setter of interface door te geven.

Voorbeeld van DI (constructor):

// klasse die afhankelijk is van Service
public class Client {
    private final Service service;

    // Constructor neemt afhankelijkheid (Service) aan
    public Client(Service service) {
        this.service = service;
    }

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

// afhankelijkheidsinterface
public interface Service {
    void execute();
}

// concrete implementatie van afhankelijkheid
public class ServiceImpl implements Service {
    @Override
    public void execute() {
        System.out.println("Service wordt uitgevoerd...");
    }
}

// klasse die "injectie" verzorgt
public class AppConfig {
    public static void main(String[] args) {
        Service myService = new ServiceImpl(); // afhankelijkheid maken
        Client client = new Client(myService); // afhankelijkheid via constructor injecteren
        client.doSomething();
    }
}

In dit voorbeeld creëert de klasse Client niet direct ServiceImpl. In plaats daarvan wordt ServiceImpl elders (AppConfig) gemaakt en doorgegeven (geïnjecteerd) aan Client via de constructor. Dit implementeert het IoC-principe, omdat het beheer van het maken en koppelen van Service is omgekeerd — het ligt niet in Client.

Wat is het verschil tussen Inversion of Control (IoC) en Dependency Injection?