Spring - Postprocesadores de frijoles

los BeanPostProcessor La interfaz define métodos de devolución de llamada que puede implementar para proporcionar su propia lógica de creación de instancias, lógica de resolución de dependencia, etc. También puede implementar alguna lógica personalizada después de que el contenedor Spring termine de instanciar, configurar e inicializar un bean conectando una o más implementaciones de BeanPostProcessor .

Puede configurar múltiples interfaces BeanPostProcessor y puede controlar el orden en el que se ejecutan estas interfaces BeanPostProcessor configurando el order propiedad siempre que el BeanPostProcessor implemente la Ordered interfaz.

Los BeanPostProcessors operan en instancias de bean (u objeto), lo que significa que el contenedor Spring IoC crea una instancia de bean y luego las interfaces BeanPostProcessor hacen su trabajo.

Un ApplicationContext detecta automáticamente los beans que se definen con la implementación del BeanPostProcessor interfaz y registra estos beans como posprocesadores, para luego ser llamados apropiadamente por el contenedor al crear el bean.

Ejemplo

Los siguientes ejemplos muestran cómo escribir, registrar y utilizar BeanPostProcessors en el contexto de un ApplicationContext.

Tengamos un IDE de Eclipse en funcionamiento y sigamos los siguientes pasos para crear una aplicación Spring:

Pasos	Descripción
1	Cree un proyecto con un nombre SpringExample y cree un paquete com.tutorialspoint bajo elsrc carpeta en el proyecto creado.
2	Agregue las bibliotecas Spring requeridas usando la opción Agregar JAR externos como se explica en el capítulo Ejemplo de Spring Hello World .
3	Cree clases de Java HelloWorld , InitHelloWorld y MainApp en el paquete com.tutorialspoint .
4	Cree el archivo de configuración de Beans Beans.xml bajo elsrc carpeta.
5	El paso final es crear el contenido de todos los archivos Java y el archivo de configuración de Bean y ejecutar la aplicación como se explica a continuación.

Aquí está el contenido de HelloWorld.java archivo -

package com.tutorialspoint;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public void getMessage(){
      System.out.println("Your Message : " + message);
   }
   public void init(){
      System.out.println("Bean is going through init.");
   }
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

Este es un ejemplo muy básico de implementación de BeanPostProcessor, que imprime un nombre de bean antes y después de la inicialización de cualquier bean. Puede implementar una lógica más compleja antes y después de inicializar un bean porque tiene acceso al objeto bean dentro de ambos métodos de postprocesador.

Aquí está el contenido de InitHelloWorld.java archivo -

package com.tutorialspoint;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
      
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

A continuación se muestra el contenido de la MainApp.javaarchivo. Aquí debe registrar un gancho de cierreregisterShutdownHook()método que se declara en la clase AbstractApplicationContext. Esto asegurará un cierre ordenado y llamará a los métodos de destrucción relevantes.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

A continuación se muestra el archivo de configuración Beans.xml requerido para los métodos de inicio y destrucción -

<?xml version = "1.0" encoding = "UTF-8"?>

<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-3.0.xsd">

   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

   <bean class = "com.tutorialspoint.InitHelloWorld" />

</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje:

BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.