面试突击80：说一下 Spring 中 Bean 的生命周期？

Java 中的公共类称之为 Bean 或 Java Bean，而 Spring 中的 Bean 指的是将对象的生命周期，交个 Spring IoC 容器来管理的对象。所以 Spring 中的 Bean 对象在使用时，无需通过 new 来创建对象，只需要通过 DI（依赖注入），从 Spring 中取出要使用的对象即可。
那么 Spring 中，Bean 的生命周期又有哪些呢？接下来，我们一起来看。

1.Bean 生命周期

Spring 中 Bean 的生命周期是指：Bean 在 Spring（IoC）中从创建到销毁的整个过程。
Spring 中 Bean 的生命周期主要包含以下 5 部分：

1. 实例化：为 Bean 分配内存空间；
2. 设置属性：将当前类依赖的 Bean 属性，进行注入和装配；
3. 初始化：
   1. 执行各种通知；
   2. 执行初始化的前置方法；
   3. 执行初始化方法；
   4. 执行初始化的后置方法。
4. 使用 Bean：在程序中使用 Bean 对象；
5. 销毁 Bean：将 Bean 对象进行销毁操作。

以上生命周期中，需要注意的是：“实例化”和“初始化”是两个完全不同的过程，千万不要搞混，实例化只是给 Bean 分配了内存空间，而初始化则是将程序的执行权，从系统级别转换到用户级别，并开始执行用户添加的业务代码。

2.代码演示

接下来我们使用代码的方式在 Spring Boot 中，给大家演示一下 Bean 的生命周期。

PS：因为 Spring Boot 是基于 Spring 创建的，所以 Bean 在 Spring 或 Spring Boot 中的行为都是一致的，而 Spring Boot 又是目前主流的框架，所以本文使用 Spring Boot 来演示 Bean 的生命周期。

首先，我们创建一个 Bean 对象，起名为 BeanLifeComponent（类命无所谓，可随意指定），它的具体实现代码如下：

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanLifeComponent implements BeanNameAware {
    public void setBeanName(String s) {
        System.out.println("执行 BeanName 的通知方法");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("执行初始化方法");
    }

    public void use() {
        System.out.println("使用 Bean");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("执行销毁方法");
    }
}

然后，我们再创建一个 MyBeanPostProcessor 类（类命无所谓，可随意指定），来实现初始化的前置方法和初始化的后置方法，具体实现代码如下：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanLifeComponent")) {
            System.out.println("执行初始化前置方法");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("beanLifeComponent")) {
            System.out.println("执行初始化后置方法");
        }
        return bean;
    }
}

为什么要创建一个单独的类来执行初始化的前置方法和初始化的后置方法呢？
这是因为初始化的前置方法和后置方法是为所有 Bean 服务的，而非为某一个 Bean 服务的，所以这两个方法不能写在某个具体的 Bean 中，否则（这两个方法）不会执行。
最后，在 Spring Boot 的启动类中获取 Bean，具体实现代码如下：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        // 得到上下文对象，并启动 Spring Boot 项目
        ConfigurableApplicationContext context = 
            SpringApplication.run(DemoApplication.class, args);
        // 获取 Bean
        BeanLifeComponent component = context.getBean(BeanLifeComponent.class);
        // 使用 Bean
        component.use();
        // 停止 Spring Boot 项目
        context.close();
    }
}

以上程序最终的执行结果如下图所示：

从上面的执行结果可以看出，代码执行顺序符合 Bean 生命周期的执行顺序：

1. 实例化：为 Bean 分配内存空间；
2. 设置属性：将当前类依赖的 Bean 属性，进行注入和装配；
3. 初始化：
   1. 执行各种通知；
   2. 执行初始化的前置方法；
   3. 执行初始化方法；
   4. 执行初始化的后置方法。
4. 使用 Bean：在程序中使用 Bean 对象；
5. 销毁 Bean：将 Bean 对象进行销毁操作。

那么问题来了，能不能先执行初始化再执行设置属性呢？也就是将生命周期中的步骤 2 和步骤 3 的执行顺序交换一下？
答案是否定的。想象一个场景，如果在初始化方法中要用到被注入对象的某个方法，比如以下代码：

@Controller
public class UserController {
    @Resource
    private UserService userService;

    @PostConstruct // 初始化方法
    public void postConstruct() {
        userService.sayHi();
    }
}

此时如果先执行步骤 2，先将 UserService 注入到当前类，再调用步骤 3 执行初始化，那么程序的执行是正常的。然而如果将交互步骤 2 和步骤 3 的执行顺序，那么程序执行就会报错（空指针异常），所以 Bean 的生命周期的顺序必须是：

1.实例化：为 Bean 分配内存空间；
2.设置属性：将当前类依赖的 Bean 属性，进行注入和装配；
3.初始化：

1. 执行各种通知；
2. 执行初始化的前置方法；
3. 执行初始化方法；
4. 执行初始化的后置方法。
   4.使用 Bean：在程序中使用 Bean 对象；
   5.销毁 Bean：将 Bean 对象进行销毁操作。

总结

Bean 的生命周期指的是 Bean 在 Spring（IoC）中从创建到销毁的整个过程。Bean 的生命周期主要包含以下 5 个流程：
1.实例化：为 Bean 分配内存空间；
2.设置属性：将当前类依赖的 Bean 属性，进行注入和装配；
3.初始化：

1. 执行各种通知；
2. 执行初始化的前置方法；
3. 执行初始化方法；
4. 执行初始化的后置方法。
   4.使用 Bean：在程序中使用 Bean 对象；
   5.销毁 Bean：将 Bean 对象进行销毁操作。

是非审之于己，毁誉听之于人，得失安之于数。

公众号：Java面试真题解析

面试合集：https://gitee.com/mydb/interview