【Spring】Spring之Bean生命周期源码解析,诺基亚2320

文件名：【Spring】Spring之Bean生命周期源码解析,诺基亚2320 【Spring】Spring之Bean生命周期源码解析 概述 什么是bean的生命周期

是指bean在spring中是如何生成，如何销毁的；spring创建对象的过程，就是IOC（控制反转）的过程；

JFR

Java Flight Record，java飞行记录，类似于飞机的黑匣子，是JVM内置的基于事件的JDK监控记录框架，主要用于问题定位和持续监控；

Bean的生成过程

入口代码：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);UserService userService = (UserService) applicationContext.getBean("userService");userService.test(); 1 生成BeanDefinition

Spring启动的时候会进行扫描，扫描定义的包路径，得到BeanDefinition的Set集合；

扫描类文件流程如下：

首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件（Spring源码中将此文件包装成了Resource对象）遍历每个Resource对象利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选（条件注解并不难理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition再基于metadataReader判断是不是对应的类是不是接口或抽象类如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有：

获取类的名字获取父类的名字获取所实现的所有接口名获取所有内部类的名字判断是不是抽象类判断是不是接口判断是不是一个注解获取拥有某个注解的方法集合获取类上添加的所有注解信息获取类上添加的所有注解类型集合

CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）

扫描得到BeanDefinition对象的几种方法：

通过直接定义BeanDefinition解析spring.xml文件的<bean/>AppConfig.class类方法上面加@Bean注解得到BeanDefinition对象 2 合并BeanDefinition

Spring中支持父子BeanDefinition，和Java父子类类似，但是完全不是一回事，父子BeanDefinition实际用的比较少。

使用方法如下：

<bean id="parent" class="com.firechou.service.Parent" scope="prototype"/><bean id="child" class="com.firechou.service.Child"/>

如上定义，child是单例Bean（默认单例）。

<bean id="parent" class="com.firechou.service.Parent" scope="prototype"/><bean id="child" class="com.firechou.service.Child" parent="parent"/>

如上定义，child是原型Bean，继承与指定的父类parent的scope属性。

在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。

3 加载类

BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的createBean()方法中，一开始就会调用：

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

如上代码是加载类，具体实现如下：

if (mbd.hasBeanClass()) {// 如果beanClass属性的类型是Class，那么就直接返回return mbd.getBeanClass();}// 根据类名加载if (System.getSecurityManager() != null) {return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());}else {// 利用BeanFactory所设置的类加载器来加载类，如果没有设置，则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载。return doResolveBeanClass(mbd, typesToMatch);} public boolean hasBeanClass() {return (this.beanClass instanceof Class);}

获取加载类的类加载器，方法ClassUtils.getDefaultClassLoader()，流程如下：

优先返回当前线程中的ClassLoader线程中类加载器为null的情况下，返回ClassUtils类的类加载器如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器 4 实例化前

BeanDefinition对应的类成功加载后，就可以实例化对象了，但是在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。

如下：

@Componentpublic class FireBeanPostProcessor implements InstantiationAwareBeanPostProcessor {@Overridepublic Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {// 注意，此时还没有实例化，所以能拿到的是beanClassif ("userService".equals(beanName)) {System.out.println("实例化前");// 可以返回值，非null时，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步return new UserService();}return null;}} 5 实例化

根据BeanDefinition去创建一个对象。

5.1 Supplier创建对象

首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。

直接使用BeanDefinition对象来设置Supplier，比如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setInstanceSupplier(new Supplier<Object>() {@Overridepublic Object get() {return new UserService();}});context.registerBeanDefinition("userService", beanDefinition); 5.2 工厂方法创建对象

如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod，也就是工厂方法，有两种方式可以设置factoryMethod。

方式一：

<bean id="userService" class="com.firechou.service.UserService" factory-method="createUserService" />

对应的UserService类为：

public class UserService {public static UserService createUserService() {System.out.println("执行createUserService()");UserService userService = new UserService();return userService;}public void test() {System.out.println("test");}}

方式二：

<bean id="commonService" class="com.firechou.service.CommonService"/><bean id="userService1" factory-bean="commonService" factory-method="createUserService" />

对应的CommonService的类为：

public class CommonService {public UserService createUserService() {return new UserService();}}

Spring发现当前BeanDefinition方法设置了工厂方法后，就会区分这两种方式，然后调用工厂方法得到对象；通过@Bean所定义的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常类似，@Bean所注解的方法就是factoryMethod，AppConfig对象就是factoryBean。如果@Bean所注解的方法是static的，那么对应的就是方式一；

5.3 推断构造方法

推断完构造方法后，就会使用构造方法来进行实例化了。

选择构造方法以及查找入参对象，判断在对应的类中是否存在使用了@Lookup注解的方法，如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。在实例化时，如果判断出来当前BeanDefinition中没有LookupOverride，那就直接用构造方法反射得到一个实例对象。如果存在LookupOverride对象，也就是类中存在@Lookup注解的方法，那就会生成一个代理对象。

@Lookup注解就是方法注入，如下：

@Componentpublic class UserService {private OrderService orderService;public void test() {OrderService orderService = createOrderService();System.out.println(orderService);}@Lookup("orderService")public OrderService createOrderService() {return null;}} 6 BeanDefinition的后置处理

Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring又提供了一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工。

如下：

@Componentpublic class FireMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {@Overridepublic void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {if ("userService".equals(beanName)) {beanDefinition.getPropertyValues().add("orderService", new OrderService());}}}

在Spring源码中，AutowiredAnnotationBeanPostProcessor就是一个MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中会去查找注入点，并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）。

7 实例化后

在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()。

如下：

@Componentpublic class FireInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {@Overridepublic boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {if ("userService".equals(beanName)) {UserService userService = (UserService) bean;userService.test();}return true;}} 8 自动注入

这里的自动注入指的是Spring的自动注入。

9 处理属性

这个步骤中，就会处理@Autowired、@Resource、@Value等注解，也是通过InstantiationAwareBeanPostProcessor.postProcessProperties()扩展点来实现的，比如我们甚至可以实现一个自己的自动注入功能。

如下：

@Componentpublic class FireInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {if ("userService".equals(beanName)) {for (Field field : bean.getClass().getFields()) {if (field.isAnnotationPresent(FireInject.class)) {field.setAccessible(true);try {field.set(bean, "123");} catch (IllegalAccessException e) {e.printStackTrace();}}}}return pvs;}} 10 执行Aware

完成了属性赋值之后，Spring会执行一些回调，包括：

BeanNameAware：回传beanName给bean对象。BeanClassLoaderAware：回传classLoader给bean对象。BeanFactoryAware：回传beanFactory给对象。 11 初始化前

初始化前，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessBeforeInitialization()。利用初始化前，可以对进行了依赖注入的Bean进行处理。

如下：

@Componentpublic class FireBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if ("userService".equals(beanName)) {System.out.println("初始化前");}return bean;}}

在Spring源码中：

InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法，ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调： EnvironmentAware：回传环境变量EmbeddedValueResolverAware：回传占位符解析器ResourceLoaderAware：回传资源加载器ApplicationEventPublisherAware：回传事件发布器MessageSourceAware：回传国际化资源ApplicationStartupAware：回传应用其他监听对象，可忽略ApplicationContextAware：回传Spring容器ApplicationContext 12 初始化 查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()方法执行BeanDefinition中指定的初始化方法 13 初始化后

这是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessAfterInitialization()。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。

如下：

@Componentpublic class FireBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if ("userService".equals(beanName)) {System.out.println("初始化后");}return bean;}} 总结BeanPostProcessor InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()实例化MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()自动注入InstantiationAwareBeanPostProcessor.postProcessProperties()Aware对象BeanPostProcessor.postProcessBeforeInitialization()初始化BeanPostProcessor.postProcessAfterInitialization() Bean的销毁过程

Bean销毁是发送在Spring容器关闭过程中的。

如下：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);UserService userService = (UserService) context.getBean("userService");userService.test();// 容器关闭context.close();

在Bean创建过程中，在最后（初始化之后），有一个步骤会去判断当前创建的Bean是不是DisposableBean：

当前Bean是否实现了DisposableBean接口或者，当前Bean是否实现了AutoCloseable接口BeanDefinition中是否指定了destroyMethod调用DestructionAwareBeanPostProcessor.requiresDestruction(bean)进行判断： ApplicationListenerDetector中直接使得ApplicationListener是DisposableBeanInitDestroyAnnotationBeanPostProcessor中使得拥有@PreDestroy注解了的方法就是DisposableBean 把符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（一个LinkedHashMap）

在Spring容器关闭过程时：

首先发布ContextClosedEvent事件调用lifecycleProcessor的onCloese()方法销毁单例Bean 遍历disposableBeans 把每个disposableBean从单例池中移除调用disposableBean的destroy()如果这个disposableBean还被其他Bean依赖了，那么也得销毁其他Bean如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉 清空manualSingletonNames，是一个Set，存的是用户手动注册的单例Bean的beanName清空allBeanNamesByType，是一个Map，key是bean类型，value是该类型所有的beanName数组清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例Bean

在定义一个Bean时，如果这个Bean实现了DisposableBean接口，或者实现了AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。