¿En qué consiste la característica de la inyección de…

La característica principal de la inyección de dependencias (DI) es que la creación y gestión de dependencias de un objeto se traslada desde el propio objeto hacia afuera, generalmente a un contenedor IoC (Inversión de Control). En lugar de que el objeto cree o encuentre sus dependencias, estas se "inyectan" desde fuera.

Las principales ventajas y características de DI:

Separación de responsabilidades: La clase no es responsable de crear sus dependencias.
Testabilidad: Las dependencias se pueden sustituir fácilmente por mocks o stubs durante las pruebas unitarias.
Flexibilidad: Es fácil cambiar las implementaciones de las dependencias sin modificar el código que las utiliza.
Menor acoplamiento: Los componentes son menos fuertemente acoplados, lo que mejora la mantenibilidad.

Formas de inyección:

A través del constructor (Constructor Injection): Las dependencias se pasan mediante el constructor de la clase. Es la forma más preferida, ya que garantiza la disponibilidad de las dependencias desde la creación del objeto.

// Clase con dependencia
public class MyService {
    private MyDependency dependency;

    // Inyección mediante constructor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Uso de la dependencia
    public void doSomething() {
        dependency.performAction();
    }
}

// Dependencia
public interface MyDependency {
    void performAction();
}

// Implementación de la dependencia
public class MyDependencyImpl implements MyDependency {
    @Override
    public void performAction() {
        System.out.println("¡Acción realizada!");
    }
}

A través del setter (Setter Injection): Las dependencias se pasan mediante métodos públicos setters. Permite crear objetos con dependencias según sea necesario, pero requiere verificaciones adicionales de null y no garantiza la presencia de todas las dependencias de inmediato.

// Clase con dependencia
public class AnotherService {
    private AnotherDependency dependency;

    // Constructor vacío
    public AnotherService() {
    }

    // Inyección mediante setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // Uso de la dependencia
    public void doSomethingElse() {
        if (dependency != null) {
            dependency.anotherAction();
        } else {
            System.out.println("¡Dependencia no establecida!");
        }
    }
}

// Dependencia
public interface AnotherDependency {
    void anotherAction();
}

// Implementación de la dependencia
public class AnotherDependencyImpl implements AnotherDependency {
    @Override
    public void anotherAction() {
        System.out.println("¡Otra acción realizada!");
    }
}

A través del campo (Field Injection): Las dependencias se inyectan directamente en los campos de la clase mediante anotaciones. Es la más sencilla en sintaxis, pero hace que la clase dependa del framework DI y dificulta las pruebas sin el framework.

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

// Clase con dependencia
public class SomeOtherService {

    // Inyección mediante campo (usando anotación de Spring)
    @Autowired
    private YetAnotherDependency dependency;

    // Uso de la dependencia
    public void doYetAnotherThing() {
        dependency.performYetAnotherAction();
    }
}

// Dependencia
public interface YetAnotherDependency {
    void performYetAnotherAction();
}

// Implementación de la dependencia
public class YetAnotherDependencyImpl implements YetAnotherDependency {
    @Override
    public void performYetAnotherAction() {
        System.out.println("¡Otra acción más realizada!");
    }
}

Comparación de métodos de inyección:

Método de inyección	Ventajas	Desventajas
A través del constructor	Garantiza la presencia de dependencias, facilita las pruebas, inmutable	Puede llevar a "dependencia de parámetros" en el constructor cuando hay muchas dependencias
A través del setter	Dependencias opcionales, permite cambiar dependencias después de crear el objeto	Requiere verificaciones de null, no garantiza el estado completo del objeto tras la creación
A través del campo	Sintaxis concisa	Alta dependencia del framework DI, dificulta las pruebas sin el framework

El DI es un principio clave en muchos frameworks modernos (por ejemplo, Spring, CDI) y ayuda a crear aplicaciones con bajo acoplamiento y fácil de probar.

¿En qué consiste la característica de la inyección de dependencias (Dependency Injection)?