目录
- 一、简介
- 二、Bean的流程
- 1.BeanDefinition
- 2.Bean 的生命周期
- 三、代码验证
- 1.User 实体类
- 2.MyBeanPostProcessor 后置处理器
- 3.SpringConfig 扫描包配置
- 4.UserTest 测试类
- 5.测试结果
- 6.模拟AOP增强
- 三、总结
一、简介
首先，为什么要学习 Spring 中 Bean 的生命周期呢？
虽然不了解 Bean 的生命周期，并不影响日常工作中的开发。但是如果我们了解了 Bean 的生命周期，可以帮助我们更好地掌握 Spring 框架，并且能够让我们更好地去理解 Spring 容器是如何管理和创建 Bean 示例的。如果以后遇到 Bean 的相关问题（比如 Spring 的循环依赖问题），就可以方便我们去调试和解决这些问题。同时也让我们可以编写出更健壮、灵活、易维护的应用程序。所以说，理解 Bean 的生命周期对掌握 Spring 框架来说是至关重要的。
这里我们主要分两部分去说明：
- 先从整体上去介绍 Bean 创建的整个流程 -> Bean的流程；
- 然后再用代码的方式去验证流程 -> 代码验证。
二、Bean的流程
1.BeanDefinition
BeanDefinition：Bean 的定义信息。Spring 容器在进行实例化时，会将 xml 配置中 <bean> 的信息（注解也是如此）封装成一个 BeanDefinition 对象，Spring 根据 BeanDefinition 来创建 Bean 对象，里面有很多用来描述 Bean 的属性。
有了 BeanDefinition 之后，再去创建 Bean 对象的时候，就可以通过反射去创建。
<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl" lazy-init="true"/>
<bean id="userService" class="com.demo.service.UserServiceImpl" scope="singleton"><property name="userDao" ref="userDao"></property>
</bean>
beanClassName：bean 的类名。initMethodName：初始化方法名称。propertyValues：bean 的属性值。scope：作用域。lazyInit：延迟初始化。
以上这些属性都被封装到 BeanDefinition 中备用。那具体什么时候用呢？这就是下面要说的 Bean 的生命周期。
2.Bean 的生命周期
目前我们已经有了 BeanDefinition 这个对象了，那第一步就是要去创建对象。
-
第1步，调用 Bean 的构造函数。 来去实例化当前 Bean 的对象。
-
第2步，依赖注入。 像是一些
@Autowired或者@Value标明的属性，这些都是在依赖注入中完成。 -
第3步，Aware接口。 比较常见的有三个，它们都是以 Aware 结尾的接口，如果 Bean 实现了这些接口，就要重写里面的方法：
BeanNameAware：在初始化过程中可以获取到 Bean 的名称。BeanFactoryAware：在初始化过程中可以获取到 Bean 工厂。ApplicationContextAware：在初始化过程中可以获取到应用上下文。以上这些内容都是为了方便对 Bean 进行扩展。
-
第4步，BeanPostProcessor#before。 BeanPostProcessor 是 Bean 的后置处理器，用来增强 Bean 的功能的，在初始化方法调用之前（before）进行回调。这个 BeanPostProcessor 后置处理器在 Bean 的生命中其中占有非常重要的作用，需要重点记忆。
-
第5步，调用初始化方法。 里面有两部分：
InitializingBean：这是一个接口类，如果当前 Bean 实现了这个接口的话，就要重写里面的方法，这一步就是来执行重写之后的方法。自定义init方法：比如在 Bean 中的某一个方法使用了注解@PostConstruct，这里就会去执行标明了注解的方法。其实自定义init方法也是从 BeanDefinition 中读取到的信息。 -
第6步，BeanPostProcessor#after。 还是在 Bean 的后置处理器中执行，但是是在初始化方法之后（after）执行。在 Spring 中对 Bean 进行增强的话，都是用到这个初始化方法之后执行的后置处理器。其实在 Spring 内部就使用到了很多的后置处理器，比较典型的就是：当一个类被曾倩了，使用到了
AOP，那这个类通常都是使用后置处理器（BeanPostProcessor#after）来增强的。我们知道 AOP 的底层使用的是动态代理，有两种：JDK动态代理、CGLIB动态代理。到这一步之后，基本上这个对象就创建完成了，现在就可以从 Spring 容器中去获取和使用这个 Bean 对象了。
注意： 从
依赖注入开始到BeanPostProcessor#after完成之后，都是针对当前的 Bean 进行初始化赋值，当然也做了一些增强。这里需要注意，Spring 中 Bean 的创建是一步一步完成的，也就是说 Bean 的创建和初始化赋值是分开的。调用构造函数就是创建 Bean 对象，但是这里创建好后是一个空对象，里面没有值，下面就是初始化赋值的过程。 -
第6步，销毁Bean。 当 Spring 容器关闭之后，这个 Bean 对象就要执行销毁的操作了。比较典型的是，如果在某个方法上使用了
@PreDestroy这个注解，那这个方法就是一个销毁的方法，Spring 容器关闭的时候就会执行这个销毁的方法。
以上就是 Bean 的生命周期，里面的步骤还是挺多的。为了方便加深印象，我们可以用代码的方式去验证一下。
三、代码验证
1.User 实体类
User.java
继承了 BeanNameAware、BeanFactoryAware、ApplicationContextAware、InitializingBean 接口。
package com.demo.lifecycle;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;import javax.annotation.PreDestroy;@Component
public class User implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {public User() {System.out.println("User类的构造方法被调用了...");}/*** 姓名*/private String name;@Value("张三")public void setName(String name) {System.out.println("setName方法被调用了...");this.name = name;}@Overridepublic void setBeanName(String name) {System.out.println("BeanNameAware接口的setBeanName方法被调用了，bean的名字是：" + name);}@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("BeanFactoryAware接口的setBeanFactory方法被调用了...");}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println("ApplicationContextAware接口的setApplicationContext方法被调用了...");}@Overridepublic void afterPropertiesSet() {System.out.println("InitializingBean接口的afterPropertiesSet方法被调用了...");}@PreDestroypublic void destroy() {System.out.println("PreDestroy注解的destroy方法被调用了...");}
}
2.MyBeanPostProcessor 后置处理器
MyBeanPostProcessor.java
定义了 #before 和 #after 方法的增强实现。
package com.demo.lifecycle;import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.stereotype.Component;import java.lang.reflect.Method;
import java.util.Objects;@Component
public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {System.out.println("BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....");return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) {if (Objects.equals(beanName, "user")) {System.out.println("BeanPostProcessor接口的postProcessAfterInitialization方法被调用了 -> user对象初始化方法后开始增强....");// cglib代理对象/*Enhancer enhancer = new Enhancer();// 设置需要增强的类enhancer.setSuperclass(bean.getClass());// 执行回调方法，增强方法enhancer.setCallback(new InvocationHandler() {@Overridepublic Object invoke(Object o, Method method, Object[] objects) throws Throwable {// 执行目标方法return method.invoke(bean, objects);}});// 创建代理对象return enhancer.create();*/}return bean;}
}
3.SpringConfig 扫描包配置
SpringConfig.java
配置了扫描包位置，只扫描 User 实体类和 MyBeanPostProcessor 后置处理器。
package com.demo.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;@Configuration
@ComponentScan("com.demo.lifecycle")
public class SpringConfig {
}
4.UserTest 测试类
UserTest.java
main 方法执行，使用 SpringConfig 配置创建上下文，并从容器中获取 user 的 Bean 对象。
package com.demo.test;import com.demo.config.SpringConfig;
import com.demo.lifecycle.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class UserTest {public static void main(String[] args) {ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);User user = ctx.getBean(User.class);System.out.println(user);}
}
5.测试结果
由于我使用的是 SpringBoot 项目进行的测试，会多打印一些日志，其中不带时间前缀的是我们手动 println 的日志。
Connected to the target VM, address: '127.0.0.1:61642', transport: 'socket'
20:03:56.949 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@9660f4e
20:03:56.985 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalConfigurationAnnotationProcessor'
20:03:57.100 [main] DEBUG org.springframework.context.annotation.ClassPathBeanDefinitionScanner - Identified candidate component class: file [D:\IdeaProjects\SpringBootExamples\springboot-demo\target\classes\com\demo\lifecycle\MyBeanPostProcessor.class]
20:03:57.105 [main] DEBUG org.springframework.context.annotation.ClassPathBeanDefinitionScanner - Identified candidate component class: file [D:\IdeaProjects\SpringBootExamples\springboot-demo\target\classes\com\demo\lifecycle\User.class]
20:03:57.266 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerProcessor'
20:03:57.270 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerFactory'
20:03:57.272 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalAutowiredAnnotationProcessor'
20:03:57.275 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
20:03:57.281 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'myBeanPostProcessor'
20:03:57.304 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'springConfig'
BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....
20:03:57.305 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'user'
User类的构造方法被调用了...
setName方法被调用了...
BeanNameAware接口的setBeanName方法被调用了，bean的名字是：user
BeanFactoryAware接口的setBeanFactory方法被调用了...
ApplicationContextAware接口的setApplicationContext方法被调用了...
BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....
InitializingBean接口的afterPropertiesSet方法被调用了...
BeanPostProcessor接口的postProcessAfterInitialization方法被调用了 -> user对象初始化方法后开始增强....
User类的构造方法被调用了...
com.demo.lifecycle.User@2235eaab
Disconnected from the target VM, address: '127.0.0.1:61642', transport: 'socket'Process finished with exit code 0
可以看到日志是按照我们梳理的 Bean 的生命周期顺序打印的，验证完毕。
6.模拟AOP增强
MyBeanPostProcessor.java 的 postProcessAfterInitialization() 方法中注释了 AOP 底层 CGLIB 动态代理的演示代码的，可以在 UserTest 的 main 方法中获取到 user 的 Bean 对象后，将鼠标放到 user 上看下，打开和关闭 CGLIB 代理的注释生成的 user Bean 会不同：
关闭 CGLIB 代理：
打开 CGLIB 代理：
三、总结
问： Spring 中 Bean 的生命周期是什么样的？
答：
① 通过 BeanDefinition 获取 Bean 的定义信息；
② 调用构造函数实例化 Bean；
③ Bean 的依赖注入；
④ 处理 Aware 接口（BeanNameAware、BeanFactoryAware、ApplicationContextAware）；
⑤ Bean 的后置处理器 BeanPostProcessor-前置；
⑥ 初始化方法（InitializingBean、init-method）；
⑦ Bean 的后置处理器 BeanPostProcessor-后置；
⑧ 销毁 Bean。
整理完毕，完结撒花~ 🌻
参考地址：
1.框架篇-05-Spring-bean的生命周期，https://www.bilibili.com/video/BV1yT411H7YK/?p=39&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=cf16f2e5f7c4612add10f9f9268a2c8a
