¿Cómo se puede aplicar la inyección de dependencias…

El contenedor IoC de Spring gestiona el ciclo de vida de los Beans de Spring (objetos). Los Beans son los bloques constructores principales de las aplicaciones Spring. La inyección de dependencias (DI) usando Beans de Spring se realiza mediante configuración que indica al contenedor cómo crear y enlazar componentes.

Hay tres formas principales de inyectar dependencias en Spring:

Inyección mediante constructor: Spring llama al constructor correspondiente de la clase al crear el Bean. Es el método preferido, ya que garantiza que todas las dependencias necesarias se inicialicen al crear el objeto y permite hacer que las dependencias sean inmutables.
Inyección mediante setter: Spring llama a los métodos setters de la clase para establecer dependencias después de crear el Bean. Este método es útil para dependencias opcionales.
Inyección mediante campo: Spring usa reflexión para inyectar directamente dependencias en los campos de la clase. No se recomienda, ya que dificulta las pruebas y viola la encapsulación.

La configuración para la inyección de dependencias puede realizarse mediante:

Anotaciones: @Autowired, @Qualifier, @Value. Enfoque más común en las aplicaciones Spring modernas.

// Ejemplo de inyección mediante constructor con anotación
@Component // Hacemos que la clase sea un Bean de Spring
public class MyService {

    private final MyDependency dependency;

    @Autowired // Indica a Spring que inyecte la dependencia a través del constructor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class MyDependency {
    // ...
}

// Ejemplo de inyección mediante setter con anotación
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Indica a Spring que inyecte la dependencia a través del setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class AnotherDependency {
    // ...
}

// Ejemplo de inyección mediante campo con anotación (no recomendado)
@Component
public class FieldInjectedService {

    @Autowired // Indica a Spring que inyecte la dependencia en el campo
    private FinalDependency dependency;

    // ...
}

@Component
public class FinalDependency {
    // ...
}

Configuración XML: Se usa en proyectos más antiguos o específicos.

<!-- Ejemplo de inyección mediante constructor en XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency"/>
    </bean>
</beans>

<!-- Ejemplo de inyección mediante setter en XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

    <bean id="anotherService" class="com.example.AnotherService">
        <property name="dependency" ref="anotherDependency"/>
    </bean>
</beans>

Configuración Java (usando @Configuration y @Bean): Enfoque moderno que permite configurar el contenedor Spring mediante código Java.

// Ejemplo de configuración Java
@Configuration // Indica que esta es una clase de configuración
public class AppConfig {

    @Bean // Declara el Bean myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Declara el Bean myService
    public MyService myService(MyDependency myDependency) {
        // Inyección mediante constructor al crear el Bean
        return new MyService(myDependency);
    }
}

El contenedor IoC de Spring escanea la configuración (anotaciones, XML, clases Java), crea instancias de Beans, gestiona su ciclo de vida e inyecta dependencias automáticamente. Esto reduce la acoplamiento de componentes, facilita las pruebas (puedes reemplazar fácilmente las dependencias con objetos mock) y hace que el código sea más mantenible.

¿Cómo se puede aplicar la inyección de dependencias usando Spring Bean?