Java面试题--SpringBean的生命周期

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. 初始化：
   • 执行各种通知；
   • 执行初始化的前置方法；
   • 执行初始化方法；
   • 执行初始化的后置方法。
4. 使用 Bean：在程序中使用 Bean 对象；
5. 销毁 Bean：将 Bean 对象进行销毁操作。

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

2.代码演示

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

/**
 * @description: Bean生命周期
 * @Title: BeanLifeComponent
 * @Package com.vector.sourcecode.entity
 * @Author 芝士汉堡
 * @Date 2023/2/21 8:37
 */
@Component
public class BeanLifeComponent implements BeanNameAware{

    @Override
    public void setBeanName(String name) {
        System.out.println("BeanNameAware.setBeanName()方法被调用--执行BeanName 的通知方法");
    }

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

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

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

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

/**
 * @description: 实现初始化前后置方法
 * @Title: MyBeanPostProcessor
 * @Package com.vector.sourcecode.entity
 * @Author 芝士汉堡
 * @Date 2023/2/21 8:43
 */
@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，具体实现代码如下：

@SpringBootApplication
public class SpringBootSourceCodeApplication {

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

执行结果：

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

1. 实例化：为 Bean 分配内存空间；
2. 设置属性：将当前类依赖的 Bean 属性，进行注入和装配；
3. 初始化：
   • 执行各种通知；
   • 执行初始化的前置方法；
   • 执行初始化方法；
   • 执行初始化的后置方法。
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.初始化：

• 执行各种通知；
• 执行初始化的前置方法；
• 执行初始化方法；
• 执行初始化的后置方法。

4.使用 Bean：在程序中使用 Bean 对象；
5.销毁 Bean：将 Bean 对象进行销毁操作。

3.总结

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

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