Spring Bean的生命周期

接触Spring很长时间了,但是,每当看到Spring Bean生命周期流程图的时候总是一头雾水,完全看不懂。在参考了很多优秀的博客之后,对Spring Bean的生命周期的一次总结。

1、Demo

1.1 实体类

/**
 * Student实体类
 * 实现了BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean接口
 */
public class Student implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{
    private String name;
    private int age;

    private BeanFactory beanFactory;
    private String beanName;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    /**
     * BeanFactoryAware接口方法
     * 作用:让bean获取配置它们的BeanFactory的引用
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【BeanFactoryAware接口】调用setBeanFactory()");
        this.beanFactory = beanFactory;
    }

    /**
     * BeanNameAware接口方法
     * 作用:让bean获取自己在BeanFactory配置中的名字
     * @param s
     */
    @Override
    public void setBeanName(String s) {
        System.out.println("【BeanNameAware接口】调用setBeanName()");
        this.beanName = s;
    }

    /**
     * InitializingBean接口方法
     * 作用:负责初始化bean
     * @throws Exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean接口】调用afterPropertiesSet()");
    }

    /**
     * DisposableBean接口方法
     * 作用:负责销毁bean
     * @throws Exception
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("【DisposableBean接口】调用destroy()");
    }

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

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

}

1.2 BeanFactoryPostProcessor实现类

/**
 * BeanFactoryPostProcessor实现类
 * 作用:bean工厂的bean属性处理容器,可以管理bean工厂内的所有未实例化的数据,修改属性
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

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

    /**
     * BeanFactoryPostProcessor接口方法
     * 在bean未实例化之前执行
     * @param configurableListableBeanFactory
     * @throws BeansException
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("【BeanFactoryPostProcessor接口】调用postProcessBeanFactory()");
        BeanDefinition student = configurableListableBeanFactory.getBeanDefinition("student");
        student.getPropertyValues().addPropertyValue("age","100");
    }
}

1.3 BeanPostProcessor实现类

/**
 * BeanPostProcessor实现类
 * 也叫后置处理器
 * 作用:在bean对象实例化和依赖注入完毕后,在显示调用初始化方法的前后添加自己的逻辑
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor(){
        super();
        System.out.println("【构造器】BeanPostProcessor实现类构造器");
    }

    /**
     * BeanPostProcessor接口方法
     * 实例化、依赖注入完毕,显示调用初始化之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor接口】调用postProcessBeforeInitialization()对属性进行更改");
        return bean;
    }

    /**
     * BeanPostProcessor接口方法
     * 实例化、依赖注入、初始化完毕时执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【BeanPostProcessor接口】调用postProcessAfterInitialization()对属性进行更改");
        return bean;
    }
}

1.4 InstantiationAwareBeanPostProcessorAdapter实现类

/**
 * InstantiationAwareBeanPostProcessorAdapter实现类
 * 作用:在实例化bean前后执行
 */
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

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

    /**
     * InstantiationAwareBeanPostProcessorAdapter接口方法
     * 实例化Bean之前调用
     * @param beanClass
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("【InstantiationAwareBeanPostProcessorAdapter接口】调用postProcessBeforeInstantiation()");
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    /**
     * InstantiationAwareBeanPostProcessorAdapter接口方法
     * 实例化Bean之后调用
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("【InstantiationAwareBeanPostProcessorAdapter接口】调用postProcessAfterInstantiation()");
        return super.postProcessAfterInstantiation(bean, beanName);
    }

}

1.5 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" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="beanPostProcessor" class="com.zhy.lifecycle.MyBeanPostProcessor"></bean>

    <bean id="instantiationAwareBeanPostProcessor" class="com.zhy.lifecycle.MyInstantiationAwareBeanPostProcessor"></bean>

    <bean id="beanFactoryPostProcessor" class="com.zhy.lifecycle.MyBeanFactoryPostProcessor"></bean>

    <bean id="student" class="com.zhy.lifecycle.Student" init-method="myInit" destroy-method="myDestroy" p:name="周大宇" p:age="18"></bean>


</beans>

1.6 测试方法

@Test
public void test(){
    System.out.println("-------开始初始化容器-------");
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println("-------容器初始化成功-------");
    Student student = context.getBean("student", Student.class);
    System.out.println(student);
    System.out.println("-------准备关闭容器-------");
    ((ClassPathXmlApplicationContext)context).registerShutdownHook();
}

1.7 运行结果

-------开始初始化容器-------
【构造器】BeanFactoryPostProcessor实现类构造器
【BeanFactoryPostProcessor接口】调用postProcessBeanFactory()
【构造器】BeanPostProcessor实现类构造器
【构造器】InstantiationAwareBeanPostProcessorAdapter实现类构造器
【InstantiationAwareBeanPostProcessorAdapter接口】调用postProcessBeforeInstantiation()
【构造器】调用Student的构造器实例化
【InstantiationAwareBeanPostProcessorAdapter接口】调用postProcessAfterInstantiation()
【DI】注入属性age
【DI】注入属性name
【BeanNameAware接口】调用setBeanName()
【BeanFactoryAware接口】调用setBeanFactory()
【BeanPostProcessor接口】调用postProcessBeforeInitialization()对属性进行更改
【InitializingBean接口】调用afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
【BeanPostProcessor接口】调用postProcessAfterInitialization()对属性进行更改
-------容器初始化成功-------
Student{name='周大宇', age=100}
-------准备关闭容器-------
【DisposableBean接口】调用destroy()
【destroy-method】调用<bean>的destroy-method属性指定的销毁方法

2、各种接口方法分类

2.1 Bean自身的方法

 1. bean本身调用的方法;
 2. 通过init-method和destory-method指定的方法;

2.2 Bean级生命周期接口方法

 1. BeanNameAware:让bean获取自己在BeanFactory配置中的名字;
 2. BeanFactoryAware:让bean获取配置它们的BeanFactory的引用;
 3. InitializingBean:初始化bean;
 4. DiposableBean:销毁bean;

2.3 容器级生命周期接口方法

 1. InstantiationAwareBeanPostProcessor:实例化bean前后执行;
 2. BeanPostProcessor:在bean对象实例化和依赖注入完毕后,在显示调用初始化方法的前后添加自己的逻辑;

2.4 工厂后处理接口方法

这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

3、Spring中的Aware接口

xxxAware表示对xxx感知,实现xxxAware接口,重写对应的setxxx方法,就可以使用xxx了。
Bean对Spring容器的存在是没有意识的,即可以将容器替换成别的容器。
当需要用到Spring容器本身的功能资源,这时候Bean必须要意识到Spring容器的存在,才能调用Spring所提供的资源,所以需要实现xxxAware接口,获取对应资源。

4、总结Spring Bean的生命周期

Spring Bean的生命周期可以分为4个阶段:
 1. 实例化bean
 2. 设置属性,即依赖注入
 3. 初始化
 4. 销毁bean

在这4个阶段的前后还执行其它逻辑

在这里插入图片描述

已标记关键词 清除标记
<div class="iteye-blog-content-contain" style="font-size: 14px;"> <pre name="code" class="MyBeanFactory.java">@Component public class MyBeanFactory implements BeanFactoryAware { private static MyBeanFactory myBeanFactory; private static BeanFactory beanFactory; //回调方法 public void setBeanFactory(BeanFactory factory) throws BeansException { // TODO Auto-generated method stub this.beanFactory = factory; System.out.println("==>>>>setBeanFactory<<<<<<=="); } public BeanFactory getBeanFactory() { return beanFactory; } public static MyBeanFactory getInstance(){ if(myBeanFactory==null){ myBeanFactory = (MyBeanFactory) beanFactory.getBean("myBeanFactory"); } return myBeanFactory; } public static Object getBean(String beanName){ return beanFactory.getBean(beanName); } public static Object getBean(String beanName, Class clazz){ return beanFactory.getBean(beanName, clazz); } }</pre> <pre name="code" class="applicationContext.xml"><!-- 属性文件读入 --> <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> </list> </property> </bean> <!-- 使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入。此处应该缩小范围,以加快速度。 --> <context:component-scan base-package="com.perlin" /> <!-- dsPrototype只是作为一个原型或模板,不要在配置文件或Annotation中引用它! --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" lazy-init="true" scope="prototype"> <property name="driverClass"><value>${jdbc.driverClassName}</value></property> <property name="url"><value>${jdbc.url}</value></property> <property name="username"><value>${jdbc.username}</value></property> <property name="password"><value>${jdbc.password}</value></property> </bean> <!-- 事务管理器配置,单数据源事务 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean> <bean id="myBeanFactory" class="com.perlin.dao.MyBeanFactory"></bean></pre> <p> </p> <p> 以上是我自定义Bean实现BeanFactoryAware接口,以及applicationContext.xml的配置,但是ioc容器启动之后,我调用MyBeanFactory的getInstance()方法,发现beanFactory为空,直接调用getBean(String beanName)方法也是一样。不知为何?哪位高手给我解答下,我纠结了好几天了。。。</p> </div>
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页