¿En qué consiste la diferencia entre inversión de control (IoC) y inyección de dependencias?

La inversión de control (IoC) es un principio de diseño general según el cual el flujo de control de un programa cambia: en lugar de gestionar explícitamente las dependencias y la lógica de su llamada, el componente confía en un marco externo o contenedor que gestiona ese flujo.

La inyección de dependencias (DI) es uno de los patrones específicos que implementan el principio IoC. Consiste en pasar las dependencias (objetos de los que depende el componente actual) al componente desde fuera, en lugar de que el componente las cree o busque por sí mismo.

Por lo tanto, DI es una forma de lograr IoC.

Las principales diferencias:

• IoC — principio/concepto.
• DI — patrón/implementación.
• IoC puede ser implementado de diferentes maneras (por ejemplo, método de fábrica, localizador de servicios), DI es una de esas maneras.
• IoC traslada la responsabilidad de crear y enlazar objetos desde el componente hacia el marco/contenedor.
• DI realiza este traslado, pasando las dependencias a través del constructor, setter o interfaz.

Ejemplo de DI (constructor):

// clase que depende de Service
public class Client {
    private final Service service;

    // El constructor recibe la dependencia (Service)
    public Client(Service service) {
        this.service = service;
    }

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

// Interfaz de dependencia
public interface Service {
    void execute();
}

// Implementación concreta de la dependencia
public class ServiceImpl implements Service {
    @Override
    public void execute() {
        System.out.println("Ejecutando servicio...");
    }
}

// Clase responsable de la "inyección"
public class AppConfig {
    public static void main(String[] args) {
        Service myService = new ServiceImpl(); // Creación de la dependencia
        Client client = new Client(myService); // Inyección de dependencia a través del constructor
        client.doSomething();
    }
}

En este ejemplo, la clase Client no crea directamente ServiceImpl. En cambio, ServiceImpl se crea en otro lugar (AppConfig) y se pasa (inyecta) en Client a través de su constructor. Esto implementa el principio IoC, ya que la gestión de la creación y la vinculación de Service está invertida: no está en Client.