La inversión de control (IoC) y la inyección de dependencia (DI) son dos conceptos fundamentales en Spring Framework. Tradicionalmente, los objetos son responsables de crear y gestionar sus propias dependencias. Sin embargo, IoC invierte esta responsabilidad entregando el control de la creación de objetos y la gestión de dependencias a un marco como Spring.

Este turno ofrece varias ventajas:

• Intercambio de implementaciones más sencillo: se pueden intercambiar diferentes implementaciones con cambios mínimos en el código base.
• Mayor modularidad: los componentes de la aplicación se vuelven más modulares, lo que facilita la separación de preocupaciones.
• Capacidad de prueba mejorada: los componentes se pueden probar de forma aislada, lo que simplifica las burlas y otras estrategias de prueba.

IoC se puede implementar a través de varios mecanismos, incluidos patrones de diseño como el patrón de fábrica, el patrón de estrategia o el patrón de localización de servicios. Sin embargo, la forma más común y poderosa de lograr IoC es mediante la inyección de dependencia.

Comprender la inyección de dependencia

La inyección de dependencia (DI) es una técnica en la que el marco inyecta dependencias en un objeto en lugar de que el objeto cree las dependencias en sí. Hay diferentes tipos de DI en primavera:

• Inyección de constructor: Las dependencias se proporcionan a través del constructor de la clase.
• Inyección de setter: Las dependencias se inyectan mediante métodos de setter.
• Inyección de campo: Las dependencias se asignan directamente a los campos mediante anotaciones.

Por ejemplo, en una clase de servicio simple, es posible que veas algo como esto:

@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processOrder(Order order) {
        paymentService.processPayment(order.getPaymentDetails());
    }
}

Aquí, PaymentService se inyecta en OrderService mediante inyección de constructor, que generalmente se prefiere por sus dependencias claras y su facilidad de prueba.

Contenedor de COI: BeanFactory frente a ApplicationContext

Spring proporciona un contenedor de IoC que es responsable de administrar el ciclo de vida de los beans (objetos administrados por Spring). La interfaz básica para este contenedor es BeanFactory. Sin embargo, la mayoría de las aplicaciones utilizan ApplicationContext, que amplía BeanFactory y ofrece funciones adicionales.

fábrica de frijoles

• Contenedor IoC básico: Proporciona funcionalidades básicas para crear y gestionar beans.
• Inicialización diferida: Los beans se crean cuando se solicitan por primera vez.

Contexto de aplicación

• Contenedor IoC avanzado: Además de las características básicas de BeanFactory, proporciona:
  • Soporte de internacionalización (i18n)
  • Propagación y manejo de eventos
  • Manejo de solicitudes asincrónicas
  • Integración con Programación Orientada a Aspectos (AOP)
• Inicialización ansiosa: se pueden crear instancias de beans cuando se inicia la aplicación, haciéndolos disponibles para su uso inmediato.

Ejemplo:

// Getting a bean from the ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyBean myBean = context.getBean(MyBean.class);

En este ejemplo, ApplicationContext se utiliza para recuperar un bean. Si estuviera utilizando un BeanFactory básico, ofrecería una funcionalidad similar pero sin los beneficios adicionales de ApplicationContext.

Accediendo al contexto de la aplicación

Hay dos formas comunes de acceder al ApplicationContext actual:

1. Autowired: Inyecte ApplicationContext directamente en su componente.
   

   @Autowired
   private ApplicationContext applicationContext;
   

2. ApplicationContextAware: implementa la interfaz ApplicationContextAware, que te permite recuperar ApplicationContext según sea necesario.
   

   public class MyBean implements ApplicationContextAware {
       private ApplicationContext applicationContext;
   
       @Override
       public void setApplicationContext(ApplicationContext context) throws BeansException {
           this.applicationContext = context;
       }
   }
   

Ciclo de vida de una aplicación Spring

Cuando se inicia una aplicación Spring, se llevan a cabo una serie de pasos:

1. Procesamiento de variables y propiedades de entorno: Se crea el objeto de entorno, incorporando configuraciones de application.properties o application.yml.

2. Creación del ApplicationContext: Se determina y crea una instancia del tipo de ApplicationContext apropiado. Por ejemplo, una aplicación Spring Boot puede usar AnnotationConfigServletWebServerApplicationContext para configuraciones basadas en Java.

3. Cargando definiciones de beans: Spring carga definiciones de beans de múltiples fuentes, como clases anotadas, clases @Configuration o archivos XML. Cada definición de bean incluye información sobre el tipo, alcance, dependencias y devoluciones de llamada del ciclo de vida del bean.

4. Procesamiento de BeanFactoryPostProcessors: estos procesadores modifican las definiciones de los beans antes de que se creen los beans reales.

5. Resolución de dependencias y creación de beans: ApplicationContext resuelve las dependencias y crea los beans. Si un bean tiene dependencias de otros beans, esas dependencias se crean primero.

Alcances de frijol en primavera

Spring admite varios alcances de beans, que definen el ciclo de vida y la visibilidad de un bean dentro del contenedor:

• Singleton (predeterminado): se crea una única instancia del bean para todo el contexto de la aplicación.
• Prototipo: se crea una nueva instancia cada vez que se solicita el bean.
• Solicitud: se crea una nueva instancia de bean para cada solicitud HTTP (aplicaciones web).
• Sesión: Se crea una nueva instancia de bean para cada sesión HTTP (aplicaciones web).

Ejemplo:

@Bean
@Scope("prototype")
public MyPrototypeBean myPrototypeBean() {
    return new MyPrototypeBean();
}

En este ejemplo, se crea una nueva instancia de MyPrototypeBean cada vez que se solicita desde el contenedor.

Objetos proxy en ámbitos Bean

Considere un escenario en el que un bean con ámbito Singleton depende de un bean con ámbito Prototipo. Normalmente, el bean prototipo solo se crearía una vez durante la inicialización del singleton. Para garantizar que se proporcione una nueva instancia del bean prototipo cada vez, Spring utiliza objetos proxy.

Ejemplo con Proxies:

@Component
@Scope(value = "singleton")
public class SingletonBean {

    @Autowired
    @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
    private PrototypeBean prototypeBean;

    public void showMessage() {
        System.out.println(prototypeBean.getMessage());
    }
}

Aquí, ScopedProxyMode.TARGET_CLASS garantiza que se devuelva una nueva instancia de PrototypeBean cada vez que se llama a getMessage().

Diferencia entre Spring Framework y Spring Boot

Spring Boot es una extensión de Spring Framework que simplifica la configuración y el desarrollo de nuevas aplicaciones Spring. Proporciona:

• Servidores de aplicaciones integrados: ejecute fácilmente aplicaciones Spring como aplicaciones independientes con Tomcat, Jetty o Undertow integrados.
• Configuración automática: configura beans automáticamente según el classpath y otras configuraciones.
• Embalaje simplificado: Empaquetar aplicaciones como JAR o WAR ejecutables.
• Monitoreo integrado y controles de estado: puntos finales integrados para monitorear el estado y la salud de la aplicación.

Configuración automática en Spring Boot

La configuración automática es una característica poderosa en Spring Boot que configura muchas cosas para usted en función de las dependencias en su classpath. Esto está controlado por anotaciones condicionales como:

• @ConditionalOnClass
• @ConditionalOnMissingClass
• @ConditionalOnBean
• @ConditionalOnMissingBean

Ejemplo:

Por ejemplo, si tiene Jackson en su classpath, Spring Boot configurará automáticamente un ObjectMapper para la serialización JSON:

@Configuration
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {
    // Configuration details...
}

Si ObjectMapper está presente, esta configuración se aplica automáticamente. De lo contrario, se omite.

Visualización de configuraciones automáticas activas

Puedes registrar las configuraciones automáticas activas durante el inicio agregando lo siguiente a tus propiedades de aplicación:

logging.level.org.springframework.boot.autoconfigure=DEBUG

Esto generará un informe detallado que muestra qué configuraciones se aplicaron y cuáles no, lo que le ayudará a solucionar problemas o comprender la configuración de la aplicación.

Conclusión

La inversión de control y la inyección de dependencias son conceptos centrales que permiten la flexibilidad, modularidad y capacidad de prueba que hacen que Spring sea tan poderoso. Al comprender cómo funciona el contenedor IoC de Spring, cómo se administran los beans y cómo Spring Boot amplía estas capacidades, podrá desarrollar aplicaciones sólidas y fáciles de mantener de manera más eficiente.