Spring bean的生命周期从源码解析

最新推荐文章于 2024-05-04 14:50:05 发布

Java、沧海一粟

最新推荐文章于 2024-05-04 14:50:05 发布

阅读量139

点赞数

分类专栏： Spring 源码解析文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_42584382/article/details/131674791

版权

Spring 源码解析专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring bean的生命周期从源码解析

1、生成BeanDefinition

Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandid
ateComponents(String basePackage) 扫描某个包路径，并得到BeanDefinition的Set集合。

后续讲解spring 的启动流程，此文章主要讲解bean的生命周期

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

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

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

值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是
利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对
象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，
它即可以存储类的名字，也可以存储class对象）。
最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或
解析spring.xml文件的，或者@Bean注解得到BeanDefinition对象。（后续课程会分析
@Bean注解是怎么生成BeanDefinition的）。

以上BeanDefinition扫描过程对应spring 源码
在这里插入图片描述扫描的主要代码，图中第276行代码是扫描的主要逻辑，包括创建Resource生成MetadataReader，感兴趣的可以从我图中的入口方法进入阅读。

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对象是单例的，相信很好理解（因为scope默认值为singleton)

<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。

3、加载类

要想完全理解这部份代码，需要JVM类加载机制的知识储备。
BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就
必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的
createBean()方法中，一开始就会调用：

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

protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch) {
            if (mbd.hasBeanClass()) {
                return mbd.getBeanClass();
            } else {
                return System.getSecurityManager() != null ? (Class)AccessController.doPrivileged(() -> {
                    return this.doResolveBeanClass(mbd, typesToMatch);
                }, this.getAccessControlContext()) : this.doResolveBeanClass(mbd, typesToMatch);
            }
}

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

首先判断beanClass的属性是不是Class，如果是直接返回（上面我们说过第一次扫描到的BeanDefinition中beanClass属性的类型是Object存储的是当前类的名字而不是Class对象（仔细阅读），如果不是调用this.doResolveBeanClass(mbd, typesToMatch)方法去加载类。

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
        ClassLoader beanClassLoader = this.getBeanClassLoader();
        ClassLoader dynamicLoader = beanClassLoader;
        return mbd.resolveBeanClass(beanClassLoader);
    }

这里的关键就是去获取一个类加载器，省略了部分我们阅读不太需要关注的其它代码
this.getBeanClassLoader()会去获取AbstractBeanFactory类的beanClassLoader属性，该属性在初始化AbstractBeanFactory时调用了以下的getDefaultClassLoader获取一个ClassLoader对象。
在这里插入图片描述

public static ClassLoader getDefaultClassLoader() {
        ClassLoader cl = null;

        try {
            cl = Thread.currentThread().getContextClassLoader();
        } catch (Throwable var3) {
        }

        if (cl == null) {
            cl = ClassUtils.class.getClassLoader();
            if (cl == null) {
                try {
                    cl = ClassLoader.getSystemClassLoader();
                } catch (Throwable var2) {
                }
            }
        }

        return cl;
    }

ClassUtils.getDefaultClassLoader()

优先返回当前线程中的ClassLoader
线程中类加载器为null的情况下，返回ClassUtils类的类加载器
如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类（因为Bootstrap类加载器是有hotspot 创建jvm虚拟机时通过C++语言创建的，我们通过java代码是获取不到的），那么
则返回系统类加载器（这里的系统类加载器如果没有其它特别的指定，返回的应当是一个AppClassLoader，大家也可以进行测试）

4、实例化前

当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但是…
在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean
实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()，我们可以实现该接口中的该方法来完成我们程序员想要在bean实例化前完成的事情。比如：

@Component
public class CangHaiBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

        System.out.println("实例化前");
        
        return null;
    }
}

那么，在所有的bean创建实例化之前后台都会打印出“实例化前”。

@Component
public class CangHaiBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

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

postProcessBeforeInstantiation()方法是有返回值的，如果我们像上诉代码一样编写，那么生成的bean就是由我们自己创建的。

5、实例化

该步骤就是根据BeanDefinition去创建对象了，由于创建对象的源码很重要，在bean生命周期中不讲，后期单独出一期spring怎么根据BeanDefinition去实例化。

6、BeanDefinition的后置处理

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

@Component
public class CangHaiMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition rootBeanDefinition, Class<?> aClass, String beanName) {
        if ("userService".equals(beanName)) {
            rootBeanDefinition.getPropertyValues().add("user", new User());
        }
    }
}

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

7、实例化后

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

@Component
public class CangHaiBeanPostProcessor 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源码中基本没有怎么使用。

8、自动注入

这里的自动注入指的是Spring的自动注入，后续关于依赖注入博客中单独讲。

9、属性处理

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

@Component
public class CangHaiBeanPostProcessor 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(CangHaiInject.class)) {
                    field.setAccessible(true);
                    try {
                        field.set(bean, "123");
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return pvs;
    }
}

关于@Autowired、@Resource、@Value的底层源码，会在后续的依赖注入博客中详解

10、执行Aware

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

BeanNameAware：回传beanName给bean对象。
BeanClassLoaderAware：回传classLoader给bean对象。
BeanFactoryAware：回传beanFactory给对象。

11、初始化前

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

@Component
public class CangHaiBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {\
        System.out.println("初始化前");
        return bean;
    }
}

利用初始化前，可以对进行了依赖注入的Bean进行处理。
在Spring源码中：

InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的
方法，
ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：
i. EnvironmentAware：回传环境变量
ii. EmbeddedValueResolverAware：回传占位符解析器
iii. ResourceLoaderAware：回传资源加载器
iv. ApplicationEventPublisherAware：回传事件发布器
v. MessageSourceAware：回传国际化资源
vi. ApplicationStartupAware：回传应用其他监听对象，可忽略
vii. ApplicationContextAware：回传Spring容器ApplicationContext

12、初始化

查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()
方法
执行BeanDefinition中指定的初始化方法

13、初始化后

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

@Component
public class CangHaiBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {\
        System.out.println("初始化后");
        return bean;
    }
}

可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返
回的对象才是最终的Bean对象。关于Spring AOP需要后续单独介绍，也是spring的核心。

总结BeanPostProcessor

InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() ：实例化前
实例化
MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition() ：BeanDefinition后置处理
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() ：实例化后
自动注入
InstantiationAwareBeanPostProcessor.postProcessProperties() ：属性处理（也是依赖注入的关键）
Aware对象
BeanPostProcessor.postProcessBeforeInitialization() ：初始化前
初始化
BeanPostProcessor.postProcessAfterInitialization() ：初始化后