Spring源码解读（4）---Bean生命周期源码解析

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

＊King＊

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

阅读量612

点赞数

分类专栏： Spring系列文章标签： spring java 后端

本文链接：https://blog.csdn.net/wlchina123/article/details/121254434

版权

Spring系列专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一、Bean的生命周期流程：

在这里插入图片描述

二、Spring扫描流程：

在这里插入图片描述

三、Bean的生成过程：

1、生成BeanDefinition

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

Spring扫描流程：参考上面的流程图

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

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有：1、获取类的名字，2、获取父类的名字，3、获取所实现的所有接口名，4、获取所有内部类的名字，5、判断是不是抽象类，6、判断是不是接口，7、判断是不是一个注解，8、获取拥有某个注解的方法集合，9、获取类上添加的所有注解信息，10、获取类上添加的所有注解类型集合。

以上是通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的，或者@Bean注解得到BeanDefinition对象。

2、合并BeanDefiniton

通过扫描得到所有的BeanDefinition后就可以根据BeanDefinition创建Bean对象了，但在Spring中支持父子BeanDefinition。

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

这样定义的child就是原型Bean了，因为child的父BeanDefinition是parant，所以会继承parent上所定义的scope属性。而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition.

3、加载类

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

// 这行代码就是去加载类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName)

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

ClassUtils.getDefaultClassLoader()：1、优化返回当前线程中的ClassLoader。2、线程中类加载器为null的情况下，返回ClassUtils类的类加载器。3、如果ClassUtils类的类加载器为空，则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器。

4、实例化前

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

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

@Component
public class WlBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("userService".equals(beanName)){
            System.out.println("实例化前");
        }
        return null;
    }
}

以上的代码会在userService这个Bean实例化前进行打印。这个方法是有返回值的。

@Component
public class WlBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("userService".equals(beanName)){
            System.out.println("实例化前");
            return new UserService();
        }
        return null;
    }
}

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

5、实例化

实例化时会根据BeanDefinition去创建一个对象

（1）Supplier创建对象

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

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

（2）工厂方法创建对象

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

第一种方式：

<bean id="userService" class="com.example.spring.UserService" factory‐
method="createUserService" />

对应的UserService类为：

@Component
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.example.spring.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的，那么对应的就是方式一。

（3）推断构造方法

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

@Component
public 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进行加工。

@Component
public class KingMergedBeanDefinitionPostProcessor 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）。

7、实例化后

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

@Component
public class KingInstantiationAwareBeanPostProcessor 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所实例化出来的对象进行处理

8、自动注入

Spring的自动注入

9、处理属性

在这一步就会处理@Autowired、@Resource、@Value等注解，也是通过**InstantiationAwareBeanPostProcessor.postProcessProperties()**扩展点来实现的

我们可以实现一个自己的自动注入功能：

@Component
public class KingInstantiationAwareBeanPostProcessor 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((Class<? extends Annotation>) KingInject.class)) {
                    field.setAccessible(true);
                    try {
                        field.set(bean,"aaa");
                    }catch (IllegalAccessException e){
                        e.printStackTrace();
                    }
                }
            }
        }
        return pvs;
    }
}

10、执行Aware

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

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

11、初始化前

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

@Component
public class KingBeanPostProcessor 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的回调：

EnvironmentAware：回传环境变量
EmbeddedValueResolverAware：回传占位符解析器
ResourceLoaderAware：回传资源加载器
ApplicationEventPublisherAware：回传事件发布器
MessageSourceAware：回传国际化资源
ApplicationStartupAware：回传应用其他监听对象
ApplicationContextAware：回传Spring容器ApplicationContext

12、初始化

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

13、初始化后

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

@Component
public class KingBeanPostProcessor implements BeanPostProcessor {

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

Spring中AOP就是基于初始化后实现的，初始化后返回的对象才是最终的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)进行判断

(1)ApplicationListenerDetector中直接使得ApplicationListener是DisposableBean

(2)InitDestroyAnnotationBeanPostProcessor中使得拥有@PreDestroy注解了的方法就是 DisposableBean

把符合上述任意一个条件的Bean适配成DisposableBeanAdapter对象，并存入disposableBeans中（LinkedHashMap）

在Spring容器关闭过程时：

首先发布ContextClosedEvent事件
调用lifecycleProcessor的onClose()方法
销毁单例Bean：

（1）遍历disposableBeans把每个disposableBean从单例池中移除，调用disposableBean的destroy()，如果这个disposableBean还被其他Bean依赖了，那么也得销毁其他Bean，如果这个disposableBean还包含了inner beans，将这些Bean从单例池中移除掉。

（2）清空manualSingletonNames，是一个Set，存的是用户手动注册的单例Bean的 beanName

（3）清空allBeanNamesByType，是一个Map，key是bean类型，value是该类型所有的 beanName数组

（4）清空singletonBeanNamesByType，和allBeanNamesByType类似，只不过只存了单例 Bean

这里有使用适配器模式：

在销毁时，Spring会找出实现了DisposableBean接口的Bean。但我们在定义一个Bean时，如果这个Bean实现了DisposableBean接口，或者实现了 AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。所以这里需要适配，将实现了DisposableBean接口、或者AutoCloseable接口等适配成实现了DisposableBean接口，所以就用到了DisposableBeanAdapter。会把实现了AutoCloseable接口的类封装成DisposableBeanAdapter，而DisposableBeanAdapter 实现了DisposableBean接口。

pring会找出实现了DisposableBean接口的Bean。但我们在定义一个Bean时，如果这个Bean实现了DisposableBean接口，或者实现了 AutoCloseable接口，或者在BeanDefinition中指定了destroyMethodName，那么这个Bean都属于“DisposableBean”，这些Bean在容器关闭时都要调用相应的销毁方法。所以这里需要适配，将实现了DisposableBean接口、或者AutoCloseable接口等适配成实现了DisposableBean接口，所以就用到了DisposableBeanAdapter。会把实现了AutoCloseable接口的类封装成DisposableBeanAdapter，而DisposableBeanAdapter 实现了DisposableBean接口。

＊King＊

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring源码解读（4）---Bean生命周期源码解析

一、Bean的生命周期流程：二、Spring扫描流程：三、Bean的生成过程：1、生成BeanDefinitionSpring在启动的时候会进行扫描，会先调用：org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandid ateComponents(String basePackage) 扫描某个包路径，并得到BeanDefinition的Set集合。Spring扫描流
复制链接

扫一扫