¿Qué es la integración dependiente y qué beneficios…

La inyección de dependencias (Dependency Injection, DI) es un patrón de diseño en el que los componentes reciben sus dependencias desde fuera, en lugar de crearlas por sí mismos. Es uno de los principios de la inversión de control (Inversion of Control, IoC).

Beneficios de DI:

Mejora de la testabilidad: Es más fácil sustituir dependencias por mocks o stubs durante las pruebas unitarias.
Reducción del acoplamiento (Loose Coupling): Los componentes dependen menos de implementaciones específicas de dependencias.
Mayor flexibilidad y extensibilidad: Es fácil cambiar las implementaciones de dependencias sin modificar el código principal del componente.
Mejora de la legibilidad y mantenibilidad: Es claro qué dependencias requiere un componente.

Ejemplo sin DI vs con DI:

Sin DI:

// Clase que crea una dependencia internamente
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Acoplamiento fuerte: crea una implementación concreta
        this.dbConnection = new OracleConnection(); 
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }
}

Con DI (a través del constructor):

// Interfaz de la dependencia
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Diferentes implementaciones
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectando a Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Desconectando de Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectando a MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Desconectando de MySQL...");
    }
}

// Clase que recibe la dependencia desde fuera
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Inyección de dependencia a través del constructor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }

    public void setDbConnection(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }
}

// Código que realiza la inyección (configuración)
public class Application {
    public static void main(String[] args) {
        // Crear la dependencia
        DatabaseConnection connection = new MySQLConnection(); 
        // Inyectar la dependencia en ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // O cambiar la dependencia sin modificar ServiceB
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Formas de inyección:

A través del constructor (Constructor Injection): Las dependencias se proporcionan mediante el constructor de la clase. Es la forma preferida para dependencias obligatorias.
A través del setter (Setter Injection): Las dependencias se proporcionan mediante métodos setters. Es adecuada para dependencias opcionales.
A través del campo (Field Injection): Las dependencias se inyectan directamente en los campos de la clase (usualmente con frameworks, requiere reflexión). No se recomienda sin frameworks de DI debido a la dificultad en las pruebas y ocultamiento de dependencias.

La DI a menudo se implementa mediante contenedores/frameworks de DI, como Spring, Guice, Dagger, que gestionan el ciclo de vida de los objetos y automatizan el proceso de inyección.

¿Qué es la integración dependiente y qué beneficios aporta?