Hablar sobre el ciclo de vida de JavaBean en Spring

1. Diagrama de flujo del ciclo de vida

El ciclo de vida completo de un Spring Bean comienza desde la creación del contenedor Spring hasta que el contenedor Spring final destruye el Bean. Aquí está el ciclo de vida del Bean en ApplicationContext. De hecho, BeanFactory es similar

Nota: Si el contenedor está registrado con las diversas interfaces anteriores, el programa seguirá el proceso anterior.

En segundo lugar, la clasificación de varios métodos de interfaz.

El ciclo de vida completo de Bean ha experimentado varias llamadas a métodos, y estos métodos se pueden dividir en las siguientes categorías:

• Método propio de Bean: incluye el método llamado por el propio Bean y el método especificado por init-method y destroy-method de <bean> en el archivo de configuración
• Métodos de interfaz de ciclo de vida a nivel de bean: esto incluye métodos de interfaces BeanNameAware, BeanFactoryAware, InitializingBean y DiposableBean
• Métodos de interfaz de ciclo de vida a nivel de contenedor: esto incluye la implementación de las dos interfaces InstantiationAwareBeanPostProcessor y BeanPostProcessor, que generalmente se denominan "postprocesadores".
• Métodos de interfaz de postprocesador de fábrica: esto incluye AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer, etc. métodos de interfaz de postprocesador de fábrica muy útiles. El postprocesador de fábrica también es a nivel de contenedor. Se llama inmediatamente después de aplicar el archivo de configuración de ensamblaje de contexto.

Tres, demostración de código

3.1

El primero es un Spring Bean simple, que llama a los métodos propios de Bean y a los métodos de interfaz de ciclo de vida de Bean. Para la conveniencia de la demostración, implementa 4 interfaces de BeanNameAware, BeanFactoryAware, InitializingBean y DiposableBean. Hay 2 métodos al mismo tiempo, correspondiente al archivo de configuración El método init y el método destroy de <bean>. como sigue:

package springBeanTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Person implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {
    
    

    private String name;
    private String address;
    private int phone;

    private BeanFactory beanFactory;
    private String beanName;

    public Person() {
    
    
        System.out.println("【构造器】调用Person的构造器实例化");
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        System.out.println("【注入属性】注入属性name");
        this.name = name;
    }

    public String getAddress() {
    
    
        return address;
    }

    public void setAddress(String address) {
    
    
        System.out.println("【注入属性】注入属性address");
        this.address = address;
    }

    public int getPhone() {
    
    
        return phone;
    }

    public void setPhone(int phone) {
    
    
        System.out.println("【注入属性】注入属性phone");
        this.phone = phone;
    }

    @Override
    public String toString() {
    
    
        return "Person [address=" + address + ", name=" + name + ", phone="
                + phone + "]";
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
    
    
        System.out
                .println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = arg0;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String arg0) {
    
    
        System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
        this.beanName = arg0;
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
    
    
        System.out
                .println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
    
    
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }

    // 通过<bean>的init-method属性指定的初始化方法
    public void myInit() {
    
    
        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
    }

    // 通过<bean>的destroy-method属性指定的初始化方法
    public void myDestory() {
    
    
        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }
}

3.2

El siguiente es el método para demostrar la interfaz BeanPostProcessor, como sigue:

package springBeanTest;

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

public class MyBeanPostProcessor implements BeanPostProcessor {
    
    

    public MyBeanPostProcessor() {
    
    
        super();
        System.out.println("这是BeanPostProcessor实现类构造器！！");
        // TODO Auto-generated constructor stub
    }

    @Override
    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
    
    
        System.out
        .println("BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
        return arg0;
    }

    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
    
    
        System.out
        .println("BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
        return arg0;
    }
}

Nota: La interfaz BeanPostProcessor incluye dos métodos postProcessAfterInitialization y postProcessBeforeInitialization.El primer parámetro de estos dos métodos es el objeto Bean que se va a procesar y el segundo parámetro es el nombre del Bean. El valor de retorno es también el objeto Bean que se va a procesar.

3.3

La interfaz InstantiationAwareBeanPostProcessor es esencialmente una subinterfaz de BeanPostProcessor. Generalmente, heredamos la clase de adaptador InstantiationAwareBeanPostProcessor Adapter proporcionado por Spring para usarlo, de la siguiente manera:

package springBeanTest;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

public class MyInstantiationAwareBeanPostProcessor extends
        InstantiationAwareBeanPostProcessorAdapter {
    
    

    public MyInstantiationAwareBeanPostProcessor() {
    
    
        super();
        System.out
                .println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
    }

    // 接口方法、实例化Bean之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass,
            String beanName) throws BeansException {
    
    
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
        return null;
    }

    // 接口方法、实例化Bean之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
    
    
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
        return bean;
    }

    // 接口方法、设置某个属性时调用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,
            PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {
    
    
        System.out
                .println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return pvs;
    }
}

El segundo método postProcessAfterInitialization es anular el método BeanPostProcessor. El tercer método postProcessPropertyValues ​​se usa para manipular propiedades, y el valor de retorno también debe ser un objeto PropertyValues

3.4

Demuestre el método de interfaz de postprocesador de fábrica, de la siguiente manera:

package springBeanTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    

    public MyBeanFactoryPostProcessor() {
    
    
        super();
        System.out.println("这是BeanFactoryPostProcessor实现类构造器！！");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
            throws BeansException {
    
    
        System.out
                .println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
        BeanDefinition bd = arg0.getBeanDefinition("person");
        bd.getPropertyValues().addPropertyValue("phone", "110");
    }

}

3,5

El archivo de configuración es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
            
    <bean id="beanPostProcessor" class="springBeanTest.MyBeanPostProcessor">
    </bean>

    <bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">
    </bean>
    
    <bean id="person" class="springBeanTest.Person" init-method="myInit"
        destroy-method="myDestory" scope="singleton" p:name="张三" p:address="广州"
        p:phone="15900000000" />
</beans>

3.6 Los resultados de la demostración son los siguientes

现在开始初始化容器
2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性address
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person [address=广州, name=张三, phone=110]
现在开始关闭容器！
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

Reimpreso de: http://www.cnblogs.com/zrtqsk/