Bean的生命周期

---

前言

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

Spring Bean的生命周期大体上分为三个阶段:
Bean的实例化->Bean的初始化->Bean的完成阶段->Bean的销毁阶段

---

一、Bean的实例化

Spring容器在进行初始化时，会通过reader解析器将xml配置的的信息封装成一个BeanDefinition对象，所有的BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，拿出每一个BeanDefinition对象，进行过Bean工厂后处理器的执行后，最终创建出一个半成品的Bean对象。

---

二、Bean的初始化

Bean的初始化阶段一般要经过六大节点来完成：

1.属性注入

BeanDefinition 中有对当前Bean实体的注入信息通过属性propertyValues进行了存储，其实就是我们之前所学习的依赖注入。
Spring在进行属性注入时，会分为如下几种情况：
1.注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；
2.注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没
有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作；
3.注入双向对象引用属性时，就比较复杂了，涉及了循环引用（循环依赖）

2.Aware接口属性注入

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

3.BeanPostProcessor的before()方法回调

当 Spring 容器初始化 bean 时，postProcessBeforeInitialization() 方法会在每个 bean 初始化前被调用，postProcessBeforeInitialization() 用于在 bean 初始化前和初始化后进行自定义的处理操作，可以让你在 bean 的生命周期中插入自己的逻辑。

 @Override
    //参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称返回值：当前Bean实例对象
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的before方法");
        return bean;
    }
1
2
3
4
5
6

4.InitializingBean接口的初始化方法回调

InitializingBean 是 Spring 框架中的一个接口，它可以被 Java 类实现，用于在 Spring 容器完成 bean 的属性设置后执行自定义的初始化操作。当 bean 被创建并设置好属性后，Spring 容器会调用实现了 InitializingBean 接口的 afterPropertiesSet() 方法，从而允许开发者在该方法中执行一些初始化逻辑。

public class MyBean implements InitializingBean {
    /*  接口初始化 */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("接口初始化");
        .....
    }
1
2
3
4
5
6
7

5.自定义初始化方法init回调

在 Spring 中，除了实现 InitializingBean 接口和使用 @PostConstruct 注解之外，你还可以通过配置一个自定义的初始化方法来在 bean 初始化时进行回调。这可以通过 XML 配置文件或者使用 @Bean 注解来实现。

@Configuration
public class MyconfigConfig {
    @Bean(initMethod = " System.out.println("静态工厂创建对象");")
    public void doinit() {
        System.out.println("yangshulin");
    }
}
xml文件配置
<bean id="myBean" class="com.xxxx.MyBean" init-method="myBean">
</bean>
1
2
3
4
5
6
7
8
9
10

6.BeanPostProcessor的after()方法回调

当 Spring 容器初始化 bean 时，postProcessAfterInitialization() 方法会在每个 bean 初始化后被调用，postProcessAfterInitialization() 用于在 bean 初始化前和初始化后进行自定义的处理操作，可以让你在 bean 的生命周期中插入自己的逻辑。

  //参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称返回值：当前Bean实例对象
 @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的After方法");
        return null;

    }
1
2
3
4
5
6
7

---

三、Bean的完成阶段

在经历过Bean的实例化、Bean的初始化之后，才会创建出一个真正的完整Bean对象，会保存在一个SingletonObjectsMap的集合中；在该集合中，每个Bean的向的key为Map集合中的id，Bean的实例化对象为这个Map中的value，从而等待用户用getBean（）的方法进行对象的提取；

---

四、Bean的销毁

当spring容器关闭的时候(调用close())方法的时候，所有的单例bean都会被销毁，并且对于实现destroy方法的bean，也会在此刻执行各自自定义的销毁逻辑。
Bean的销毁时不可控的，但是我们可以在bean销毁的前期做一些资源回收等方法的处理，比如：
1.实现 DisposableBean 接口：
DisposableBean 接口定义了一个 destroy() 方法，你可以在这个方法中编写 bean 销毁的逻辑。

public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 在这里编写 bean 的销毁逻辑
        ......
    }
}
1
2
3
4
5
6
7

2.使用 @PreDestroy 注解：
通过在方法上添加 @PreDestroy 注解，你可以标识一个方法作为 bean 的销毁方法。这个方法会在 bean 销毁之前被调用。

public class MyBean {
    @PreDestroy
    public void customDestroy() {
        // 在这里编写 bean 的销毁逻辑
    }
}
1
2
3
4
5
6

除此之外还可以自定义销毁实例方法，实现与自定义初始化方法相同。

---

五、Spring的后处理器

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

1.BeanFactoryPostProcessor

Bean工厂后处理器，在BeanDefinitionMap填充完毕，Bean实例化之前执行；
BeanFactoryPostProcessor是一个接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能。

/**
 * @author 杨树林
 * @version 1.0
 * @since 5/8/2023
 */

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor的PostProcessor");
        //修改演示
        BeanDefinition beanDefinition =configurableListableBeanFactory.getBeanDefinition("user");
        beanDefinition.setBeanClassName("com.apesource.pojo.Student");

        //注册演示：
        BeanDefinition beanDefinition =new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.apesource.pojo.Student");
        //强转成DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)configurableListableBeanFactory;
        defaultListableBeanFactory.registerBeanDefinition("stu",beanDefinition);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.BeanPostProcessor

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

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    //参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称返回值：当前Bean实例对象
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的before方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("BeanPostProcessor的After方法");
        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

六、解决双向依赖的死循环—三级缓存

在bean的属性注入阶段，除了普通注入，单向对象注入之外，还有双向注入。
在双向注入的过程中，多个实体之间相互依赖并形成闭环的情况就叫做"循环依赖"，也叫做"循环引用：

在这样的场景下，就容易引发死循环，导致两个bean都无法注入容器，从而引发栈溢出，最终程序异常退出，具体流程如下：

那么如何解决这种双向注入的问题呢?
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);
}
1
2
3
4
5
6
7
8
9

UserService和UserDao循环依赖的过程结合上述三级缓存:

• UserService 实例化对象，但尚未初始化，将UserService存储到三级缓存；
• UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao；
• UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存；
• UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移 入二级缓存；
• UserDao执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存； UserService注入UserDao；
• UserService执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓 存。

---