一、生命周期流程图:

  Spring Bean的完整生命周期从创建Spring容器开始,直到最终Spring容器销毁Bean,这其中包含了一系列关键点

假设一个Bean实现了所有的接口,大的概况一下Bean的生命周期:

1.实例化BeanFactoryPostProcessor:处理的对象是BeanFactory级别

2.实例化BeanPostProcessor实现类

3.实例化InstantiationAwareBeanPostProcessorAdapter实现类,注:该类是BeanPostProcessor的扩展

4.执行InstantiationAwareBeanPostProcessorAdapter类的postProcessBeforeInstantiation方法

5.Bean的构造方法

6.执行InstantiationAwareBeanPostProcessorAdapter类的postProcessPropertyValues

7.为Bean注入属性,即依赖注入

8.调用BeanNameAware的setBeanName方法

9.调用BeanNameAware的setBeanFactory方法

10.执行BeanPostProcessor的后置处理器,postProcessAfterInitialization方法

11.调用InitializingBean的afterPropertiesSet方法

12.调用bean的init-method初始化方法

13.执行BeanPostProcessor的postProcessAfterInitialization

14.执行InstantiationAwareBeanPostProcessorAdapter的后置方法,postProcessAfterInitialization

15.Bean的使用

16.调用DiposibleBean的destory方法

17.调用bean指定的destory-method方法

为了上述流程的正确性,我们可以用代码来测试一下:

测试Bean - StudentBean类:

/**
* 测试生命周期的Bean
* Created by kxm
*/
public class StudentBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware {
private String name;
private int age; private String beanName; //实现了BeanNameAware接口,Spring可以将BeanName注入该属性中
private BeanFactory beanFactory; //实现了BeanFactory接口,Spring可将BeanFactory注入该属性中 public StudentBean(){
System.out.println("【Bean构造方法】学生类的无参构造方法");
} @Override
public String toString() {
return "StudentBean{" +
"name='" + name + '\'' +
", age=" + age +
", beanName='" + beanName + '\'' +
'}';
} public String getName() {
return name;
} public void setName(String name) {
System.out.println("【set注入】注入学生的name属性");
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
System.out.println("【set注入】注入学生的age属性");
this.age = age;
} /**
* 自己编写的初始化方法
*/
public void myInit(){
System.out.println("【init-method】调用init-method属性配置的初始化方法");
} /**
* 自己编写的销毁方法
*/
public void myDestroy(){
System.out.println("【destroy-method】调用destroy-method属性配置的销毁方法");
} /**
* BeanFactoryAware接口的方法
* @param beanFactory
* @throws BeansException
*/
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
System.out.println("【BeanFactoryAware接口】调用BeanFactoryAware的setBeanFactory方法得到beanFactory引用");
} /**
* BeanNameAware接口的方法
* @param name
*/
public void setBeanName(String name) {
this.beanName = name;
System.out.println("【BeanNameAware接口】调用BeanNameAware的setBeanName方法得到Bean的名称");
} /**
* InitializingBean接口的方法
* @throws Exception
*/
public void afterPropertiesSet() throws Exception {
System.out.println("【InitializingBean接口】调用InitializingBean接口的afterPropertiesSet方法");
} /**
* DisposableBean接口的方法
* @throws Exception
*/
public void destroy() throws Exception {
System.out.println("【DisposableBean接口】调用DisposableBean接口的destroy方法");
}
}

MyBeanFactoryPostProcessor工厂处理器类:

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor实现类构造方法");
} /**
* 重写BeanFactoryPostProcessor接口的postProcessBeanFactory方法,可通过该方法对beanFactory进行设置
*/
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
System.out.println("【BeanFactoryPostProcessor接口】调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法");
}
}

MyInstantiationAwareBeanPostProcessor类:

/**
* 一般情况下,当我们需要实现InstantiationAwareBeanPostProcessor接口时,是通过继承Spring框架中InstantiationAwareBeanPostProcessor接口实现类
* InstantiationAwareBeanPostProcessorAdapter这个适配器类来简化我们实现接口的工作
*/
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter { public MyInstantiationAwareBeanPostProcessor() {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor构造方法");
} /**
* 实例化Bean之前调用
*/
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法");
return null;
} /**
* 实例化Bean之后调用
*/
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInitialization方法");
return bean;
} /**
* 设置某个属性时调用
*/
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
System.out.println("【InstantiationAwareBeanPostProcessor接口】调用InstantiationAwareBeanPostProcessor接口的postProcessPropertyValues方法");
return pvs;
}
}

MyBeanPostProcessor类:

/**
* Created by kxm
*/
public class MyBeanPostProcessor implements BeanPostProcessor { public MyBeanPostProcessor(){
System.out.println("【BeanPostProcessor接口】调用BeanPostProcessor的构造方法");
} public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessBeforeInitialization方法,这里可对"+beanName+"的属性进行更改。");
return bean;
} public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("【BeanPostProcessor接口】调用postProcessAfterInitialization方法,这里可对"+beanName+"的属性进行更改。");
return bean;
}
}

XML配置:

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"> <!-- 生命周期测试 -->
<!--配置Bean的后置处理器-->
<bean id="beanPostProcessor" class="com.my.spring.life.MyBeanPostProcessor">
</bean> <!--配置instantiationAwareBeanPostProcessor-->
<bean id="instantiationAwareBeanPostProcessor" class="com.my.spring.life.MyInstantiationAwareBeanPostProcessor">
</bean> <!--配置BeanFactory的后置处理器-->
<bean id="beanFactoryPostProcessor" class="com.my.spring.life.MyBeanFactoryPostProcessor">
</bean> <bean id="studentBean" class="com.my.spring.life.StudentBean" init-method="myInit"
destroy-method="myDestroy" scope="singleton">
<property name="name" value="yanxiao"></property>
<property name="age" value="21"></property>
</bean>
</beans>

测试类:

public class TestCyclelife {

	/**
* Created by yanxiao on 2016/8/1.
*/
public static void main(String[] args){
System.out.println("--------------【初始化容器】---------------"); ApplicationContext context = new ClassPathXmlApplicationContext("Springlife.xml");
System.out.println("-------------------【容器初始化成功】------------------");
//得到studentBean,并显示其信息
StudentBean studentBean = context.getBean("studentBean",StudentBean.class);
System.out.println(studentBean); System.out.println("--------------------【销毁容器】----------------------");
((ClassPathXmlApplicationContext)context).registerShutdownHook();
}
}

测试结果如下:

符合上述的Bean的生命周期,至此,Bean的生命周期问题已基本解决,不过还等待着你继续去深入。

Spring Bean的生命周期 ---附详细流程图及测试代码的更多相关文章

  1. Spring Bean的生命周期(非常详细)

    Spring作为当前Java最流行.最强大的轻量级框架,受到了程序员的热烈欢迎.准确的了解Spring Bean的生命周期是非常必要的.我们通常使用ApplicationContext作为Spring ...

  2. Spring Bean的生命周期,《Spring 实战》书中的官方说法

    连着两天的面试 ,都问到了 Spring 的Bean的生命周期,其中还包括 昨晚一波阿里的电话面试.这里找到了Spring 实战中的官方说法.希望各位要面试的小伙伴记住,以后有可能,或者是有时间 去看 ...

  3. Spring Bean的生命周期相关博客

    最近得面试题一直 问 Spring 得生命周期,鉴于自己还未阅读过源码 所以只能是自己 背一波了.属实不懂硬背得作用,但是无奈被各位面试官打败了.等以后有时间了 一定要阅读几遍spring的 源码 有 ...

  4. Spring Bean的生命周期详解(转)

    Spring作为当前Java最流行.最强大的轻量级框架,受到了程序员的热烈欢迎.准确的了解Spring Bean的生命周期是非常必要的.我们通常使用ApplicationContext作为Spring ...

  5. Spring动态代理及Spring Bean的生命周期

    数组添加值 public class DiTest { /** * 数组 */ private String [] arrays; /** * List:集合 */ private List<I ...

  6. 谈谈Spring bean的生命周期(一)

    简介 本片文章主要讲Spring IOC容器中 bean 的生命周期 Spring bean 生命周期 Spring 中bean的声明周期 可以分为如下4个阶段: 实例化阶段--Instantiati ...

  7. spring bean的生命周期

    掌握好spring bean的生命周期,对spring的扩展大有帮助.  spring bean的生命周期(推荐看)  spring bean的生命周期

  8. Spring学习手札(四)谈谈Spring Bean的生命周期及作用域

    在Spring中,那些组成应用程序的主体以及由Spring IoC容器所管理的对象,被称之为Bean.Bean与应用程序中其他对象(比如自己创建类)的区别就是,Bean是由IoC容器创建于销毁的.在S ...

  9. Spring(三)--Spring bean的生命周期

    Spring bean的生命周期 ApplicationContext Bean生命周期流程 1.需要的实体类 ackage com.xdf.bean; import org.springframew ...

随机推荐

  1. 『图论』LCA 最近公共祖先

    概述篇 LCA (Least Common Ancestors) ,即最近公共祖先,是指这样的一个问题:在一棵有根树中,找出某两个节点 u 和 v 最近的公共祖先. LCA 可分为在线算法与离线算法 ...

  2. GitHub如何回滚代码?

    1.git log 查看commit hash值 执行git log:查看commit hash值. 2.执行git reset --hard xxxx xxxx表示的是commit hash 值. ...

  3. 多语言工作者の十日冲刺<8/10>

    这个作业属于哪个课程 软件工程 (福州大学至诚学院 - 计算机工程系) 这个作业要求在哪里 团队作业第五次--Alpha冲刺 这个作业的目标 团队进行Alpha冲刺--第八天(05.07) 作业正文 ...

  4. django OperationalError: unable to open database file 创建数据库

  5. Django的F查询和Q查询,事务,ORM执行原生SQL

    F查询和Q查询,事务及其他   F查询和Q查询 F查询 在上面所有的例子中,我们构造的过滤器都只是将字段值与某个我们自己设定的常量做比较.如果我们要对两个字段的值做比较,那该怎么做呢? Django ...

  6. laravel生成key失败

    laravel生成key失败 生成KEY失败.原因是没有复制.env文件 In KeyGenerateCommand.php line 96: file_get_contents(D:\project ...

  7. Python3-threading模块-多线程

    什么是线程? 线程是操作系统能够进行运算调度的最小单位.它被包含在进程之中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务 P ...

  8. 使用onload和setTimeout、setInterval来实现当前的时间

    1.在body里面使用onload和在函数中使用setTimeout来实现当前的日期时间不断变化 2.在script中直接是用setInterval实现当前实现的日期时间不断变化 <!DOCTY ...

  9. 博弈论Nim取子问题,困扰千年的问题一行代码解决

    本文始发于个人公众号:TechFlow,原创不易,求个关注 今天是算法与数据结构专题26篇文章,我们来看看一个新的博弈论模型--Nim取子问题. 这个博弈问题非常古老,延续长度千年之久,一直到20世纪 ...

  10. Python进阶之浅谈内置方法(补充)

    目录 列表类型的内置方法 元组类型的内置方法 字典类型的内置方法 集合类型的内置方法 列表类型的内置方法 1.作用:描述名字,说的话等 2.定义方式 s=['tim','age'] s=str('ti ...