Spring Bean 生命周期

---

BeanFactory和ApplicationContext是Spring两种很重要的容器,前者提供了最基本的依赖注入的支持，而后者在继承前者的基础进行了功能的拓展，例如增加了事件传播，资源访问和国际化的消息访问等功能。

概括来说主要有四个阶段：实例化，初始化，使用，销毁。

Bean 作用范围

常用的Bean作用范围：singleton和prototype

• singleton

在默认情况下,Spring的ApplicationContext容器在启动时,自动实例化所有singleton的Bean并缓存于容器中.虽然启动时会花费一些时间,但带来两个好处:首先对Bean提前的实例化操作会及早发现一些潜在的配置问题.其次Bean以缓存的方式保存,当运行时使用到该Bean时就无须再实例化了,加快了运行效率.如果用户不希望在容器启动时提前实例化singleton的Bean,可以通过lazy-init属性进行控制.

• prototype

在默认情况下,Spring容器在启动时不实例化prototype的Bean.此外,Spring容器将prototype的Bean交给调用者后,就不再管理它的生命周期.

ApplicationContext Bean生命周期：

Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。

流程图

若容器注册了以上各种接口，程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。

各种接口方法分类

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1、Bean自身的方法：这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法

2、Bean级生命周期接口方法：这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法

3、容器级生命周期接口方法：这个包括了InstantiationAwareBeanPostProcessor和 BeanPostProcessor这两个接口实现，一般称它们的实现类为“后处理器”。容器中每个bean初始化都要经过这一步。

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

流程说明

1. 首先容器启动后，会对scope为singleton且非懒加载(lazy-init=false)的bean进行实例化，
2. 按照Bean定义信息配置信息，注入所有的属性
3. 如果Bean实现了BeanNameAware接口，会回调该接口的setBeanName()方法，传入该Bean的id，此时该Bean就获得了自己在配置文件中的id
4. 如果Bean实现了BeanFactoryAware接口,会回调该接口的setBeanFactory()方法，传入该Bean的BeanFactory，这样该Bean就获得了自己所在的BeanFactory
5. 如果Bean实现了ApplicationContextAware接口,会回调该接口的setApplicationContext()方法，传入该Bean的ApplicationContext，这样该Bean就获得了自己所在的ApplicationContext
6. 如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessBeforeInitialzation()方法
7. 如果Bean实现了InitializingBean接口，则会回调该接口的afterPropertiesSet()方法
8. 如果Bean配置了init-method方法，则会执行init-method配置的方法
9. 如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessAfterInitialization()方法
10. 经过流程9之后，就可以正式使用该Bean了,对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例，而对于scope为prototype的Bean,每次被调用都会new一个新的对象，生命周期就交给调用方管理了，不再是Spring容器进行管理了
11. 容器关闭后，如果Bean实现了DisposableBean接口，则会回调该接口的destroy()方法
12. 如果Bean配置了destroy-method方法，则会执行destroy-method配置的方法，至此，整个Bean的生命周期结束

BeanFactory Bean生命周期

BeanFactoty容器中, Bean的生命周期如下图所示，与ApplicationContext相比，有如下几点不同:

1.BeanFactory容器中，不会调用ApplicationContextAware接口的setApplicationContext()方法

2.BeanPostProcessor接口的postProcessBeforeInitialzation()方法和postProcessAfterInitialization()方法不会自动调用，必须自己通过代码手动注册

3.BeanFactory容器启动的时候，不会去实例化所有Bean,包括所有scope为singleton且非懒加载的Bean也是一样，而是在调用的时候去实例化。

流程图

流程说明

1. 当调用者通过 getBean(name)向 容器寻找Bean时，如果容器注册了org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，在实例bean之前，将调用该接口的 postProcessBeforeInstantiation()方法
2. 容器寻找Bean的定义信息，并将其实例化
3. 使用依赖注入，Spring按照Bean定义信息配置Bean的所有属性
4. 如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的id
5. 如果实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
6. 如果BeanPostProcessor和Bean关联，那么它们的postProcessBeforeInitialization()方法将被调用（需要手动进行注册！）
7. 如果Bean实现了InitializingBean接口，则会回调该接口的afterPropertiesSet()方法
8. 如果Bean指定了init-method方法，就会调用init-method方法
9. 如果BeanPostProcessor和Bean关联，那么它的postProcessAfterInitialization()方法将被调用（需要手动注册！）
10. 现在Bean已经可以使用了
    1. scope为singleton的Bean缓存在Spring IOC容器中
    2. scope为prototype的Bean生命周期交给客户端
11. 销毁
    1. 如果Bean实现了DisposableBean接口，destory()方法将会被调用
    2. 如果配置了destory-method方法，就调用这个方法

演示

用一个简单的Spring Bean来演示一下Spring Bean的生命周期。

1、首先是一个简单的Spring Bean，调用Bean自身的方法和Bean级生命周期接口方法，为了方便演示，它实现了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这4个接口，同时有2个方法，对应配置文件中<bean>的init-method和destroy-method。如下：

package com.zsr.test.spring.bean;

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 beanFactory) throws BeansException {
    System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
    this.beanFactory = beanFactory;
  }

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

  // 这是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属性指定的初始化方法");
  }

}

2、接下来是演示BeanPostProcessor接口的方法，如下：

package com.zsr.test.spring.bean;

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

public class MyBeanPostProcessor implements BeanPostProcessor {

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

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

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

}

如上，BeanPostProcessor接口包括2个方法postProcessAfterInitialization和postProcessBeforeInitialization，这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。

3、InstantiationAwareBeanPostProcessor 接口本质是BeanPostProcessor的子接口，一般我们继承Spring为其提供的适配器类InstantiationAwareBeanPostProcessorAdapter来使用它，如下：

package com.zsr.test.spring.bean;

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;
  }
}

这个有3个方法，其中第二个方法postProcessAfterInitialization就是重写了BeanPostProcessor的方法。第三个方法postProcessPropertyValues用来操作属性，返回值也应该是PropertyValues对象。

4、工厂后处理器接口方法，如下：

package com.zsr.test.spring.bean;

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 beanFactory) throws BeansException {
    System.out.println("BeanFactoryPostProcessor调用postProcessBeanFactory方法");
    BeanDefinition bd = arg0.getBeanDefinition("person");
    bd.getPropertyValues().addPropertyValue("phone", "110");
  }

}

BeanFactoryPostProcessor 可以修改 bean 的配置信息而 BeanPostProcessor 不能

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
                throws BeansException {
            //BeanFactoryPostProcessor可以修改BEAN的配置信息而BeanPostProcessor不能
            //我们在这里修改postProcessorBean的username注入属性
            BeanDefinition bd = beanFactory.getBeanDefinition("postProcessorBean");
            MutablePropertyValues pv =  bd.getPropertyValues();
            if(pv.contains("username"))
            {
                pv.addPropertyValue("username", "xiaojun");
            }
        }
    }

5、配置文件如下beans.xml，使用ApplicationContext,处理器不用手动注册：

<?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>

6、测试一下：

package com.zsr.test.spring.bean;

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

public class BeanLifeCycleTest {

  public static void main(String[] args) {

    System.out.println("现在开始初始化容器");

    ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml");
    System.out.println("容器初始化成功");
    // 得到Preson，并使用
    Person person = factory.getBean("person", Person.class);
    System.out.println(person);

    System.out.println("现在开始关闭容器！");
    ((ClassPathXmlApplicationContext) factory).registerShutdownHook();
  }
}

关闭容器使用的是实际是AbstractApplicationContext的钩子方法。

7、结果：

现在开始初始化容器
[location]15:15:33 100  INFO (org.springframework.context.support.ClassPathXmlApplicationContext:510) - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@75a70476: startup date [Mon May 08 15:15:33 CST 2017]; root of context hierarchy
[location]15:15:33 194  INFO (org.springframework.beans.factory.xml.XmlBeanDefinitionReader:315) - Loading XML bean definitions from class path resource [beans.xml]
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
[location]15:15:33 695  INFO (org.springframework.beans.factory.support.DefaultListableBeanFactory:596) - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@461d434f: 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]
现在开始关闭容器！
[location]15:15:33 752  INFO (org.springframework.context.support.ClassPathXmlApplicationContext:1042) - Closing org.springframework.context.support.ClassPathXmlApplicationContext@75a70476: startup date [Mon May 08 15:15:33 CST 2017]; root of context hierarchy
[location]15:15:33 752  INFO (org.springframework.beans.factory.support.DefaultListableBeanFactory:444) - Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@461d434f: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法

总结

Bean的完整生命周期从 spring 容器开始实例化 bean 开始，到销毁。可以从三点来理解

1、bean自身的方法：包括构造方法、 set 方法、 init-method 指定的方法、 destroy-method 指定的方法

2、bean级生命周期接口方法：如BeanNameAware 、 BeanFactoryAware 等这些接口方法由 bean类实现

3、容器级生命周期接口方法：有InstantiationAwareBeanPostProcessor 、 BeanPostProcessor等。一般称为后处理器。他们一般不由bean 本身实现，独立存在，注册到 spring 容器中。 Spring 通过接口反射预先知道，当 spring 容器创建任何 bean 时，这些后处理器都会发生作用。所以他们是全局的，用户可以通过编码对只感兴趣的 bean 进行处理

参考

Spring Bean的生命周期

Spring Bean生命周期

Spring bean生命周期详解