# Spring Boot Inyección de Dependencias
La inyección de dependencias es un patrón de diseño utilizado para gestionar las relaciones entre objetos de manera más flexible y desacoplada. Permite que los objetos reciban sus dependencias desde una fuente externa en lugar de crearlas por sí mismos, lo que mejora la modularidad y facilita las pruebas.

Spring Boot aprovecha fuertemente la programación orientada a interfaces como una buena práctica de diseño, especialmente en la inyección de dependencias, donde los objetos no se instancian explícitamente. En su lugar, el contenedor de Spring (IoC container) se encarga de crear e inyectar las dependencias necesarias.

La inyección de dependencias es una técnica que ayuda a construir aplicaciones más modulares, flexibles y fáciles de mantener, ya que las dependencias de un objeto sean gestionadas de forma externa.

## Dependencia
Una dependencia es cualquier objeto que otra clase necesita para funcionar. Por ejemplo, una clase de servicio puede necesitar una instancia de un repositorio para acceder a los datos.

## Inyección
La inyección consiste en proporcionar esas dependencias desde el exterior, en lugar de que la propia clase las cree. Esto se realiza mediante un contenedor o framework (como Spring), lo que promueve un diseño más desacoplado y fácil de mantener.

## Tipos de Inyección de Dependencias
- Inyección por Atributo o Campo
- Inyección por Constructor
- Inyección por Setter

# Beans
Un bean en Spring es un objeto que es instanciado, configurado, ensamblado y gestionado por el contenedor de Spring.

Los beans pueden ser configurados de varias formas, incluyendo anotaciones como @Component, @Service, @Repository y @Controller.

También pueden ser configurados en archivos XML y configuración Java con clases anotadas con @Configuration.

## Configuración basada en XML

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

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

    <bean id="myRepository" class="com.example.MyRepository"/>

</beans>

## Configuración basada en Java con clases anotadas con @Configuration

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService(myRepository());
    }

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }
}

Luego, en otra parte de la aplicación, podríamos inyectar ese bean:

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

@Component
public class MiControlador {

    @Autowired
    private MyService myService;

    public void ejecutar() {
        myService.procesar();
    }
}

## Ciclo de Vida de un Bean
Los beans tienen un ciclo de vida que puede incluir métodos de inicialización y destrucción, permitiendo a los desarrolladores ejecutar lógica específica en esos momentos.
1. Creación: El contenedor de Spring instancia el bean.
2. Inicialización: Se ejecutan los métodos de inicialización (@PostConstruct, métodos definidos en la configuración).
3. Uso: El bean está listo para ser utilizado por la aplicación.
4. Destrucción: Se ejecutan los métodos de destrucción (@PreDestroy, métodos definidos en la configuración) antes de que el bean sea destruido.

### Inicialización de un Bean usando @PostConstruct
@PostConstruct se usa para definir un método que debe ejecutarse después de que el Bean haya sido completamente inicializado por el contenedor (por ejemplo, Spring). Este método se ejecuta después de que se inyecten todas las dependencias y se construya el Bean. También se puede utilizar el constructor para inicializar un Bean, pero con la diferencia de que el constructor se ejecutará antes de que se inyecten todas las dependencias del Bean.

import javax.annotation.PostConstruct;

public class MyBean {

    @PostConstruct
    public void init() {
        System.out.println("Bean inicializado mediante @PostConstruct");
    }
}

### Destrucción de un Bean usando @PreDestroy
@PreDestroy se usa para definir un método que debe ejecutarse justo antes de que el Bean sea destruido por el contenedor. Este método es útil para liberar recursos, cerrar conexiones, etc.

import javax.annotation.PreDestroy;

public class MyBean {

    @PreDestroy
    public void destroy() {
        System.out.println("Bean destruido mediante @PreDestroy");
    }
}

# @Autowired
se utiliza para inyectar automáticamente las dependencias de un bean en otro bean. Es parte del soporte de inyección de dependencias de Spring y permite al framework resolver e inyectar automáticamente los componentes necesarios en los lugares apropiados.

### Ejemplo de Inyección por Atributo o Campo
En el siguiente ejemplo el servicio `MyService` esta siendo inyectado por el repositorio `MyRepository`.

import org.springframework.stereotype.Component;

@Component
public class MyRepository {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

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

@Service
public class MyService {
    
    @Autowired
    private MyRepository myRepository;

    public void someOperation() {
        myRepository.doSomething();
    }
}

### Ejemplo de Inyección por Constructor

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

@Service
public class MyService {
    
    private MyRepository myRepository;
    
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
    
    public void someOperation() {
        myRepository.doSomething();
    }
}

**Nota:** En la inyección de dependencias por constructor no es necesario especificar la anotación `@Autowired`, ya que por defecto Spring reconoce que se trata de una inyección.

### Ejemplo de Inyección por Setter

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

@Service
public class MyService {
    
    private MyRepository myRepository;
    
    @Autowired
    public void setMyRepository(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
    
    public void someOperation() {
        myRepository.doSomething();
    }
}

**Nota:** Al utilizar la inyección por constructor o setter, el parámetro que se recibe es el bean gestionado por el contenedor de Spring.

## Inyección Mediante Interfaces
Inyectar dependencias mediante interfaces es una práctica común y recomendada en la programación orientada a objetos y, especialmente, en el desarrollo de aplicaciones Spring.

Supongamos que tenemos una interfaz `NotificationService` y dos implementaciones: `EmailNotificationService` y `SmsNotificationService`.

public interface NotificationService {
    void sendNotification(String message);
}

import org.springframework.stereotype.Service;

@Service
public class EmailNotificationService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending email with message: " + message);
    }
}

import org.springframework.stereotype.Service;

@Service
public class SmsNotificationService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending SMS with message: " + message);
    }
}

Ahora en el controlador inyectaríamos la interfaz `NotificationService` mas no el servicio directamente.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final NotificationService notificationService;

    @Autowired
    public UserController(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void someOperation() {
        notificationService.sendNotification();
    }
}

Sin embargo esto nos daría un error, ya que Sprig no sabría cual de los dos servicios inyectar, para ello, podemos hacer uso de las anotacion `@Primary` y `@Qualifier`.

## @Primary
La anotación @Primary se usa para marcar un bean como la opción preferida cuando hay múltiples beans del mismo tipo disponibles. Si no se especifica explícitamente un bean con @Qualifier, Spring inyectará el bean marcado con @Primary.

En este ejemplo, EmailNotificationService está marcado con @Primary. Si Spring encuentra múltiples beans del tipo NotificationService, inyectará PrimaryUserService por defecto.

import org.springframework.stereotype.Service;

@Service
@Primary
public class EmailNotificationService implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending email with message: " + message);
    }
}

## @Qualifier
La anotación @Qualifier se utiliza para especificar cuál bean debe ser inyectado cuando hay múltiples beans del mismo tipo disponibles. Esto se hace proporcionando un nombre de calificador que coincide con el nombre del bean que se desea inyectar.

En este ejemplo, UserController inyecta específicamente SmsNotificationService utilizando @Qualifier.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    private final NotificationService notificationService;

    @Autowired
    public UserController(@Qualifier("smsNotificationService") NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void someOperation() {
        notificationService.sendNotification();
    }
}

**Nota:** @Qualifier tiene prioridad sobre @Primary. Si se especifica @Qualifier, Spring inyectará el bean correspondiente al @Qualifier, ignorando el bean anotado con @Primary.

# Scopes (contextos)
En Spring, los scopes (contextos) determinan el ciclo de vida y la visibilidad de los beans dentro del contenedor. Hay varios tipos de contextos, pero los más comunes son Singleton, RequestScope y SessionScope.

## Singleton Scope
Es el scope por defecto en Spring. En este contexto, el contenedor de Spring crea una única instancia del bean para todo el ciclo de vida de la aplicación.

Características
- Ciclo de vida: Toda la aplicación.
- Visibilidad: Global dentro del contenedor de Spring.
- Uso típico: Beans que contienen lógica sin estado (stateless) o que deben compartirse a lo largo de toda la aplicación.

## Request Scope
En este contexto, Spring crea una nueva instancia del bean para cada solicitud HTTP. Se utiliza principalmente en APIs.

Características
- Ciclo de vida: Una solicitud HTTP.
- Visibilidad: Dentro de la misma solicitud HTTP.
- Uso típico: Beans que contienen lógica dependiente de una única solicitud HTTP.

## Session Scope

En este contexto, Spring crea una nueva instancia del bean para cada sesión HTTP. Se utiliza principalmente en aplicaciones web.

Características
- Ciclo de vida: Una sesión HTTP.
- Visibilidad: Dentro de la misma sesión HTTP.
- Uso típico: Beans que deben mantener datos específicos de un usuario durante su sesión en la aplicación.

# @Value
se utiliza para inyectar valores en los campos de una clase desde el archivo de configuración (por ejemplo, application.properties o application.yml) o desde otros recursos como variables de entorno o valores predeterminados. Esta anotación es útil para inyectar valores constantes o configuraciones que no cambian durante la ejecución de la aplicación.

Por ejemplo, en application.properties:

my.property.value=Hello, Spring!

Luego, en alguna clase de nuestro proyecto, podemos utilizarla con la anotación @Value para inyectar este valor:

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @Value("${my.property.value}")
    private String myValue;

    public void printValue() {
        System.out.println(myValue);
    }
}

# Archivo de propiedades de la aplicación
El archivo de propiedades de la aplicación **(application.properties o application.yml)** en Spring Boot es un archivo de configuración ubicado en `src/main/resources`, que permite definir valores externos al código fuente para personalizar el comportamiento de la aplicación.
Se utiliza para configurar propiedades como el puerto del servidor, los datos de conexión a bases de datos, parámetros personalizados, perfiles de entorno, entre otros.
Además, como se vio anteriormente, facilita la inyección de valores en clases mediante anotaciones como @Value o @ConfigurationProperties, lo que hace que la aplicación sea más flexible, mantenible y adaptable a distintos entornos sin necesidad de recompilar.

# Referencias circulares
Las referencias circulares ocurren cuando dos o más *beans* se dependen mutuamente entre sí, creando un ciclo que impide que el contenedor de Spring los inicialice correctamente.

Ejemplo

@Service
public class ServicioA {
    private final ServicioB servicioB;

    @Autowired
    public ServicioA(@Lazy ServicioB servicioB) {
        this.servicioB = servicioB;
    }
}

@Service
public class ServicioB {
    private final ServicioA servicioA;

    @Autowired
    public ServicioB(ServicioA servicioA) {
        this.servicioA = servicioA;
    }
}

Aquí, Spring no puede crear ServicioA sin ServicioB, ni ServicioB sin ServicioA, y eso genera un error de referencia circular.

En Spring 6 y Spring Boot 3 (y versiones recientes), por defecto se lanza un error como este: `The dependencies of some of the beans in the application context form a cycle...`

**¿Cómo se soluciona?**
- Reestructurando el diseño **(es lo ideal)**: evita que los beans se dependan mutuamente. “Deberíamos intentar rediseñar los componentes correctamente para que su jerarquía esté bien diseñada y no se necesiten dependencias circulares.” (Hombergs T, 2024)
- Usando `@Lazy` en una de las dependencias: esto retrasa la creación de uno de los beans, rompiendo el ciclo:

@Component
public class ServicioA {
    @Autowired
    @Lazy
    private ServicioB servicioB;
}

- Constructor vs Setter Injection: a veces, usar inyección por setter en lugar de constructor puede ayudar con la carga diferida.
- Evitar lógica fuerte en constructores: deja la lógica pesada para métodos @PostConstruct o inicialización posterior.

Para mas información [Dependencias circulares en Spring](https://www.baeldung.com/circular-dependencies-in-spring)

# Bibliografía
Guzmán, A. (s. f.). *Spring Framework 6 & Spring Boot 3 desde cero a experto.* Udemy. https://www.udemy.com/course/spring-framework-5

Hombergs, T. (2024, mayo 11). *Dependencias circulares en Spring.* Baeldung. https://www.baeldung.com/circular-dependencies-in-spring