1. 什么是Bean的生命周期 49
Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。
所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。
什么时候创建Bean对象？
创建Bean对象的前后会调用什么方法？
Bean对象什么时候销毁？
Bean对象的销毁前后调用什么方法？
2. 为什么要知道Bean的生命周期 49
其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。
我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。
只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。
我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。
3. Bean的生命周期之5步 49
Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。
Bean生命周期可以粗略的划分为五大步：
● 第一步：实例化Bean
● 第二步：Bean属性赋值
● 第三步：初始化Bean
● 第四步：使用Bean
● 第五步：销毁Bean
3.1 编写测试程序： 49
定义一个Bean
package com.powernode.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
/**
*
* Bean的生命周期按照粗略的五步的话： 49
* 第一步：实例化Bean（调用无参数构造方法。）
* 第二步：给Bean属性赋值（调用set方法。）
* 第三步：初始化Bean（会调用Bean的init方法。注意：这个init方法需要自己写，自己配。）
* 第四步：使用Bean
* 第五步：销毁Bean（会调用Bean的destroy方法。注意：这个destroy方法需要自己写，自己配。）
**/
public class User{
private String name;
public void setName(String name) {
System.out.println("第二步：给对象的属性赋值。");
this.name = name;
}
public User() {
System.out.println("第一步：无参数构造方法执行。");
}
// 这个方法需要自己写，自己配。方法名随意。
public void initBean(){
System.out.println("第三步：初始化Bean。");
}
// 这个方法需要自己写，自己配。方法名随意。
public void destroyBean(){
System.out.println("第五步：销毁Bean。");
}
// @Override
// public void setBeanClassLoader(ClassLoader classLoader) {
// System.out.println("Bean这个类的加载器：" + classLoader);
// }
//
// @Override
// public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
// System.out.println("生产这个Bean的工厂对象是：" + beanFactory);
// }
//
// @Override
// public void setBeanName(String name) {
// System.out.println("这个Bean的名字是：" + name);
// }
//
// @Override
// public void afterPropertiesSet() throws Exception {
// System.out.println("InitializingBean's afterPropertiesSet执行。");
// }
//
// @Override
// public void destroy() throws Exception {
// System.out.println("DisposableBean's destroy方法执行");
// }
}<!-- 研究bean的生命周期 49-->
<!--需要手动指定初始化方法，和销毁方法。-->
<bean id="user" class="com.powernode.spring6.bean.User"
init-method="initBean" destroy-method="destroyBean">
<property name="name" value="zhangsan"/>
</bean>
//测试bean的生命周期 49
@Test
public void testBeanLifecycleTest(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User user = applicationContext.getBean("user", User.class);
System.out.println("第四步:使用bean:"+user);
// 注意：必须手动关闭Spring容器，这样Spring容器才会销毁Bean.
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close();
}
3.2 需要注意的： 49
● 第一：只有正常关闭spring容器，bean的销毁方法才会被调用。
● 第二：ClassPathXmlApplicationContext类才有close()方法。
● 第三：配置文件中的init-method指定初始化方法。destroy-method指定销毁方法。
3.2.1 再次强调
Bean的生命周期五步：
第一步：实例化Bean
第二步：Bean属性赋值
第三步：初始化Bean
第四步：使用Bean
第五步：销毁Bean
4. Bean生命周期之7步 50
4.1 Bean生命周期七步：比五步添加的那两步在哪里？
在初始化Bean的前和后。
第一步：实例化Bean
第二步：Bean属性赋值
第三步：执行“Bean后处理器”的before方法。
第四步：初始化Bean
第五步：执行“Bean后处理器”的after方法。
第六步：使用Bean
第七步：销毁Bean
在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。
编写一个类实现BeanPostProcessor类，并且重写before和after方法：
package com.powernode.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* 日志Bean后处理器。 50
**/
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("执行Bean后处理器的before方法。");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
// 方法有两个参数：
// 第一个参数：刚创建的bean对象。
// 第二个参数：bean的名字。
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("执行Bean后处理器的after方法。");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}在spring.xml文件中配置“Bean后处理器”：
<!--配置Bean后处理器。 50-->
<!--注意：这个Bean后处理器将作用于整个配置文件中所有的bean。-->
<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>
4.2 注意 50
一定要注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean。
如果加上Bean后处理器的话，Bean的生命周期就是7步了：
5. Bean生命周期之10步 51
5.1 Bean生命周期十步：比七步添加的那三步在哪里？ 51
5.1.1 点位1：
在“Bean后处理器”before方法之前
干了什么事儿？
检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法。
然后调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。
5.1.2 点位2：
在“Bean后处理器”before方法之后
干了什么事儿？
检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法。
5.1.3 点位3：
使用Bean之后，或者说销毁Bean之前
干了什么事儿？
检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法。
5.1.4 添加的这三个点位的特点：
都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法。
如果根据源码跟踪，可以划分更细粒度的步骤，10步：
5.2 上图中检查Bean是否实现了Aware的相关接口是什么意思？ 51
Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
● 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。
● 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。
● 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。
5.3 测试以上10步，可以让User类实现5个接口，并实现所有方法：51
● BeanNameAware
● BeanClassLoaderAware
● BeanFactoryAware
● InitializingBean
● DisposableBean
package com.powernode.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
/**
*
* Bean的生命周期按照粗略的五步的话： 49
* 第一步：实例化Bean（调用无参数构造方法。）
* 第二步：给Bean属性赋值（调用set方法。）
* 第三步：初始化Bean（会调用Bean的init方法。注意：这个init方法需要自己写，自己配。）
* 第四步：使用Bean
* 第五步：销毁Bean（会调用Bean的destroy方法。注意：这个destroy方法需要自己写，自己配。）
**/
public class User implements
BeanNameAware, BeanClassLoaderAware,BeanFactoryAware,InitializingBean,DisposableBean{
private String name;
public void setName(String name) {
System.out.println("第二步：给对象的属性赋值。");
this.name = name;
}
public User() {
System.out.println("第一步：无参数构造方法执行。");
}
// 这个方法需要自己写，自己配。方法名随意。
public void initBean(){
System.out.println("第四步：初始化Bean。");
}
// 这个方法需要自己写，自己配。方法名随意。
public void destroyBean(){
System.out.println("第七步：销毁Bean。");
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("Bean这个类的加载器：" + classLoader);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("生产这个Bean的工厂对象是：" + beanFactory);
}
@Override
public void setBeanName(String name) {
System.out.println("这个Bean的名字是：" + name);
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean's afterPropertiesSet执行。");
}
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean's destroy方法执行");
}
}package com.powernode.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* 日志Bean后处理器。 50
**/
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第三步：执行Bean后处理器的before方法。");
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}
// 方法有两个参数：
// 第一个参数：刚创建的bean对象。
// 第二个参数：bean的名字。
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("第五步：执行Bean后处理器的after方法。");
return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}
}<?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/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置Bean后处理器。 50-->
<!--注意：这个Bean后处理器将作用于整个配置文件中所有的bean。-->
<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>
<!-- 研究bean的生命周期 49-->
<!--需要手动指定初始化方法，和销毁方法。-->
<bean id="user" class="com.powernode.spring6.bean.User"
init-method="initBean" destroy-method="destroyBean">
<property name="name" value="zhangsan"/>
</bean>
<!-- <bean id="vip" class="com.powernode.spring6.bean.Vip"/>-->
</beans>
package com.powernode.spring6.test;
import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanLifecycleTest {
//测试bean的生命周期 49-50
@Test
public void testBeanLifecycleTest(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User user = applicationContext.getBean("user", User.class);
System.out.println("第六步:使用bean:"+user);
// 注意：必须手动关闭Spring容器，这样Spring容器才会销毁Bean.
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close();
}
}
通过测试可以看出来：
● InitializingBean的方法早于init-method的执行。
● DisposableBean的方法早于destroy-method的执行。
对于SpringBean的生命周期，掌握之前的7步即可。够用。
6. Bean的作用域不同，管理方式不同 52
Spring 根据Bean的作用域来选择管理方式。
● 对于singleton作用域的Bean，Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；
● 而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。
我们把之前User类的spring.xml文件中的配置scope设置为prototype：
<!--配置Bean后处理器。 50-->
<!--注意：这个Bean后处理器将作用于整个配置文件中所有的bean。-->
<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>
<!-- 研究bean的生命周期 49-->
<!--需要手动指定初始化方法，和销毁方法。-->
<bean id="user" class="com.powernode.spring6.bean.User"
init-method="initBean" destroy-method="destroyBean" scope="prototype">
<property name="name" value="zhangsan"/>
</bean>
/**
* Spring容器只对singleton的Bean进行完整的生命周期管理。
* 如果是prototype作用域的Bean，Spring容器只负责将该Bean初始化完毕。
* 等客户端程序一旦获取到该Bean之后，Spring容器就不再管理该对象的生命周期了。
*/
//测试bean的生命周期 49-50
@Test
public void testBeanLifecycleTest(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User user = applicationContext.getBean("user", User.class);
System.out.println("第六步:使用bean:"+user);
// 注意：必须手动关闭Spring容器，这样Spring容器才会销毁Bean.
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close();
}
通过测试一目了然。只执行了前8步，第9和10都没有执行。
7. 自己new的对象如何让Spring管理 53
有些时候可能会遇到这样的需求，某个java对象是我们自己new的，然后我们希望这个对象被Spring容器管理，怎么实现？
package com.powernode.spring6.bean;
/**
* 自己new的对象如何让Spring管理 53
**/
public class Student {
}//自己new的对象如何让Spring管理 53
@Test
public void testRegisterBean(){
// 自己new的对象
Student student = new Student();
System.out.println(student);
// 将以上自己new的这个对象纳入Spring容器来管理。半路上交给Spring来管理。
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerSingleton("studentBean",student);
// 从spring容器中获取
Object studentBean = factory.getBean("studentBean");
System.out.println(studentBean);
}