前言
Spring IOC 中的Bean生命周期大致分为四个阶段：实例化、属性赋值、初始化、销毁，如下图所示：
其实核心的阶段就是这些了，但是每个核心的阶段里面又有很细致的划分。
基于BeanPostProcessor的生命周期
首先先给出一个更加详细的流程：
如上图所示，第一步就是实例化一个Bean对象。接下来就是属性赋值，为Bean设置相关属性和依赖。然后到了整个初始化模块，其中5、6是真正的初始化环节，第3、4步为在初始化前执行，第7步在初始化后执行，初始化完成后，Bean就可以被使用了。最后，第8步其实也可以算到销毁阶段，但不是真正意义上的销毁，而是先在使用前注册了销毁的相关调用接口，为了后面第9、10步真正销毁Bean时再执行相应的方法。
以一个实际的例子举例：
public class PersonBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean { /** * 身份证号 */ private Integer no; /** * 姓名 */ private String name; public PersonBean() { System.out.println("1.调用构造方法：我出生了！"); } public Integer getNo() { return no; } public void setNo(Integer no) { this.no = no; } 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使用中：工作，只有对社会没有用的人才放假。。"); } }
定义一个MyBeanPostProcessor 实现 BeanPostProcessor 接口。（这个很关键）！！！
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; } }
配置文件，指定 init-method 和 destroy-method 属性
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/bea ns http://www.springframework.org/schema/beans/spring.beans.xsd"> <bean name="myBeanPostProcessor" class="cn.fighter3.spring.life.MyBeanPostProcessor" /> <bean name="personBean" class="cn.fighter3.spring.life.PersonBean" init-method="init" destroy-method="destroyMethod"> <property name="idNo" value= "80669865"/> <property name="name" value="张铁钢" /> </bean> </beans>
测试
public class Main { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); PersonBean personBean = (PersonBean)context.getBean("personBean"); personBean.work(); ((ClassPathXmlApplicationContext) context).destroy(); } }
运行结果
1.调用构造方法：我出生了！ 2.设置属性：我的名字叫张铁钢 3.调用BeanNameAware#setBeanName方法:我要上学了，起了个学名 4.调用BeanFactoryAware#setBeanFactory方法：选好学校了 5.BeanPostProcessor#postProcessBeforeInitialization方法：到学校 报名啦 6.InitializingBean#afterPropertiesSet方法：入学登记 7.自定义init方法：努力上学ing 8.BeanPostProcessor#postProcessAfterInitialization方法：终于毕 业，拿到毕业证啦！ Bean使用中：工作，只有对社会没有用的人才放假。。 9.DisposableBean#destroy方法：平淡的一生落幕了 10.自定义destroy方法:睡了，别想叫醒我
以上就是Bean的生命周期，但是其实并不完整。首先从头来分析：
PersonBean 实现了四个接口，分别是InitializingBean、BeanFactoryAware、BeanFactoryAware、BeanFactoryAware。这些接口中分别只有一个方法，分别是 afterPropertiesSet（）、setBeanName（）、setBeanFactory（）、destroy（）
其实这四个方法重写之后能够和生命周期映射起来，如下图所示：
而抛开 图中所圈的三个以及 BeanPostProcesser前置处理、BeanPostProcesser后置处理外，剩下的其实就是 生命周期的四大阶段了。
PersonBean 实现的四个接口就是基于 四大阶段的一个扩展了。
再回到MyBeanPostProcessor，这个前面说了很关键，其实在图中并结合上面例子的输出也可以看到，实际上与BeanPostProcesser前置处理、BeanPostProcesser后置处理有关，MyBeanPostProcessor 实现了 BeanPostProcessor的两个方法，其实就是初始化的前置和后置了，结合起来其实就构成了完成的生命周期。
基于BeanPostProcessor实现类的生命周期
但是BeanPostProcessor是一个接口，有两个实现类扩展了它，分别是InstantiationAwareBeanPostProcessor、DestructionAwareBeanPostProcessor，如下所示：
当进入查看发现InstantiationAwareBeanPostProcessor额外又实现了三个方法，而DestructionAwareBeanPostProcessor额外又实现了一个方法。
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor { @Nullable default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { return null; } default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { return true; } @Nullable default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { return null; } /** @deprecated */ @Deprecated @Nullable default PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { return pvs; } }
InstantiationAwareBeanPostProcessor 对BeanPostProcessor进行了扩展，新增了三个方法。
postProcessBeforeInstantiation 在实例化bean前调用，可以返回一个替代原始实例化的对象，如果返回非空对象，则会跳过正常的实例化过程。
postProcessAfterInstantiation在实例化 bean 后调用，可以对实例进行进一步的处理，常用于额外的初始化或修改实例属性等操作。
postProcessProperties在完成 bean 实例化和属性填充后调用，可以对属性进行进一步的修改或验证。
public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor { void postProcessBeforeDestruction(Object var1, String var2) throws BeansException; default boolean requiresDestruction(Object bean) { return true; } }
DestructionAwareBeanPostProcessor对BeanPostProcessor进行了扩展，新增了一个方法。
postProcessBeforeDestruction在 bean 销毁前调用此方法，可以在销毁之前做一些清理工作，例如释放资源、断开连接等。
当使用 BeanPostProcessor 的实现类的时候，就是继续包装之前的生命周期：
@Component public class LifeCycleBean implements InitializingBean, BeanFactoryAware, BeanNameAware { private static final Logger log = LoggerFactory.getLogger(LifeCycleBean.class); public LifeCycleBean() { log.debug("构造"); } @Autowired public void autowire(@Value("${JAVA_HOME}") String home) { log.debug("依赖注入: {}", home); } @PreDestroy public void destroy() { log.debug("销毁"); } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { log.debug("调用BeanFactoryAware"); } @Override public void setBeanName(String s) { log.debug("调用BeanNameAware"); } @Override public void afterPropertiesSet() throws Exception { log.debug("Bean 初始化执行的逻辑InitializingBean"); } @PostConstruct public void init() { log.debug("初始化"); } }
@Component public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor { // 两个典型的后置处理器的子接口 private static final Logger log = LoggerFactory.getLogger(MyBeanPostProcessor.class); @Override public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) log.debug("<<<<<< 销毁之前执行, 如 @PreDestroy"); } @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) log.debug("<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean"); return null; } @Override public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) { log.debug("<<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段"); // return false; } return true; } @Override public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) log.debug("<<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource"); return pvs; } @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) log.debug("<<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties"); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (beanName.equals("lifeCycleBean")) log.debug("<<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强"); return bean; } }
此时的运行结果如下所示：
<<<<<< 实例化之前执行, 这里返回的对象会替换掉原本的 bean 构造 <<<<<< 实例化之后执行, 这里如果返回 false 会跳过依赖注入阶段 <<<<<< 依赖注入阶段执行, 如 @Autowired、@Value、@Resource 依赖注入: C:\Program Files\Java\jdk1.8.0_231 调用BeanNameAware 调用BeanFactoryAware <<<<<< 初始化之前执行, 这里返回的对象会替换掉原本的 bean, 如 @PostConstruct、@ConfigurationProperties 初始化 Bean 初始化执行的逻辑InitializingBean <<<<<< 初始化之后执行, 这里返回的对象会替换掉原本的 bean, 如代理增强 <<<<<< 销毁之前执行, 如 @PreDestroy 销毁
但是还是存在一些问题，相信细心的人会发现，在这里 初始化竟然先于 “是否实现InitailizinBean”实现了，这并不符合生命周期的顺序呀，回顾代码其实可以发现，在代码中执行初始化方法实际上是：
@PostConstruct public void init() { log.debug("初始化"); }
通过阅读，发现原理是这样的：
对于Spring的Bean生命周期，@PostConstruct注解和InitializingBean接口的afterPropertiesSet()方法都用于在Bean初始化完成后执行一些逻辑，可以看作是等效的。它们的执行顺序并不是由注解或接口本身决定的，而是由Spring容器的实现决定的。
当一个Bean被创建并完成属性注入后，Spring容器会调用@PostConstruct注解标记的方法或InitializingBean接口的afterPropertiesSet()方法来执行初始化逻辑。然而，具体的执行顺序是由Spring容器决定的，这取决于容器的实现和配置。
通常情况下，如果一个Bean同时使用了@PostConstruct注解和实现了InitializingBean接口，那么@PostConstruct注解标记的方法会先于afterPropertiesSet()方法执行。这是因为Spring容器会首先检查Bean是否使用了@PostConstruct注解，并在属性注入完成后立即执行该方法。然后，容器会检查Bean是否实现了InitializingBean接口，并在同一个初始化阶段调用afterPropertiesSet()方法。
需要注意的是，由于执行顺序是由Spring容器决定的，所以不能依赖于具体的执行顺序来编写代码逻辑。如果需要确保执行顺序，建议将相关逻辑放在一个方法中，并使用一个统一的方式（例如@PostConstruct注解）来标记该方法。
至此，一个更加完整的 并且结合 BeanPostProcessor实现类的生命周期主题就已经实现完成了！！！
