[Spring实战系列]（10）初探Bean生命周期

Posted 2020-06-13 SunnyYoona

1. 生命周期流程图

Bean在Spring容器中从创建到销毁经历了若干个阶段，在每一个阶段都可以针对Spring如何管理Bean进行个性化定制。

正如你所见，在Bean 准备就绪之前，Bean 工厂执行了若干启动步骤。

• Spring 对Bean 进行实例化。
• Spring 将值和Bean 的引用注入进Bean 对应的属性中。
• 如果Bean 实现了BeanNameAware接口，Spring 将Bean的ID传递给setBeanName() 接口方法。
• 如果Bean 实现了BeanFactoryAware接口，Spring 将调用setBeanFactory()接口方法，将BeanFactory 容器实例传入。
• 如果Bean 实现了ApplicationContextAware 接口，Spring 将调用setApplicationContext()接口方法，将应用上下文的引用传入。
• 如果Bean 实现了BeanPostProcessor 接口，Spring 将调用它们的postProcessBeforeInitialization() 接口方法。
• 如果Bean 实现了InitializingBean 接口，Spring 将调用它们的afterPropertiesSet() 接口方法。类似地，如果Bean 使用init-method 声明了初始化方法，该方法也会被调用。
• 如果Bean 实现了BeanPostProcessor 接口，Spring 将调用它们的postPoressAfterInitialization() 接口方法。
• 此时此刻，Bean 已经准备就绪，可以被应用程序使用了，它们将一直驻留在应用上下文中，直到该应用上下文被销毁。
• 如果Bean 实现了DisposableBean 接口，Spring 将调用它的destroy()接口方法。同样，如果Bean 使用destroy-method 声明了销毁方法，该方法也会被调用。

2. 各种接口方法分类

 

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

方法	用途
Bean自身的方法	这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法
Bean级生命周期接口方法	这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
容器级生命周期接口方法	这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
工厂后处理器接口方法	这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

 　

3. 实例

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

 

首先是一个简单的Spring Bean，它实现了BeanNameAware，BeanFactoryAware，InitializingBean，ApplicationContextAware和DiposableBean这5个接口，同时有2个方法（myInit()方法和myDestroy方法），对应配置文件中<bean>的init-method和destroy-method。

package com.sjf.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;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
 
/**
 * Student实体类
 * @author sjf0115
 *
 */
public class Student implements BeanNameAware,BeanFactoryAware,InitializingBean,ApplicationContextAware, DisposableBean{
	
	private String name;
	private int age;
	private String school;
	
	// 构造器
	public Student(){
		System.out.println("constructor Student...");
	}
	
	public void setName(String name) {
		this.name = name;
		System.out.println("setName...");
	}
 
	public void setAge(int age) {
		this.age = age;
		System.out.println("setAge...");
	}
 
	public void setSchool(String school) {
		this.school = school;
		System.out.println("setSchool...");
	}
 
	public void myInit(){
		System.out.println("init-method...");
	}
	
	public void myDestroy(){
		System.out.println("destroy-method...");
	}
	
	// 来自于BeanNameAware接口
	public void setBeanName(String arg0) {
		System.out.println("setBeanName...[" + arg0 + "]");
	}
	
	// 来自于BeanFactoryAware接口
	public void setBeanFactory(BeanFactory arg0) throws BeansException {
		System.out.println("setBeanFactory...");
	}
	
	// 来自于InitializingBean
	public void afterPropertiesSet() throws Exception {
		System.out.println("afterPropertiesSet...");
	}
	
	// 来自于DisposableBean
	public void destroy() throws Exception {
		System.out.println("destroy...");
	}
	// 来自于ApplicationContextAware接口
	public void setApplicationContext(ApplicationContext arg0) throws BeansException {
		System.out.println("setApplicationContext...");
	}
	
	@Override
	public String toString() {
		return "name：" + name + "   age：" + age + "   school：" + school;
	}
}

然后是自定义一个MyBeanPostProcessor Bean，实现了BeanPostProcessor接口。

package com.sjf.bean;
 
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
 
/**
 * 自定义BeanPostProcessor
 * @author sjf0115
 *
 */
public class MyBeanPostProcessor implements BeanPostProcessor{