一、概述

Spring Bean的完整生命周期从创建Spring容器开始,直到最终Spring容器销毁Bean,生命周期时序图如下:

二、生命周期接口分类

Bean的生命周期经历了多个接口方法的调用,这些接口和方法可分为以下四类:

1、Bean自身方法

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

三、生命周期示例演示

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()");
} // 通过<bean>的init-method属性指定的初始化方法
@PostConstruct
public void myInit() {
System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
} // 通过<bean>的destroy-method属性指定的初始化方法
@PreDestroy
public void myDestory() {
System.out.println("【destroy-method】调用<bean>的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】调用<bean>的init-method属性指定的初始化方法
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改!
InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
容器初始化成功
Person [address=shanghai, name=matt, phone=110]
现在开始关闭容器!
【destroy-method】调用<bean>的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" />

测试

@Test
public void testMethodRegistry() {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-context-lifecircle.xml");
UserService userService = context.getBean(UserService.class);
userService.doSomething();
}

运行结果

======> 业务类原始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;
}
}

参考:

Spring Bean的生命周期(非常详细)

Spring Bean生命周期详解

Spring 依赖注入时,什么时候会创建代理类

随机推荐

  1. 瞎BB

    今天家里停电了,什么都没干,又开始胡思乱想了.或许有点时候真的应该沉迷一些东西. 小时候其实挺喜欢数学的,考试都是90分,100分,我喜欢思考钻研不懂的题目,花很多时间,所以有的时候会跳过课堂的东西, ...

  2. 308. Range Sum Query 2D - Mutable

    题目: Given a 2D matrix matrix, find the sum of the elements inside the rectangle defined by its upper ...

  3. 全文检索luncence

    检索技术基本原理: 最主要的两点是  1.如何创建索引 2.如何查询.  分析需求: 好几篇文档,从这些文档找关键词,一种方式是顺序一个个遍历,加入这些文档量很多,就花费太长时间了,第二种是建立索引, ...

  4. 面试技巧,如何通过索引说数据库优化能力,内容来自Java web轻量级开发面试教程

    上星期写了一个篇文章,数据库方面的面试技巧,如何从建表方面展示自己能力,承蒙管理员抬举,放入首页,也承蒙各位厚爱,两天内收获了将近770个点击,也一度进入48小时热榜. 为了感谢管理员和大家的支持,再 ...

  5. 201521123060 《Java程序设计》第10周学习总结

    1.本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结异常与多线程相关内容. 异常: 1.不要乱用异常: 2.异常发生时:确定异常类型,异常位置: 3.尽量使用已有的异常类. 多线程: 2 ...

  6. 从锅炉工到AI专家(6)

    欠拟合和过拟合 几乎所有的复杂方程都存在结果跟预期差异的情况,越复杂的方程,这种情况就越严重.这里面通常都是算法造成的,当然也存在数据集的个体差异问题. 所以"欠拟合"和" ...

  7. es 模块的基础知识,深度了解

    // 一模块的基础知识 /** * export :用于模块输出的出口 * import :文件引入的入口 */ // 1,第一种方式使用export方式输出 var a = 'a'; var b = ...

  8. Catlike学习笔记(1.1)-使用Unity实现一个钟表

    最近发现『Catlike系列教程』觉得内容真的很赞,感觉有很多地方涉及到了我的知识盲点,如果真的可以照着做下来一遍的话应该收获颇丰.因为教程很长所以逐字翻译不太可能了(主要是翻译的太差).基本上就是把 ...

  9. Android 使用全局变量的问题

    现在每天都在忙,而且一忙起来,就把写笔记的事情放在了后面,最近在写程序的时候,突然要使用全局变量,就按照以前的方式,写了一个类,然后把变量都声明为静态变量,然后做为全局变量使用,但是在进行Activi ...

  10. Jenkins Tomcat安装设置

    Jenkins Tomcat安装设置 以下为必须满足Jenkins Tomcat设置的先决条件. 第1步:验证安装Java 要验证Java安装,打开控制台并执行以下Java命令. OS 任务 命令 W ...