继续 Spring 复盘，今天看了下 Spring 的 Bean 生命周期。
1、典型的 Spring 生命周期
在传统的 Java 应用中，bean 的生命周期很简单，使用 Java 关键字 new 进行 Bean 的实例化，然后该 Bean 就能够使用了。一旦 bean 不再被使用，则由 Java 自动进行垃圾回收，简直不要太简单。
相比之下，Spring 管理 Bean 的生命周期就复杂多了，正确理解 Bean 的生命周期非常重要，因为 Spring 对 Bean 的管理可扩展性非常强，下面展示了一个 Bea 的构造过程。
以上图片出自《Spring 实战（第四版）》一书，图片描述了一个经典的 Spring Bean 的生命周期，书中随他的解释如下：
1．Spring 对 bean 进行实例化；
2．Spring 将值和 bean 的引用注入到 bean 对应的属性中；
3．如果 bean 实现了 BeanNameAware 接口，Spring 将 bean 的 ID 传递给
setBean-Name() 方法；
4．如果 bean 实现了 BeanFactoryAware 接口，Spring 将调
用 setBeanFactory()方法，将 BeanFactory 容器实例传入；
5．如果 bean 实现了 ApplicationContextAware 接口，Spring 将调
用 setApplicationContext()方法，将 bean 所在的应用上下文的
引用传入进来；
6．如果 bean 实现了 BeanPostProcessor 接口，Spring 将调用它们
的 post-ProcessBeforeInitialization()方法；
7．如果 bean 实现了 InitializingBean 接口，Spring 将调用它们的
after-PropertiesSet() 方法。类似地，如果 bean 使用 init-
method 声明了初始化方法，该方法也会被调用；
8．如果 bean 实现了 BeanPostProcessor 接口，Spring 将调用它们
的 post-ProcessAfterInitialization()方法；
9．此时，bean 已经准备就绪，可以被应用程序使用了，它们将一直
驻留在应用上下文中，直到该应用上下文被销毁；
10．如果 bean 实现了 DisposableBean 接口，Spring 将调用它的
destroy() 接口方法。同样，如果 bean 使用 destroy-method 声明
了销毁方法，该方法也会被调用。
2、验证 Spring Bean 周期
写了下代码验证以上说法，首先创建一个 Person 类，它就是我们要验证的 Bean，为方便测试，他实现了 BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean。代码如下：
package com.nasus.bean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Scope;
/**
* Project Name:review_spring <br/>
* Package Name:PACKAGE_NAME <br/>
* Date:2019/9/1 16:29 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
@Scope("ProtoType")
public class Person implements BeanNameAware, BeanFactoryAware,
ApplicationContextAware, InitializingBean, DisposableBean {private static final Logger LOGGER = LoggerFactory.getLogger(Person.class);
private String name;
public Person(){System.out.println("1、开始实例化 person");
}
public String getName() {return name;}
public void setName(String name) {
this.name = name;
System.out.println("2、设置 name 属性");
}
@Override
public void setBeanName(String beanId) {
System.out.println("3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的"
+ "ID=" + beanId + "传递给 setBeanName 方法");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("4、Person 实现了 BeanFactoryAware 接口，Spring 调"
+ "用 setBeanFactory()方法，将 BeanFactory 容器实例传入");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("5、Person 实现了 ApplicationContextAware 接口，Spring 调"
+ "用 setApplicationContext()方法，将 person 所在的应用上下文的"
+ "引用传入进来");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("8、Person 实现了 InitializingBean 接口，Spring 调用它的"
+ "afterPropertiesSet()方法。类似地，如果 person 使用 init-"
+ "method 声明了初始化方法，该方法也会被调用");
}
@Override
public void destroy() throws Exception {
System.out.println("13、Person 实现了 DisposableBean 接口，Spring 调用它的"
+ "destroy() 接口方法。同样，如果 person 使用 destroy-method 声明"
+ "了销毁方法，该方法也会被调用");
}
/**
* xml 中声明的 init-method 方法
*/
public void initMethod(){System.out.println("9、xml 中声明的 init-method 方法");
}
/**
* xml 中声明的 destroy-method 方法
*/
public void destroyMethod(){System.out.println("14、xml 中声明的 destroy-method 方法");
System.out.println("end---------------destroy-----------------");
}
// 自定义初始化方法
@PostConstruct
public void springPostConstruct(){System.out.println("7、@PostConstruct 调用自定义的初始化方法");
}
// 自定义销毁方法
@PreDestroy
public void springPreDestory(){System.out.println("12、@PreDestory 调用自定义销毁方法");
}
@Override
protected void finalize() throws Throwable {System.out.println("finalize 方法");
}
}除此之外，创建了一个 MyBeanPostProcessor 类继承自 BeanPostProcessor 这个类只关心 Person 初始化前后要做的事情。比如，初始化之前，加载其他 Bean。代码如下：
package com.nasus.lifecycle;
import com.nasus.bean.Person;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* Project Name:review_spring <br/>
* Package Name:PACKAGE_NAME <br/>
* Date:2019/9/1 16:25 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class MyBeanPostProcessor implements BeanPostProcessor {
// 容器加载的时候会加载一些其他的 bean，会调用初始化前和初始化后方法
// 这次只关注 Person 的生命周期
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if(bean instanceof Person){System.out.println("6、初始化 Person 之前执行的方法");
}
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if(bean instanceof Person){System.out.println("10、初始化 Person 完成之后执行的方法");
}
return bean;
}
}resource 文件夹下新建一个 bean_lifecycle.xml 文件注入相关 bean，代码如下：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 扫描 bean -->
<context:component-scan base-package="com.nasus"/>
<!-- 实现了用户自定义初始化和销毁方法 -->
<bean id="person" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
<!-- 注入 bean 属性名称 -->
<property name="name" value="nasus" />
</bean>
<!-- 引入自定义的 BeanPostProcessor-->
<bean class="com.nasus.lifecycle.MyBeanPostProcessor"/>
</beans>测试类，获取 person 这个 Bean 并使用它，代码如下：
import com.nasus.bean.Person;
import java.awt.print.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* Project Name:review_spring <br/>
* Package Name:PACKAGE_NAME <br/>
* Date:2019/9/1 16:38 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class lifeCycleTest {
@Test
public void testLifeCycle(){
// 为面试而准备的 Bean 生命周期加载过程
ApplicationContext context = new ClassPathXmlApplicationContext("bean_lifecycle.xml");
Person person = (Person)context.getBean("person");
// 使用属性
System.out.println("11、实例化完成使用属性：Person name =" + person.getName());
// 关闭容器
((ClassPathXmlApplicationContext) context).close();}
}lifeCycleTest 方法最后关闭了容器，关闭的同时控制台日志输出如下：
1、开始实例化 person
2、设置 name 属性
3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 ID=person 传递给 setBeanName 方法
4、Person 实现了 BeanFactoryAware 接口，Spring 调用 setBeanFactory()方法，将 BeanFactory 容器实例传入
5、Person 实现了 ApplicationContextAware 接口，Spring 调用 setApplicationContext()方法，将 person 所在的应用上下文的引用传入进来
6、初始化 Person 之前执行的方法
7、@PostConstruct 调用自定义的初始化方法
8、Person 实现了 InitializingBean 接口，Spring 调用它的 afterPropertiesSet()方法。类似地，如果 person 使用 init-method 声明了初始化方法，该方法也会被调用
9、xml 中声明的 init-method 方法
10、初始化 Person 完成之后执行的方法
11、实例化完成使用属性：Person name = nasus
12、@PreDestory 调用自定义销毁方法
13、Person 实现了 DisposableBean 接口，Spring 调用它的 destroy() 接口方法。同样，如果 person 使用 destroy-method 声明了销毁方法，该方法也会被调用
14、xml 中声明的 destroy-method 方法
end---------------destroy-----------------由以上日志可知，当 person 默认是单例模式时，bean 的生命周期与容器的生命周期一样，容器初始化，bean 也初始化。容器销毁，bean 也被销毁。那如果，bean 是非单例呢？
3、在 Bean 实例化完成后，销毁前搞事情
有时我们需要在 Bean 属性值 set 好之后和 Bean 销毁之前做一些事情，比如检查 Bean 中某个属性是否被正常的设置好值了。Spring 框架提供了多种方法让我们可以在 Spring Bean 的生命周期中执行 initialization 和 pre-destroy 方法。这些方法我在上面已经测试过了，以上代码实现了多种方法，它是重复，开发中选以下其一即可，比如：
- 在配置文件中指定的 init-method 和 destroy-method 方法
- 实现 InitializingBean 和 DisposableBean 接口
- 使用 @PostConstruct 和 @PreDestroy 注解（墙裂推荐使用）
4、多实例模式下的 Bean 生命周期
上面测试中的 person 默认是 singleton 的，现在我们将 person 改为 protoType 模式，bean_lifecycle.xml 做如下代码修改，其余类保持不变：
<!-- 实现了用户自定义初始化和销毁方法 -->
<bean id="person" scope="prototype" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
<!-- 注入 bean 属性名称 -->
<property name="name" value="nasus" />
</bean>此时的日志输出如下：
1、开始实例化 person
2、设置 name 属性
3、Person 实现了 BeanNameAware 接口，Spring 将 Person 的 ID=person 传递给 setBeanName 方法
4、Person 实现了 BeanFactoryAware 接口，Spring 调用 setBeanFactory()方法，将 BeanFactory 容器实例传入
5、Person 实现了 ApplicationContextAware 接口，Spring 调用 setApplicationContext()方法，将 person 所在的应用上下文的引用传入进来
6、初始化 Person 之前执行的方法
7、@PostConstruct 调用自定义的初始化方法
8、Person 实现了 InitializingBean 接口，Spring 调用它的 afterPropertiesSet()方法。类似地，如果 person 使用 init-method 声明了初始化方法，该方法也会被调用
9、xml 中声明的 init-method 方法
10、初始化 Person 完成之后执行的方法
11、实例化完成使用属性：Person name = nasus此时，容器关闭，person 对象并没有销毁。原因在于，单实例模式下，bean 的生命周期由容器管理，容器生，bean 生；容器死，bean 死。而在多实例模式下，Spring 就管不了那么多了，bean 的生命周期，交由客户端也就是程序员或者 JVM 来进行管理。
5、多实例模式下 Bean 的加载时机
首先说说单实例，单实例模式下，bean 在容器加载那一刻起，就已经完成实例化了，证明如下，我启用 debug 模式，在 20 行打了一个断点，而日志却如下所示，说明了 bean 在 19 行，初始化容器的时候，已经完成实例化了。
再说多实例模式下，这个模式下，bean 在需要用到 bean 的时候才进行初始化，证明如下，同样执行完 19 行，多实例模式下，控制台一片空白，说明此时的 bean 是未被加载的。
debug 走到 23 行时，需要用到 bean 时，bean 才被加载了，验证如下。在开发中，我们把这种加载叫做懒加载，它的用处就是减轻程序开销，等到要用时才加载，而不是一上来就加载全部。
6、单实例 bean 如何实现延迟加载
只需在 xml 中加上 lazy-init 属性为 true 即可。如下，它的加载方式就变成了懒加载。
<!-- 实现了用户自定义初始化和销毁方法 -->
<bean id="person" lazy-init="true" class="com.nasus.bean.Person" init-method="initMethod" destroy-method="destroyMethod">
<!-- 注入 bean 属性名称 -->
<property name="name" value="nasus" />
</bean>如果想对所有的默认单例 bean 都应用延迟初始化，可以在根节点 beans 设置 default-lazy-init 属性为 true，如下所示：
<beans default-lazy-init="true" …>7、源码地址
https://github.com/turoDog/review_spring
推荐阅读：
1、java | 什么是动态代理
2、Spring 复盘(1) | IOC
3、Spring 复盘(2) | AOP
4、SpringBoot | 启动原理
5、SpringBoot | 自动配置原理
6、Spring MVC 复盘 | 工作原理及配置详解