Spring Bean生命周期管理技术详解：面试必考！

Spring Bean生命周期管理技术详解：面试必考！

引用

CSDN

等

13

来源

1.

https://blog.csdn.net/qq_38658567/article/details/107473266

2.

https://blog.csdn.net/J080624/article/details/79856218

3.

https://blog.csdn.net/ww2651071028/article/details/130519309

4.

https://blog.csdn.net/qq_32099833/article/details/136158462

5.

https://blog.csdn.net/m0_46897923/article/details/129850717

6.

https://blog.csdn.net/m0_51176516/article/details/139265116

7.

https://blog.csdn.net/qq_33589510/article/details/122870732

8.

https://juejin.cn/post/7075168883744718856

9.

https://www.baeldung.com/spring-beanpostprocessor

10.

https://juejin.cn/post/6844904065457979405

11.

https://www.cnblogs.com/redwinter/p/16296394.html

12.

https://cloud.tencent.com/developer/article/1730097

13.

https://bbs.huaweicloud.com/blogs/353243

在Spring框架中，Bean的生命周期管理是一个核心概念，也是面试中的常见考点。从Bean的创建到销毁，Spring提供了多个扩展点，允许开发者在不同阶段进行自定义操作。本文将详细解析Spring Bean的生命周期，帮助你彻底掌握这一知识点。

Bean生命周期概述

Spring Bean的生命周期可以分为四个主要阶段：

1. 实例化（Instantiation）：容器根据配置创建Bean实例。
2. 属性赋值（Populate）：通过依赖注入完成属性赋值。
3. 初始化（Initialization）：调用初始化方法，使Bean进入可用状态。
4. 销毁（Destruction）：在容器关闭时执行清理工作。

关键扩展点详解

1. Aware接口

Aware接口允许Bean在创建过程中获取容器的相关信息。常见的Aware接口包括：

• BeanNameAware：获取Bean的名称
• BeanFactoryAware：获取BeanFactory实例
• ApplicationContextAware：获取ApplicationContext实例

示例代码：

public class MyBean implements BeanNameAware, BeanFactoryAware {
    private String beanName;
    private BeanFactory beanFactory;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
    }

    @Override
    public void setBeanFactory(BeanFactory factory) throws BeansException {
        this.beanFactory = factory;
    }
}

2. BeanPostProcessor

BeanPostProcessor提供了在Bean初始化前后进行处理的机制。它包含两个主要方法：

• postProcessBeforeInitialization：初始化前处理
• postProcessAfterInitialization：初始化后处理

示例代码：

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化前进行处理
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 在初始化后进行处理
        return bean;
    }
}

3. 初始化方法

Spring提供了多种方式定义Bean的初始化方法：

• InitializingBean接口：实现afterPropertiesSet方法
• @PostConstruct注解：标注初始化方法
• init-method配置：通过XML或注解配置初始化方法

示例代码：

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
    }

    @PostConstruct
    public void init() {
        // 初始化逻辑
    }
}

4. 销毁方法

与初始化类似，Spring也提供了多种方式定义Bean的销毁方法：

• DisposableBean接口：实现destroy方法
• @PreDestroy注解：标注销毁方法
• destroy-method配置：通过XML或注解配置销毁方法

示例代码：

public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
    }

    @PreDestroy
    public void cleanup() {
        // 销毁逻辑
    }
}

执行顺序

Bean生命周期各个阶段的执行顺序如下：

1. 实例化
2. 属性赋值
3. Aware接口方法调用
4. BeanPostProcessor的postProcessBeforeInitialization
5. 初始化方法（@PostConstruct → InitializingBean → init-method）
6. BeanPostProcessor的postProcessAfterInitialization
7. Bean就绪，可被使用
8. 销毁阶段（@PreDestroy → DisposableBean → destroy-method）

示例代码

下面是一个完整的示例，展示了Bean生命周期各个扩展点的使用：

public class LifecycleDemo implements BeanNameAware, InitializingBean, DisposableBean {
    public LifecycleDemo() {
        System.out.println("1. 构造函数");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("2. BeanNameAware");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("3. @PostConstruct");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("4. InitializingBean");
    }

    public void initMethod() {
        System.out.println("5. init-method");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("6. @PreDestroy");
    }

    @Override
    public void destroy() {
        System.out.println("7. DisposableBean");
    }

    public void destroyMethod() {
        System.out.println("8. destroy-method");
    }
}

常见面试问题

1. Bean生命周期的四个主要阶段是什么？
2. Aware接口和BeanPostProcessor的区别是什么？
3. 初始化方法和销毁方法有哪些实现方式？
4. 多个BeanPostProcessor的执行顺序如何确定？

理解Bean生命周期有助于优化资源管理和实现高级扩展功能。通过合理利用各个扩展点，可以实现更灵活、更强大的功能。