Spring Bean的生命周期

🕗 发布于 2024-01-23 17:44 spring java 后端 spring boot

一、知识点

4 个阶段：
实例化（Instantiation）
属性赋值（Populate）
初始化（Initialization）
销毁（Destruction）

在这里插入图片描述

二、源码分析

// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {

    // 1. 实例化
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
    Object exposedObject = bean;
    try {
        // 2. 属性赋值
        populateBean(beanName, mbd, instanceWrapper);
        // 3. 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }

    // 4. 销毁-注册回调接口
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }

    return exposedObject;
}

// AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // 3. 检查 Aware 相关接口并设置相关依赖
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    // 4. BeanPostProcessor 前置处理
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 5. 若实现 InitializingBean 接口，则调用 afterPropertiesSet() 方法，在属性注入完成后调用
    // 6. 若配置自定义的 init-method方法，则执行
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    // 7. BeanPostProceesor 后置处理
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

// DisposableBeanAdapter.java
public void destroy() {
    // 9. 若实现 DisposableBean 接口，则执行 destory()方法
    if (this.invokeDisposableBean) {
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((DisposableBean) this.bean).destroy();
                    return null;
                }, this.acc);
            }
            else {
                ((DisposableBean) this.bean).destroy();
            }
        }
    }
    
// 10. 若配置自定义的 detory-method 方法，则执行
    if (this.destroyMethod != null) {
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
        if (methodToInvoke != null) {
            invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
        }
    }
}

三、扩展

这些接口的实现类是独立于 Bean 的，并且会注册到 Spring 容器中。在 Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用。

1、InstantiationAwareBeanPostProcessor

该类是 BeanPostProcessor 的子接口，常用的有如下三个方法：
postProcessBeforeInstantiation(Class beanClass, String beanName)：在bean实例化之前调用
postProcessProperties(PropertyValues pvs, Object bean, String beanName)：在bean实例化之后、构造方法前调用
postProcessAfterInstantiation(Class beanClass, String beanName)：在实例化 Bean 之后、构造方法之后调用

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return pvs;
    }
}

2、Aware

组件的“觉醒”
Aware 之前的名字就是可以拿到什么资源，例如 BeanNameAware 可以拿到 BeanName，以此类推。
调用时机：所有的 Aware 方法都是在初始化阶段之前调用的

若 Spring 检测到 bean 实现了 Aware 接口，则会为其注入相应的依赖。
–> 通过让 bean 实现 Aware 接口，则能在 bean 中获得相应的 Spring 容器资源。

当组件实现Aware接口的时候，会实现Aware接口里提供的 setXXX方法
这些 setXXX方法可以让组件对象获取一些信息，形参中会包含对应的信息，比如组件在容器中的组件id等

BeanFactory 类型的容器

Spring 中提供的 Aware 接口：
BeanNameAware：该接口只有一个方法 setBeanName(String name)，用来获取 bean 的 id 或者 name。
BeanClassLoaderAware：该接口只有一个方法 setBeanClassLoader(ClassLoader bc1)，用来获取 bean 的 ClassLoader。
BeanFactoryAware：该接口只有一个方法 setBeanFactory(BeanFactory beanFactory)，用来获取当前环境中的 BeanFactory。

// AbstractAutowireCapableBeanFactory.java
private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

ApplicationContext 类型的容器

Spring 中提供的 Aware 接口：常用：
ApplicationContextAware：该接口只有一个方法 setApplicationContext(ApplicationContext applicationContext)，用来获取当前环境中的 ApplicationContext。

// ApplicationContextAwareProcessor.java
private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof EnvironmentAware) { // 注入 Enviroment，一般用于获取配置属性
        ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
    }
    if (bean instanceof EmbeddedValueResolverAware) { // 注入 EmbeddedValueResolver（Spring EL解析器），一般用于参数解析
        ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
    }
    if (bean instanceof ResourceLoaderAware) {
        ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
    }
    if (bean instanceof ApplicationEventPublisherAware) {
        ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
    }
    if (bean instanceof MessageSourceAware) {
        ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
    }
    if (bean instanceof ApplicationContextAware) {
        ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
    }
}

2、BeanPostProcessor

BeanPostProcessor 是 Spring 为修改 bean 提供的强大扩展点，其可作用于容器中除它本身外所有 bean
常用于：为当前对象提供代理实现。例如 Spring AOP 功能，生成对象的代理类，然后返回

该接口有两个方法：
postProcessBeforeInitialization(Object bean, String beanName)：初始化前置处理，在初始化之前调用此方法
postProcessAfterInitialization(Object bean, String beanName)：初始化后置处理，在初始化之后调用此方法

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

// AbstractAutoProxyCreator.java
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // 返回代理类
        return proxy;
    }
    return null;
}

四、实例

1、注解方式

dao层：

@Getter
@ToString
@Repository
public class UserDao implements InitializingBean, BeanNameAware, DisposableBean, ApplicationContextAware {

    private Integer id;
    private String name;

    // 1-1. 实例化 Bean 实例：调用构造方法
    public UserDao(Integer id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("调用全参构造函数");
    }

    // 1-1. 实例化 Bean 实例：调用构造方法
    // 具体使用哪一个构造方式看 new 对象
    public UserDao() {
        System.out.println("调用无参构造函数");
    }

    // 2. 设置对象属性 属性注入
    public void setId(Integer id) {
        this.id = id;
        System.out.println("\n2. 设置对象属性");
        System.out.println("id属性注入");
    }

    // 2. 设置对象属性 属性注入
    public void setName(String name) {
        this.name = name;
        System.out.println("name属性注入");
    }

    // 3. 初始化--检查 Aware 相关接口并设置相关依赖
    // BeanNameAware 下的 setBeanName 方法
    @Override
    public void setBeanName(String name) {
        System.out.println("\n3. 初始化");
        System.out.println("调用 BeanNameAware.setBeanName() 方法");
    }

    // 3。 初始化--检查 Aware 相关接口并设置相关依赖
    // ApplicationContextAware 下的 setApplicationContext 方法
    // if (bean instanceof ApplicationContextAware) {
    //        ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
    //    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        System.out.println("3. 检查 Aware 相关接口并设置相关依赖---调用 ApplicationContextAware.setApplicationContext() 方法");
    }

    // 4. BeanPostProcessor 前置处理 见 MyBeanPostProcessor类

    // 5. 初始化--是否实现 InitializingBean 接口
    // InitializingBean 下的 afterPropertiesSet 方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. 是否实现 InitializingBean 接口---调用 InitializingBean.afterPropertiesSet() 方法");
    }

    // 6. 初始化--是否配置自定义的 init-method
    public void myInit() {
        System.out.println("6. 是否配置自定义的 init-method---调用 init-method 方法");
    }

    // 7. BeanPostProcessor 后置处理 见 MyBeanPostProcessor类

    // 8. 注册 Destruction 相关回调接口 略

    // 9. 销毁--是否实现 DisposableBean 接口
    // DisposableBean 下的 destroy 方法
    @Override
    public void destroy() throws Exception {
        System.out.println("\n4. 销毁");
        System.out.println("调用 DisposableBean.destroy() 方法");
    }

    // 10. 销毁--是否配置自定义的 destroy-method
    public void myDestroy() throws Exception {
        System.out.println("调用 destroy-method 方法");
    }
}

@Repository
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    // 1-0. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法 在实例化 Bean 之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("1. 实例化 Bean 实例");
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法");
        }
        return null;
    }

    // 1-1. 实例化 Bean 实例：调用全参构造方法 见 UserDao

    // 1-2. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法 在实例化 Bean 之后、构造方法之前调用
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            UserDao userDao = (UserDao) bean;
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法");
        }
        return true;
    }

    // 1-3. 实例化 Bean 实例
    // InstantiationAwareBeanPostProcessor.postProcessProperties() 方法 在实例化 Bean 之后、构造方法之后调用
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("调用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法");
        }
        return null;
    }
}

@Repository
public class MyBeanPostProcessor implements BeanPostProcessor {

    // 4. 初始化--BeanPostProcessor 前置处理
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("4. BeanPostProcessor 前置处理---调用 BeanPostProcessor.postProcessBeforeInitialization() 方法");
        }
        return bean;
    }

    // 7.初始化--BeanPostProcessor 后置处理
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userDao".equals(beanName)) {
            System.out.println("7. BeanPostProcessor 后置处理---调用 BeanPostProcessor.postProcessAfterInitialization() 方法");
        }
        return bean;
    }
}

配置类：

@Configuration
public class MyConfig {

    // @Bean(initMethod = "myInit", destroyMethod = "destroy") // 不执行 myDestroy
    @Bean(initMethod = "myInit", destroyMethod = "myDestroy") // 执行 myDestroy 和 destroy
    public UserDao userDao() {
        return  new UserDao(23, "xiaoyu-alive");
    }

    @Bean
    public MyInstantiationAwareBeanPostProcessor myInstantiationAwareBeanPostProcessor() {
        return  new MyInstantiationAwareBeanPostProcessor();
    }

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return  new MyBeanPostProcessor();
    }
}

测试类：

@SpringBootTest
public class SpringbootdemoApplicationTests {

    @Test
    public void test() throws Exception {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        Object userDao = applicationContext.getBean("userDao");
        // 销毁方法只有在IOC容器关闭的时候才调用，所以在测试代码中关闭IOC容器
        //关闭ioc容器
        applicationContext.close();
    }
}

在这里插入图片描述

2、xml配置文件方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean class="com.test.springbootdemo.dao.MyInstantiationAwareBeanPostProcessor"></bean>

    <bean id="userDao" class="com.test.springbootdemo.dao.UserDao">
        <property name="id" value="23"/>
        <property name="name" value="xiaoyu-alive"></property>
    </bean>

    <bean class="com.test.springbootdemo.dao.MyBeanPostProcessor"></bean>
</beans>

@Test
public void mytest() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml"); // 也可以使用绝对路径
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    ((AbstractApplicationContext) applicationContext).close();
}

测试结果同上

注：取消 MyInstantiationAwareBeanPostProcessor 和 MyBeanPostProcessor 的注入的测试结果：

在这里插入图片描述

参考：

如何记忆 Spring Bean 的生命周期

Spring注解(六)：Bean的生命周期中自定义初始化和销毁方法的四种方式

一文读懂 Spring Bean 的生命周期

原文地址：https://blog.csdn.net/xiaoyu_alive/article/details/135740524

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：汽车售后服务客户满意度调查内容
下一篇：日本那霸市最新倾斜模型3DTiles数据

【C++】list 类深度解析：探索双向链表的奇妙世界
本文深度解析了 C++ 标准库中的 list 类。首先阐述学习 list 类的原因，其具有高效插入删除操作优势，如双向链表结构使插入删除只需调指针，时间复杂度常数级；内存管理灵活，节点分散存储避免内存
阅读更多2024-11-16
常用List工具类（取交集、并集等等）
【代码】常用List工具类（取交集、并集等等）
阅读更多2024-11-16
宝塔面板从 Nginx 切换到 Caddy：详细教程
宝塔面板从 Nginx 切换到 Caddy
阅读更多2024-11-16
计算机网络中的数据包传输机制详解
数据包是网络通信的基本单位，它包含了控制信息（如源地址、目的地址等）和用户数据（即有效载荷）。根据不同的网络协议，数据包的结构会有所不同。数据包的传输机制是计算机网络的核心内容之一，它涉及到数据的封装
阅读更多2024-11-16
LinkedList 源码分析
仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1)，其他情况增删元素的平均时间复杂度都是 O(n)。底层数据结构是链表，内存地址不连续，只能通过指针来定位，不支持随机快速访问，所以不能实现。是一
阅读更多2024-11-16
【泛型 Plus】Kotlin 的加强版类型推断：@BuilderInference
视频先行下面是视频内容的脚本文案原稿分享。小剧场面试官：「既然协程和泛型你都熟悉，flow() 函数是怎么实现类型推断的有了解过吗？」求职者：「嗯……」求职者：「嗯……在Kotlin协程中，flow
阅读更多2024-11-16
20.UE5UI预构造，开始菜单
如果我们直接再画布上设计我们的按钮，我们需要为每一个按钮进行编辑，复用性太差，能不能在其他的UI蓝图中编辑好，随后就好像其他元素（文本，button）一样，直接放入到我们的画布中？为了在复用时，可以自
阅读更多2024-11-16
支持向量机SVM——基于分类问题的监督学习算法
支持向量机SVM是一种常用于分类问题的监督学习算法。文章主要从基础公式角度讲解它的基本原理，涉及线性和非线性情况。
阅读更多2024-11-16
鸿蒙生态下的安全隐私保护：打造用户信任的应用体验
作为开发者，在享受鸿蒙生态系统带来的广阔市场机遇的同时，也面临着保障用户数据安全和隐私保护的重要责任。同时，开发者需要向用户提供清晰的信息收集和使用的说明，让用户了解自己的数据如何被使用。总的来说，在
阅读更多2024-11-16
基本数据类型：Kotlin、Dart (Flutter)、Java 和 C++ 的比较
本文比较了 Kotlin、Dart (Flutter)、Java 和 C++ 中的基本数据类型，并探讨了有符号和无符号整数的区别。文章还详细解释了二进制补码的计算方式和其在计算机系统中的应用。理解这些
阅读更多2024-11-16

Spring Bean的生命周期

目录

一、知识点

二、源码分析

三、扩展

1、InstantiationAwareBeanPostProcessor

2、Aware

BeanFactory 类型的容器

ApplicationContext 类型的容器

2、BeanPostProcessor

四、实例

1、注解方式

2、xml配置文件方式

相关文章