Spring Bean的生命周期

码农叮叮车

于 2023-08-10 19:51:12 发布

阅读量51

点赞数 1

文章标签： spring java

本文链接：https://blog.csdn.net/qq_51593012/article/details/132216575

版权

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

一.Bean 实例化的基本流程

Spring容器在进行初始化时，会将 xml 配置的的信息封装成一个 BeanDefifinition 对象，所有的BeanDefifinition存储到一个名为 beanDefifinitionMap 的 Map 集合中去， Spring 框架在对该 Map 进行遍历，使用反射创建Bean 实例对象，创建好的 Bean 对象存储在一个名为 singletonObjects 的 Map 集合中，当调用getBean方法时则最终从该Map 集合中取出 Bean 实例对象返回。

Bean信息定义对象-BeanDefifinition

BeanDefifinition存储到一个名为beanDefifinitionMap

对象存储在一个名为 singletonObjects 的 Map

Bean 实例化的基本流程

加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefifinition对象;
将BeanDefifinition存储在一个名为beanDefifinitionMap的Map<String,BeanDefifinition>中;
ApplicationContext底层遍历beanDefifinitionMap，创建Bean实例对象;
创建好的Bean实例对象，被存储到一个名为singletonObjects的Map<String,Object>中;
当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

二.Spring的后处理器

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

BeanFactoryPostProcessor：Bean工厂后处理器，在BeanDefifinitionMap填充完毕，Bean实例化之前执行；
BeanPostProcessor：Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行。

1.BeanFactoryPostProcessor

Bean 工厂后处理器 – BeanFactoryPostProcessor

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

演示修改：

1. 创建 BeanFactoryPostProcessor 实现类并重写方法

2. 注入实现类

/**
 * @author lizhihui
 * @version 1.0
 * @since 2023/8/5
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor@BeanFactoryPostProcessor");

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

演示注册：

1. 创建 BeanFactoryPostProcessor 实现类并重写方法

2. 注入实现类

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor@BeanFactoryPostProcessor");

        // 注册演示
        BeanDefinition beanDefinition = new RootBeanDefinition();
        beanDefinition.setBeanClassName("com.itzhi.entity.Student");
        //强转为DefaultListableBeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
        defaultListableBeanFactory.registerBeanDefinition("stu",beanDefinition);

    }
}

Bean 工厂后处理器 – BeanDefifinitionRegistryPostProcessor

Spring 提供了一个 BeanFactoryPostProcessor 的子接 BeanDefifinitionRegistryPostProcessor 专门用于注册BeanDefifinition 操作。

/**
 * @author lizhihui
 * @version 1.0
 * @since 2023/8/5
 */
public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {

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

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

2.BeanPostProcessor

Bean 后处理器 – BeanPostProcessor

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

自定义演示：

/**
 * @author lizhihui
 * @version 1.0
 * @since 2023/8/5
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    /* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization方法");
        return bean;
    }
    /* 参数： bean是当前被实例化的Bean，beanName是当前Bean实例在容器中的名称
返回值：当前Bean实例对象 */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization方法");
        return bean;
    }
}

//2.注入配置MyBeanPostProcessor
<bean class="com.apesource.processors.MyBeanPostProcessor"></bean>

三.Spring Bean的生命周期

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

Bean的实例化阶段：Spring框架会取出BeanDefifinition的信息进行判断当前Bean的范围是否是 singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的 Bean通过反射进行实例化；
Bean的初始化阶段：Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware 接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段；
Bean的完成阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池 singletonObjects中去了，即完成了Spring Bean的整个生命周期。

由于 Bean 的初始化阶段的步骤比较复杂，所以着重研究 Bean 的初始化阶段

Spring Bean 的初始化过程涉及如下几个过程：

Bean实例的属性填充
Aware接口属性注入
BeanPostProcessor的before()方法回调
InitializingBean接口的初始化方法回调
自定义初始化方法init回调
BeanPostProcessor的after()方法回调

Bean 实例属性填充

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

总结：

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

注入普通属性，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去；
注入单向对象引用属性时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象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);
}
//注：将对象保存至三级缓存的时候，会包装成ObjectFactory对象录入，未来通过此接口对应的get方法再次提取对象

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