spring-bean的生命周期-【源码解析】-上

一、spring的bean概念

Spring最重要的功能就是帮助程序员创建对象也就是IOC而启动Spring就是为创建Bean对象做准备所以我们先明白Spring到底是怎么去创建Bean的也就是先弄明白Bean的生命周期。

Bean的生命周期就是指在Spring中一个Bean是如何生成的如何销毁的

Bean生命周期流程图

二、bean的生成过程

2.1 生成BeanDefinition

Spring启动的时候会进行扫描会先调用

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)

扫描某个包路径并得到BeanDefinition的Set集合。

Spring扫描底层流程

1. 首先通过ResourcePatternResolver获得指定包路径下的所有.class文件Spring源码中将此文件包装成了Resource对象

2. 遍历每个Resource对象

3. 利用MetadataReaderFactory解析Resource对象得到MetadataReader在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactoryMetadataReader的具体实现类为SimpleMetadataReader

4. 利用MetadataReader进行excludeFilters和includeFilters以及条件注解@Conditional的筛选条件注解并不能理解某个类上是否存在@Conditional注解如果存在则调用注解中所指定的类的match方法进行匹配匹配成功则通过筛选匹配失败则pass掉。

5. 筛选通过后基于metadataReader生成ScannedGenericBeanDefinition

6. 再基于metadataReader判断是不是对应的类是不是接口或抽象类

7. 如果筛选通过那么就表示扫描到了一个Bean将ScannedGenericBeanDefinition加入结果集

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

8. 获取类的名字、

9. 获取父类的名字

10. 获取所实现的所有接口名

11. 获取所有内部类的名字

12. 判断是不是抽象类

13. 判断是不是接口

14. 判断是不是一个注解

15. 获取拥有某个注解的方法集合

16. 获取类上添加的所有注解信息

17. 获取类上添加的所有注解类型集合

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

最后上面是说的通过扫描得到BeanDefinition对象我们还可以通过直接定义BeanDefinition或解析spring.xml文件的<bean/>或者@Bean注解得到BeanDefinition对象。

2.2 合并BeanDefinition

通过扫描得到所有BeanDefinition之后就可以根据BeanDefinition创建Bean对象了但是在Spring中支持父子BeanDefinition和Java父子类类似但是完全不是一回事。

父子BeanDefinition实际用的比较少使用是这样的比如

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

这么定义的情况下child是单例Bean。

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

但是这么定义的情况下child就是原型Bean了。

因为child的父BeanDefinition是parent所以会继承parent上所定义的scope属性。

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

2.3 加载类

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

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

这行代码就是去加载类该方法是这么实现的

if (mbd.hasBeanClass()) { return mbd.getBeanClass();}if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->  doResolveBeanClass(mbd, typesToMatch), getAccessControlContext()); }else { return doResolveBeanClass(mbd, typesToMatch);}

public boolean hasBeanClass() { return (this.beanClass instanceof Class);}

如果beanClass属性的类型是Class那么就直接返回如果不是则会根据类名进行加载doResolveBeanClass方法所做的事情

会利用BeanFactory所设置的类加载器来加载类如果没有设置则默认使用ClassUtils.getDefaultClassLoader()所返回的类加载器来加载。

ClassUtils.getDefaultClassLoader()

1. 优先返回当前线程中的ClassLoader

2. 线程中类加载器为null的情况下返回ClassUtils类的类加载器

3. 如果ClassUtils类的类加载器为空那么则表示是Bootstrap类加载器加载的ClassUtils类那么则返回系统类加载器

2.4 实例化前

当前BeanDefinition对应的类成功加载后就可以实例化对象了但是...

在Spring中实例化对象之前Spring提供了一个扩展点允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如

@Componentpublic class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {  if ("userService".equals(beanName)) {   System.out.println("实例化前");  }  return null; }}

如上代码会导致在userService这个Bean实例化前会进行打印。

值得注意的是postProcessBeforeInstantiation()是有返回值的如果这么实现

@Componentpublic class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {  if ("userService".equals(beanName)) {   System.out.println("实例化前");   return new UserService();  }  return null; }}

userService这个Bean在实例化前会直接返回一个由我们所定义的UserService对象。如果是这样表示不需要Spring来实例化了并且后续的Spring依赖注入也不会进行了会跳过一些步骤直接执行初始化后这一步。

2.5 实例化

在这个步骤中就会根据BeanDefinition去创建一个对象了。

2.5.1 Supplier创建对象

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

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

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();beanDefinition.setInstanceSupplier(new Supplier<Object>() { @Override public Object get() {  return new UserService(); }});context.registerBeanDefinition("userService", beanDefinition);

2.5.2 工厂方法创建对象

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

方式一

<bean id="userService" class="com.zhouyu.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.zhouyu.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所注解的方法就是factoryMethodAppConfig对象就是factoryBean。如果@Bean所所注解的方法是static的那么对应的就是方式一。

2.5.3 推断构造方法

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

额外的在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象意外会还判断是否在对应的类中是否存在使用@Lookup注解了方法。如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。

在实例化时如果判断出来当前BeanDefinition中没有LookupOverride那就直接用构造方法反射得到一个实例对象。如果存在LookupOverride对象也就是类中存在@Lookup注解了的方法那就会生成一个代理对象。

@Lookup注解就是方法注入使用demo如下

@Componentpublic class UserService { private OrderService orderService; public void test() {  OrderService orderService = createOrderService();  System.out.println(orderService); } @Lookup("orderService") public OrderService createOrderService() {  return null; }}

2.6 BeanDefinition的后置处理

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

@Componentpublic class ZhouyuMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor { @Override public 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。

2.7 实例化后

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

@Componentpublic class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {  if ("userService".equals(beanName)) {   UserService userService = (UserService) bean;   userService.test();  }  return true; }}

上述代码就是对userService所实例化出来的对象进行处理。

这个扩展点在Spring源码中基本没有怎么使用。

2.8 自动注入

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

2.9 处理属性

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

@Componentpublic class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { @Override public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {  if ("userService".equals(beanName)) {   for (Field field : bean.getClass().getFields()) {    if (field.isAnnotationPresent(ZhouyuInject.class)) {     field.setAccessible(true);     try {      field.set(bean, "123");     } catch (IllegalAccessException e) {      e.printStackTrace();     }    }   }  }  return pvs; }}

关于@Autowired、@Resource、@Value的底层源码会在后续的依赖注入课程中详解。

2.10 执行Aware

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

1. BeanNameAware回传beanName给bean对象。

2. BeanClassLoaderAware回传classLoader给bean对象。

3. BeanFactoryAware回传beanFactory给对象。

2.11 初始化前

初始化前也是Spring提供的一个扩展点BeanPostProcessor.postProcessBeforeInitialization()比如

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

利用初始化前可以对进行了依赖注入的Bean进行处理。

在Spring源码中

1. InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法

2. ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调

1. EnvironmentAware回传环境变量

2. EmbeddedValueResolverAware回传占位符解析器

3. ResourceLoaderAware回传资源加载器

4. ApplicationEventPublisherAware回传事件发布器

5. MessageSourceAware回传国际化资源

6. ApplicationStartupAware回传应用其他监听对象可忽略

7. ApplicationContextAware回传Spring容器ApplicationContext

2.12 初始化

1. 查看当前Bean对象是否实现了InitializingBean接口如果实现了就调用其afterPropertiesSet()方法

2. 执行BeanDefinition中指定的初始化方法

2.13 初始化后

这是Bean创建生命周期中的最后一个步骤也是Spring提供的一个扩展点BeanPostProcessor.postProcessAfterInitialization()比如

@Componentpublic class ZhouyuBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  if ("userService".equals(beanName)) {   System.out.println("初始化后");  }  return bean; }}

可以在这个步骤中对Bean最终进行处理Spring中的AOP就是基于初始化后实现的初始化后返回的对象才是最终的Bean对象。

三、总结BeanPostProcessor

1. InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()

2. 实例化

3. MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()

4. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()

5. 自动注入

6. InstantiationAwareBeanPostProcessor.postProcessProperties()

7. Aware对象

8. BeanPostProcessor.postProcessBeforeInitialization()

9. 初始化

10. BeanPostProcessor.postProcessAfterInitialization()