去字节面试，直接让人出门左拐：Bean 生命周期都不知道！

2023-02-28

方法对象 bean

大家好，我是楼仔！SpringBean的生命周期，面试时非常容易问，这不，前段时间就有个粉丝去字节面试，因为不会回答这个问题，一面都没有过。如果只讲基础知识，感觉和网上大多数文章没有区别，但是我又想写得稍微深入一点。考虑很多同学不喜欢看源码，我就把文章分为2大部分，前面是基础知识，主要方便大家面试和

大家好，我是楼仔！

Spring Bean 的生命周期，面试时非常容易问，这不，前段时间就有个粉丝去字节面试，因为不会回答这个问题，一面都没有过。

如果只讲基础知识，感觉和网上大多数文章没有区别，但是我又想写得稍微深入一点。

考虑很多同学不喜欢看源码，我就把文章分为 2 大部分，前面是基础知识，主要方便大家面试和学习，后面是源码部分，对源码感兴趣的同学可以继续往后面看。

1. 基础知识

1.1 什么是 IoC ？

IoC，控制反转，想必大家都知道，所谓的控制反转，就是把 new 对象的权利交给容器，所有的对象都被容器控制，这就叫所谓的控制反转。

IoC 很好地体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”，即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

理解好 IoC 的关键是要明确 “谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”。

谁控制谁，控制什么？

传统 Java SE 程序设计，我们直接在对象内部通过 new 进行创建对象，是程序主动去创建依赖对象。而 IoC 是由专门一个容器来创建这些对象，即由 IoC 容器来控制对象的创建。

谁控制谁？当然是 IoC 容器控制了对象；
控制什么？主要控制了外部资源获取（不只是对象，比如包括文件等）。

为何是反转，哪些方面反转了？

有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转，而反转则是由容器来帮忙创建及注入依赖对象。

为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；
哪些方面反转了？依赖对象的获取被反转了。

1.2 Bean 生命周期

对 Prototype Bean 来说，当用户 getBean 获得 Prototype Bean 的实例后，IOC 容器就不再对当前实例进行管理，而是把管理权交由用户，此后再 getBean 生成的是新的实例。

所以我们描述 Bean 的生命周期，都是指的 Singleton Bean。

Bean 生命周期过程：

实例化：第 1 步，实例化一个 Bean 对象；
属性赋值：第 2 步，为 Bean 设置相关属性和依赖；
初始化：初始化的阶段的步骤比较多，5、6 步是真正的初始化，第 3、4 步为在初始化前执行，第 7 步在初始化后执行，初始化完成之后，Bean 就可以被使用了；
销毁：第 8~10 步，第 8 步其实也可以算到销毁阶段，但不是真正意义上的销毁，而是先在使用前注册了销毁的相关调用接口，为了后面第 9、10 步真正销毁 Bean 时再执行相应的方法。

整个执行流程稍微有些抽象，下面我们通过代码，来演示执行流程。

1.3 执行流程

创建一个 LouzaiBean。

public class LouzaiBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {

    /**
     * 姓名
     */
    private String name;

    public LouzaiBean() {
        System.out.println("1.调用构造方法：我出生了！");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.设置属性：我的名字叫"+name);
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.调用BeanFactoryAware#setBeanFactory方法：选好学校了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6.InitializingBean#afterPropertiesSet方法：入学登记");
    }

    public void init() {
        System.out.println("7.自定义init方法：努力上学ing");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("9.DisposableBean#destroy方法：平淡的一生落幕了");
    }

    public void destroyMethod() {
        System.out.println("10.自定义destroy方法:睡了，别想叫醒我");
    }

    public void work(){
        System.out.println("Bean使用中：工作，只有对社会没有用的人才放假。。");
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

自定义一个后处理器 MyBeanPostProcessor。

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：到学校报名啦");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕业，拿到毕业证啦！");
        return bean;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

applicationContext.xml 配置文件（部分）。

<bean name="myBeanPostProcessor" class="demo.MyBeanPostProcessor" />
<bean name="louzaiBean" class="demo.LouzaiBean"
      init-method="init" destroy-method="destroyMethod">
    <property name="name" value="楼仔" />
</bean>1.
2.
3.
4.
5.

测试入口：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context =new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        LouzaiBean louzaiBean = (LouzaiBean) context.getBean("louzaiBean");
        louzaiBean.work();
        ((ClassPathXmlApplicationContext) context).destroy();
    }
}1.
2.
3.
4.
5.
6.
7.
8.

执行结果：

调用构造方法：我出生了！
设置属性：我的名字叫楼仔
调用BeanNameAware#setBeanName方法:我要上学了，起了个学名
调用BeanFactoryAware#setBeanFactory方法：选好学校了
BeanPostProcessor.postProcessBeforeInitialization方法：到学校报名啦
InitializingBean#afterPropertiesSet方法：入学登记
自定义init方法：努力上学ing
BeanPostProcessor#postProcessAfterInitialization方法：终于毕业，拿到毕业证啦！
Bean使用中：工作，只有对社会没有用的人才放假。。
DisposableBean#destroy方法：平淡的一生落幕了
自定义destroy方法:睡了，别想叫醒我1.











这个流程非常清晰，Bean 生命周期流程图能完全对应起来。

1.4 扩展方法

我们发现，整个生命周期有很多扩展过程，大致可以分为 4 类：

Aware 接口：让 Bean 能拿到容器的一些资源，例如 BeanNameAware 的setBeanName()，BeanFactoryAware 的setBeanFactory()；
后处理器：进行一些前置和后置的处理，例如 BeanPostProcessor 的postProcessBeforeInitialization()和postProcessAfterInitialization()；
生命周期接口：定义初始化方法和销毁方法的，例如 InitializingBean 的afterPropertiesSet()，以及 DisposableBean 的destroy()；
配置生命周期方法：可以通过配置文件，自定义初始化和销毁方法，例如配置文件配置的init()和destroyMethod()。