Spring Bean的生命周期

是大眼同学！

已于 2023-08-06 20:25:46 修改

阅读量161

点赞数 1

文章标签： spring java idea xml

于 2023-08-06 20:09:30 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_52572813/article/details/132134045

版权

本文详细阐述了Spring中Bean的实例化流程，包括BeanFactoryPostProcessor和BeanPostProcessor的作用，以及SpringBean的生命周期和属性注入过程，特别关注了循环依赖的解决方案和Aware接口的运用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、Bean实例化的基本流程

二、Spring的后处理器

1. BeanFactoryPostProcessor

2.BeanPostProcessor

三、Spring Bean的生命周期

生命周期总结

一、Bean实例化的基本流程

Bean实例化的基本流程：
加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象；

将BeanDefinition存储在一个名为beanDefinitionMap的Map中；

ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象；

创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中；

当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回。

二、Spring的后处理器

Spring的后处理器是Spring对外开发的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。

Spring主要有两种后处理器：

（1）BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；

（2）BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。

1. BeanFactoryPostProcessor

Bean工厂后处理器 – BeanFactoryPostProcessor

BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么 Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

演示修改：

（1）创建BeanFactoryPostProcessor实现类并重写方法；

（2）注入实现类。

演示注册：

（1）创建BeanFactoryPostProcessor实现类并重写方法；

（2）注入实现类。

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的postProcessBeanFactory");
        //注册演示
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.dytx.pojo.Student");
        //强转为DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
        defaultListableBeanFactory.registerBeanDefinition("stu1",beanDefinition);

        //修改演示
//        BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition("user");
//        beanDefinition.setBeanClassName("com.dytx.pojo.Student");
    }
}

Bean工厂后处理器 – BeanDefinitionRegistryPostProcessor

Spring 提供了一个BeanFactoryPostProcessor的子接口BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.dytx.pojo.Student");
        beanDefinitionRegistry.registerBeanDefinition("stu2",beanDefinition);
    }
}

2.BeanPostProcessor

Bean后处理器 – BeanPostProcessor

Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，中间会经过Bean的初始化过程，例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

自定义演示：

//1.自定义MyBeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {
/* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeanPostProcessor的before方法...");
return bean;
}
/* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeanPostProcessor的after方法...");
return bean;
}
}
//2.注入配置MyBeanPostProcessor
<bean class="com.apesource.processors.MyBeanPostProcessor"></bean>
//3.测试控制台打印结果如下
User创建了...
BeanPostProcessor的before方法...
User属性填充...
User初始化方法执行...
BeanPostProcessor的after方法...
com.apesource.pojo.User@56ac3a89

三、Spring Bean的生命周期

Spring Bean的生命周期是从Bean实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为三个阶段：

（1）Bean的实例化阶段：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是 singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的 Bean通过反射进行实例化；

（2）Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段；

(3)Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期。

由于Bean的初始化阶段的步骤比较复杂，所以着重研究Bean的初始化阶段 Spring Bean的初始化过程涉及如下几个过程：

Bean实例的属性填充；

Aware接口属性注入；

BeanPostProcessor的before()方法回调；

InitializingBean接口的初始化方法回调；

自定义初始化方法init回调BeanPostProcessor的after()方法回调。

Bean实例属性填充

BeanDefinition 中有对当前Bean实体的注入信息通过属性propertyValues进行了存储，例如

总结：Spring在进行属性注入时，会分为如下几种情况：

（1）注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；

（2）注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；

（3）注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）

注入双向对象引用属性演示：

含义：多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用"。

解决方案：

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环引用问题在DefaultListableBeanFactory的上四级父类DefaultSingletonBeanRegistry中提供如下三个Map

public class DefaultSingletonBeanRegistry ... {
//1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存"
Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为"二级缓存"
Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
//3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为"三
级缓存"
Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
}

注：将对象保存至三级缓存的时候，会包装成ObjectFactory对象录入，未来通过此接口对应的get方法再次提取对象。

UserService和UserDao循环依赖的过程结合上述三级缓存描述一下：

（1）UserService 实例化对象，但尚未初始化，将UserService存储到三级缓存；

（2）UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao；

（3）UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存；

（4）UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级缓存；

（5）UserDao执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存；

（6） UserService 注入UserDao；

（7）UserService执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存。

常用的Aware接口

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口。框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。

总结：处理器的作用，为Bean生命周期各个阶段提供扩展

生命周期总结

Spring Bean的生命周期总体分四个阶段：实例化=>属性注入=>初始化=>销毁。

·Step1 实例化 Bean:根据配置文件中 Bean的定义，利用Java Reflection反射技术创建 Bean 的实例；
·Step2 注入对象依赖的属性值(或对象)；
·Step3 处理各种Aware接口:Spring会检测该Bean是否实现了*xxAware接口，通过A ware类型的接口，可以让Spring框架为当前Bean注入相应的内容。
（1）如果Bean实现BeanNameAware接口，会调用它实现的setBeanName(String beanI d)方法，注入Bean的名字；
（2）如果Bean实现BeanClassLoaderAware接口，调用setBeanClassLoader()方法，注入ClassLoader 对象的实例；
o如果Bean实现BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，注入的是Spring工厂；
（3）如果Bean实现ApplicationContextAware接口，会调用setApplicationContext()方法，注入Spring上下文;
·Step4 执行BeanPostProcessor前置处理:如果想对Bean进行一些自定义的前置处理，那么可以让Bean实现了BeanPostProcessor接口，将会在该阶段调用postProcessBefor eInitialization(Object obj, String s)方法。
·Step5 执行InitializingBean初始化方法:如果Bean实现了InitializingBean接口，执行afeterPropertiesSet()方法；
·Step6 执行init-method自定义初始化方法:如果Bean在Spring配置文件中配置了in it-method 属性，则会自动调用其配置的初始化方法；
·Step7 执行BeanPostProcessor后置处理:如果这个Bean实现了BeanPostProcessor接口,将会调用postProcessAfterInitialization(Object objString s)方法，由于这个方法是在Bean初始化结束后调用;
，以上几个步骤完成后， Bean 已经被正确创建，可以正常使用这个 Bean了；
·Step8 执行DisposableBean销毁Bean:当Bean不再需要时，会经过清理阶段，如果Bea n实现了DisposableBean这个接口，会调用其实现的destroy()方法执行销毁；
·Step9执行destroy-method自定义销毁方法:如果这个Bean的Spring配置中配置了d estroy-method属性，会自动调用其配置的自定义销毁方法。