Primavera – BeanPostProcessor

Spring Framework proporciona la interfaz BeanPostProcessor. Permite la modificación personalizada de nuevas instancias de beans creadas por Spring Bean Factory. Si queremos implementar alguna lógica personalizada, como verificar las interfaces de marcadores o envolver beans con proxies después de que el contenedor Spring termine de crear instancias, configurar e inicializar un bean, podemos conectar implementaciones de BeanPostProcessor.

Sintaxis: 

org.springframework.beans.factory.config
public interface BeanPostProcessor

Métodos en la interfaz BeanPostProcessor

La interfaz BeanPostProcessor consta de dos métodos de devolución de llamada que se enumeran a continuación: 

1. Método postProcessBeforeInitialization()
2. Método postProcessAfterInitialization()

Método 1: postProcessBeforeInitialization():

Para aplicar cualquier lógica personalizada a la nueva instancia de bean dada antes de cualquier devolución de llamada de inicialización de bean (como AfterPropertiesSet de InitializingBean o un método de inicio personalizado), podemos llamar a este método BeanPostProcessor. El bean ya se completará con los valores de propiedad y la instancia de bean devuelta puede ser un envoltorio alrededor del original.

Sintaxis:

@Nullable

default Object postProcessBeforeInitialization(Object bean, String beanName) 
throws BeansException

Parámetros:

• La nueva instancia de bean
• El nombre del frijol

Tipo de devolución: ya sea el original o una instancia de bean envuelto para usar. No se invocará ningún BeanPostProcessor posterior, si es nulo. Y en caso de errores, lanza BeansException.

Método 2: postProcessAfterInitialization():

Para aplicar cualquier lógica personalizada a la nueva instancia de bean dada después de cualquier devolución de llamada de inicialización de bean (como AfterPropertiesSet de InitializingBean o un método de inicio personalizado), podemos llamar a este método BeanPostProcessor.

El bean ya se completará con los valores de propiedad y la instancia de bean devuelta puede ser un envoltorio alrededor del original. Esta devolución de llamada se invocará tanto para la instancia de FactoryBean como para los objetos creados por FactoryBean. El posprocesador puede decidir si se aplica a FactoryBean oa los objetos creados o ambos a través de la instancia de bean correspondiente de las comprobaciones de FactoryBean.

Sintaxis: 

@Nullable

default Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException

Parámetros:

• La nueva instancia de bean
• El nombre del frijol

Tipo de devolución: ya sea el original o una instancia de bean envuelto para usar. No se invocará ningún BeanPostProcessor posterior, si es nulo. Y en caso de errores, lanza BeansException.

Registro y pedido de BeanPostProcessors

Podemos conectar una o más implementaciones de BeanPostProcessor para incluir lógica personalizada, en este caso, podemos controlar estas múltiples instancias de BeanPostProcessor configurando la propiedad order o implementando la interfaz Ordered.

Un ApplicationContext puede detectar automáticamente beans BeanPostProcessor en sus definiciones de beans y aplicarlos a cualquier beans que se cree posteriormente. En el caso de una BeanFactory simple, necesitamos registrar los posprocesadores aplicándolos programáticamente a todos los beans creados a través de la fábrica de beans.

Los beans BeanPostProcessor que se detectan automáticamente en un ApplicationContext se ordenarán de acuerdo con las interfaces PriorityOrdered y Ordered. Por el contrario, los beans BeanPostProcessor que se registran mediante programación con BeanFactory se aplicarán en el orden de registro.

Implementación:

Crearemos una aplicación Spring simple para obtener detalles de los empleados usando Eclipse IDE.

Paso 1: Cree un nuevo proyecto Java ‘Spring_Application’ en Eclipse.

Paso 2: agregue archivos Spring jar al proyecto. Podemos descargar los últimos archivos jar desde Maven Repository .

Paso 3: Ahora, necesitamos crear las clases Java requeridas y los archivos de configuración bajo el proyecto. A continuación se mostrará la estructura del proyecto final de la aplicación.

Estructura del proyecto

Paso 4: cree un archivo ‘CustomProcessor.java’ que implemente la interfaz BeanPostProcessor e implemente los dos métodos de devolución de llamada en él.

Ejemplo: Spring BeanPostProcessor

A. Archivo: CustomProcessor.java

// Java Program to Illustrate CustomProcessor Class
 
package com.geeks.beans;
 
// Importing required classes
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
 
// Class
// Implementing BeanPostProcessor interface
public class CustomProcessor implements BeanPostProcessor {
 
    // Method 1
    public Object postProcessBeforeInitialization(
        Object bean, String beanName) throws BeansException
    {
        System.out.println(
            "postProcessBeforeInitialization() is called for EmployeeImpl");
 
        return bean;
    }
 
    // Method 2
    public Object postProcessAfterInitialization(
        Object bean, String beanName) throws BeansException
    {
        System.out.println(
            "postProcessAfterInitialization() is called for EmployeeImpl");
 
        return bean;
    }
}

Paso 5: cree un archivo ‘Employee.java’ para definir las variables y sus métodos getter/setter.

B. Archivo: Empleado.java

// Java Program to Illustrate Employee Class
 
package com.geeks.beans;
 
// Class
public class Employee {
 
    // Class data members
    private String name;
    private String mail;
 
    // Getter
    public String getName() { return name; }
 
    // Setter
    public void setName(String name) { this.name = name; }
 
    // Getter
    public String getMail() { return mail; }
 
    // Setter
    public void setMail(String mail) { this.mail = mail; }
}

Paso 6: Cree un archivo ‘EmployeeImpl.java’ para crear un nuevo objeto Empleado. Defina los métodos Init y Destroy de la clase.

C. Archivo: EmployeeImpl.java

// Java Program Implementing Employee Class
 
package com.geeks.beans;
 
// Class
public class EmployeeImpl {
 
    // Method 1
    public Employee createEmp()
    {
 
        // Creating Employee class object
        // inside EmployeeImpl class
        Employee e = new Employee();
 
        // Custom setters
        e.setName("Geek");
        e.setMail("test@email.com");
        return e;
    }
 
    // Method 2
    public void initBean()
    {
        System.out.println("EmployeeImpl is Initialized.");
    }
 
    // Method 3
    public void destroyBean()
    {
        System.out.println("EmployeeImpl is Destroyed.");
    }
}

Paso 7: Cree el archivo de configuración Spring ‘applicationContext.xml’ para incluir definiciones de beans. Registre el BeanPostProcessor en el archivo de configuración.

D. Archivo: applicationContext.xml

<?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.xsd">
 
    <bean id="beanPostProcessor" class="com.geeks.beans.CustomProcessor" />
    <bean id="impl" class="com.geeks.beans.EmployeeImpl"  init-method="initBean" destroy-method="destroyBean"/>
     
 
</beans>

Paso 8: Cree un archivo ‘EmployeeTest.java’ para obtener el bean y ejecutar la aplicación.

E. Archivo: EmployeeTest.java

// Java Program to Illustrate EmployeeTest Class
 
package com.geeks.beans;
 
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
// Class
public class EmployeeTest {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of ApplicationContext,
        // EmployeeImpl, and Employee class inside main()
        // method
        ApplicationContext con
            = new ClassPathXmlApplicationContext(
                "com/geeks/resources/applicationContext.xml");
        EmployeeImpl impl
            = (EmployeeImpl)con.getBean("impl");
        Employee emp = impl.createEmp();
 
        System.out.println("Employee Details");
        System.out.println("Name: " + emp.getName()
                           + ", Email address: "
                           + emp.getMail());
        ((ClassPathXmlApplicationContext)con).close();
    }
}

Paso 9: Ejecute la aplicación como una aplicación Java. Obtendremos el siguiente resultado en la consola.

Producción

Como podemos ver en la salida, se llama a postProcessBeforeInitialization() antes de la inicialización del bean y, una vez hecho esto, se llama al método postProcessAfterInitialization() y luego se completa el resto del proceso. Por lo tanto, podemos incluir cualquier lógica personalizada utilizando postprocesadores para las nuevas instancias de bean, ya sea antes o después de las inicializaciones de bean.