一张图搞懂Spring bean的完整生命周期
图形介绍
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，生命周期时序图如下：
生命周期接口分类
Bean的生命周期经历了多个接口方法的调用，这些接口和方法可分为以下四类：
1、Bean自身方法
通过的init-method和destroy-method或注解@PostConstruct与@PreDestroy 指定的方法
2、Bean级生命周期接口
包括BeanNameAware、BeanFactoryAware、InitializingBean、DiposableBean
// 获取bean名称
public interface BeanNameAware extends Aware {
void setBeanName(String name);
}
// 获取BeanFactory对象
public interface BeanFactoryAware extends Aware {
void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
// 对象初始化，与init-method属性作用相同
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
// 对象销毁，与destroy-method属性作用相同
public interface DisposableBean {
void destroy() throws Exception;
}
3、容器级生命周期接口
包括InstantiationAwareBeanPostProcessor 、BeanPostProcessor，注意：InstantiationAwareBeanPostProcessor继承自BeanPostProcessor，实际中使用InstantiationAwareBeanPostProcessorAdapter提供空实现，从而方便使用
// 对象实例化生命周期接口
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException;
}
// 对象初始化生命周期接口
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
4、BeanFactory后处理器接口
包括BeanFactoryPostProcessor
// 工厂后处理接口，用于修改bean配置（BeanDefinition）
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
生命周期示例演示
Spring 依赖注入时，什么时候会创建代理类
Bean
@Component
public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
private String name;
@Value("shanghai")
private String address;
@Value("123")
private int phone;
private BeanFactory beanFactory;
private String beanName;
public Person() {
System.out.println("【构造器】调用Person的构造器实例化");
}
public String getName() {
return name;
}
@Autowired
public void setName(@Value("matt") 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()");
}
// 通过的init-method属性指定的初始化方法
@PostConstruct
public void myInit() {
System.out.println("【init-method】调用的init-method属性指定的初始化方法" );
}
// 通过的destroy-method属性指定的初始化方法
@PreDestroy
public void myDestory() {
System.out.println("【destroy-method】调用的destroy-method属性指定的初始化方法" );
}
}
BeanFactoryPostProcessor
@Component
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");
}
}
InstantiationAwareBeanPostProcessor
@Component
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 boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessAfterInstantiation方法");
return true;
}
// 接口方法、设置某个属性时调用
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
return pvs;
}
}
BeanPostProcessor
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor() {
super();
System.out.println("这是BeanPostProcessor实现类构造器！！");
}
@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;
}
}
配置
<context:component-scan base-package="cn.matt.lifecircle"/>
测试
public class BeanLifeTest {
@Test
public void test() {
System.out.println("现在开始初始化容器");
ApplicationContext factory = new ClassPathXmlApplicationContext("spring-context-lifecircle.xml");
System.out.println("容器初始化成功");
//得到Preson，并使用
Person person = factory.getBean("person",Person.class);
System.out.println(person);
System.out.println("现在开始关闭容器！");
((ClassPathXmlApplicationContext)factory).registerShutdownHook();
}
}
运行结果
现在开始初始化容器
这是BeanFactoryPostProcessor实现类构造器！！
BeanFactoryPostProcessor调用postProcessBeanFactory方法
这是BeanPostProcessor实现类构造器！！
这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
【构造器】调用Person的构造器实例化
InstantiationAwareBeanPostProcessor调用postProcessAfterInstantiation方法
InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
【注入属性】注入属性name
【注入属性】注入属性phone
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
【init-method】调用的init-method属性指定的初始化方法
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person [address=shanghai, name=matt, phone=110]
现在开始关闭容器！
【destroy-method】调用的destroy-method属性指定的初始化方法
【DiposibleBean接口】调用DiposibleBean.destory()
一个应用示例
后台服务以方法调用的形式向外提供服务，在服务启动时须注册向外暴露的方法，该注册功能可利用bean的生命周期的BeanPostProcessor接口，在bean加载完毕后自动注册，代码如下：
业务类注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface ExpoService {
String value() default "";
}
业务接口与实现
public interface UserService {
void doSomething();
}
@ExpoService
public class UserServiceImpl implements UserService {
// @Async
@Override
public void doSomething() {
System.out.println("doSomething invoked!");
}
}
请求管理类
@Component
public class RequestManager {
private Map<String, MethodAndInstance> methodMap = new HashMap<String, MethodAndInstance>();
public void addExpoMethod(Method rawMethod, Object rawInstance, Method proxyMethod, Object proxyInstance) {
methodMap.put(rawMethod.getName(), new MethodAndInstance(rawMethod, rawInstance, proxyMethod, proxyInstance));
System.out.println(String.format("****** 添加expo对外暴露方法: %s", rawMethod.getName()));
}
public static class MethodAndInstance {
private Method rawMethod;
private Object rawInstance;
private Method proxyMethod;
private Object proxyInstance;
public MethodAndInstance(Method rawMethod, Object rawInstance, Method proxyMethod, Object proxyInstance) {
this.rawMethod = rawMethod;
this.rawInstance = rawInstance;
this.proxyMethod = proxyMethod;
this.proxyInstance = proxyInstance;
}
public Object getRawInstance() {
return rawInstance;
}
public Object getProxyInstance() {
return proxyInstance;
}
public Method getRawMethod() {
return rawMethod;
}
public Method getProxyMethod() {
return proxyMethod;
}
}
}
使用BeanPostProcessor，注册接口
@Component
public class ExpoBeanPostProcessor implements BeanPostProcessor {
private Map<String, Object> beanMap = new HashMap<String, Object>();
@Autowired
private RequestManager requestManager;
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
Class<?> cls = bean.getClass();
if (cls.isAnnotationPresent(ExpoService.class)) {
beanMap.put(beanName, bean);
System.out.println(String.format("======> 业务类原始bean: %s", bean.getClass().getName()));
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object proxyBean, String beanName) throws BeansException {
try {
if (beanMap.containsKey(beanName)) {
System.out.println(String.format("======> 业务类代理bean: %s", proxyBean.getClass().getName()));
Object rawBean = beanMap.remove(beanName);
for (Class<?> cls : rawBean.getClass().getInterfaces()) {
for (Method rowMethod : cls.getDeclaredMethods()) {
Method proxyMethod = proxyBean.getClass().getMethod(rowMethod.getName(), rowMethod.getParameterTypes());
this.requestManager.addExpoMethod(rowMethod, rawBean, proxyMethod, proxyBean);
}
}
}
}
catch (Exception e) { }
return proxyBean;
}
}
配置
<context:component-scan base-package="cn.matt.lifecircle"/>
<task:annotation-driven executor="myExecutor1"/>
<task:executor id="myExecutor1" pool-size="10" />
测试
运行结果
======> 业务类原始bean: cn.matt.lifecircle.UserServiceImpl
======> 业务类代理bean: cn.matt.lifecircle.UserServiceImpl
****** 添加expo对外暴露方法: doSomething
doSomething invoked!
当业务方法添加@Async时，运行结果：
======> 业务类原始bean: cn.matt.lifecircle.UserServiceImpl
======> 业务类代理bean: com.sun.proxy.$Proxy9
****** 添加expo对外暴露方法: doSomething
doSomething invoked!
补充：不存在需要aop功能时，spring bean为原始类；当存在需要aop功能时，spring bean为代理类
上述实例存在一个bug：当业务类存在循环引用时，spring会将引用链中的某个类提前构造，此时，ExpoBeanPostProcessor在该类的postProcessAfterInitialization方法中获取的是原始类，而非代理类，由于方法在原始类上调用，导致所有基于aop的功能（如事务，多数据源切换等）失效
解决方法：通过对spring初始化bean的源码的分析可知（参考Spring 依赖注入时，什么时候会创建代理类），利用SmartInstantiationAwareBeanPostProcessor接口的getEarlyBeanReference方法获取到代理类，该方法在BeanPostProcessor接口相关方法之前调用
具体修改如下：
@Component
public class ExpoBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
private Map<String, Object> beanMap = new HashMap<String, Object>();
/**
* @Fields proxyBeanMap : 记录bean循环引用时的代理bean
*/
private Map<String, Object> proxyBeanMap = new HashMap<String, Object>();
@Autowired
private RequestManager requestManager;
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
Class<?> cls = bean.getClass();
if (cls.isAnnotationPresent(ExpoService.class)) {
beanMap.put(beanName, bean);
System.out.println(String.format("======> 业务类原始bean: %s", bean.getClass().getName()));
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object proxyBean, String beanName) throws BeansException {
Object originalProxyBean = proxyBean;
try {
if (beanMap.containsKey(beanName)) {
// bean循环引用时, postProcessAfterInitialization获取不到代理类，须特殊处理
if (proxyBeanMap.containsKey(beanName)) {
proxyBean = proxyBeanMap.get(beanName);
}
System.out.println(String.format("======> 业务类代理bean: %s", proxyBean.getClass().getName()));
Object rawBean = beanMap.remove(beanName);
for (Class<?> cls : rawBean.getClass().getInterfaces()) {
for (Method rowMethod : cls.getDeclaredMethods()) {
Method proxyMethod = proxyBean.getClass().getMethod(rowMethod.getName(), rowMethod.getParameterTypes());
this.requestManager.addExpoMethod(rowMethod, rawBean, proxyMethod, proxyBean);
}
}
}
}
catch (Exception e) { }
return originalProxyBean;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
if (!proxyBeanMap.containsKey(beanName)) {
proxyBeanMap.put(beanName, bean);
}
return bean;
}
}
`