Spring Bean的生命周期

最新推荐文章于 2023-03-01 15:06:10 发布

mhHao

最新推荐文章于 2023-03-01 15:06:10 发布

阅读量95

点赞数

分类专栏：常用框架

原文链接：https://blog.csdn.net/w_linux/article/details/80086950

版权

常用框架专栏收录该内容

18 篇文章 0 订阅

订阅专栏

该篇博客就来了解IoC容器下Bean的一生吧，也可以理解为bean的生命周期。

####首先你需要知道的知识
在IoC容器启动之后，并不会马上就实例化相应的bean，此时容器仅仅拥有所有对象的BeanDefinition(BeanDefinition：是容器依赖某些工具加载的XML配置信息进行解析和分析，并将分析后的信息编组为相应的BeanDefinition)。只有当getBean()调用时才是有可能触发Bean实例化阶段的活动

#####为什么说有可能触发Bean实例化阶段？

因为当对应某个bean定义的getBean()方法第一次被调用时，不管是显示的还是隐式的，Bean实例化阶段才会被触发，第二次被调用则会直接返回容器缓存的第一次实例化完的对象实例(因为默认是singleton单例，当然，这里的情况prototype类型的bean除外)

##该篇博客主要阐述
#####1、Bean的一生过程
#####2、Bean的后置处理器

###一、Bean的一生过程
####先来看以下的图(Bean的一生)

####可以简述为以下九步

实例化bean对象(通过构造方法或者工厂方法)
设置对象属性(setter等)（依赖注入）
如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Aware接口）
如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法
调用Bean的初始化方法
将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法
使用Bean
容器关闭之前，调用Bean的销毁方法
####先看一个最简单的一生(没有使用Bean的后置处理器)

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**

@author LinJie
@Description:一个学生类(Bean)，能体现其生命周期的Bean
*/
public class Student implements BeanNameAware {
private String name;

//无参构造方法
public Student() {
super();
}

/** 设置对象属性
- @param name the name to set
  */
  public void setName(String name) {
  System.out.println(“设置对象属性setName()…”);
  this.name = name;
  }
//Bean的初始化方法
public void initStudent() {
System.out.println(“Student这个Bean：初始化”);
}

//Bean的销毁方法
public void destroyStudent() {
System.out.println(“Student这个Bean：销毁”);
}

//Bean的使用
public void play() {
System.out.println(“Student这个Bean：使用”);
}

/* 重写toString
- @see java.lang.Object#toString()
  */
  @Override
  public String toString() {
  return "Student [name = " + name + “]”;
  }
//调用BeanNameAware的setBeanName()
//传递Bean的ID。
@Override
public void setBeanName(String name) {
System.out.println(“调用BeanNameAware的setBeanName()…” );
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
测试类

package com.linjie.cycle;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**

测试类
@author LinJie

*/
public class CycleTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext.xml”);
Student student = (Student) context.getBean(“student”);
//Bean的使用
student.play();
System.out.println(student);
//关闭容器
((AbstractApplicationContext) context).close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>

	<bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
	<property name="name" value="LINJIE"></property>
	</bean>

1 2 3 4 5 6 7 8 9 10 11 12 控制台显示结果

可以在输出结果看出bean的一生，完全与之前的一生过程图相符(除了bean后置处理器部分)，这里还需要提及的是在xml配置中的两个属性

init-method：指定初始化的方法
destroy-method：指定销毁的方法
#####说到init-method和destroy-method，当然也要提及一下在< beans>的属性

default-init-method：为应用上下文中所有的Bean设置了共同的初始化方法
default-destroy-method：为应用上下文中所有的Bean设置了共同的销毁方法

###二、Bean的后置处理器

上面bean的一生其实已经算是对bean生命周期很完整的解释了，然而bean的后置处理器，是为了对bean的一个增强

####用法

分别在Bean的初始化前后对Bean对象提供自己的实例化逻辑

实现BeanPostProcessor接口
- postProcessBeforeInitialization方法
- postProcessAfterInitialization方法
  1
  2
  3
  ####接上面的Student Demo

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**

@author LinJie
@Description:一个学生类(Bean)，能体现其生命周期的Bean
*/
public class Student implements BeanNameAware {
private String name;

//无参构造方法
public Student() {
super();
}

/** 设置对象属性
- @param name the name to set
  */
  public void setName(String name) {
  System.out.println(“设置对象属性setName()…”);
  this.name = name;
  }
//Bean的初始化方法
public void initStudent() {
System.out.println(“Student这个Bean：初始化”);
}

//Bean的销毁方法
public void destroyStudent() {
System.out.println(“Student这个Bean：销毁”);
}

//Bean的使用
public void play() {
System.out.println(“Student这个Bean：使用”);
}

/* 重写toString
- @see java.lang.Object#toString()
  */
  @Override
  public String toString() {
  return "Student [name = " + name + “]”;
  }
//调用BeanNameAware的setBeanName()
//传递Bean的ID。
@Override
public void setBeanName(String name) {
System.out.println(“调用BeanNameAware的setBeanName()…” );
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
MyBeanPostProcessor.java（实现BeanPostProcessor接口）

package com.linjie.cycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**

bean的后置处理器
分别在bean的初始化前后对bean对象提供自己的实例化逻辑
postProcessAfterInitialization：初始化之后对bean进行增强处理
postProcessBeforeInitialization：初始化之前对bean进行增强处理
@author LinJie

*/
public class MyBeanPostProcessor implements BeanPostProcessor {

//对初始化之后的Bean进行处理
//参数：bean：即将初始化的bean
//参数：beanname：bean的名称
//返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
@Override
public Object postProcessAfterInitialization(Object bean, String beanname) throws BeansException {
	Student stu = null;
	System.out.println("对初始化之后的Bean进行处理,将Bean的成员变量的值修改了");
	if("name".equals(beanname) || bean instanceof Student) {
		stu = (Student) bean;
		stu.setName("Jack");
	}
	return stu;
}

//对初始化之前的Bean进行处理
//参数：bean：即将初始化的bean
//参数：beanname：bean的名称
//返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
@Override
public Object postProcessBeforeInitialization(Object bean, String beanname) throws BeansException {
	System.out.println("对初始化之前的Bean进行处理,此时我的名字"+bean);
	return bean;
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
测试类

package com.linjie.cycle;

/**

测试类
@author LinJie

<?xml version="1.0" encoding="UTF-8"?>

	<bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
	<property name="name" value="LINJIE"></property>
	</bean>
	
	<!-- 配置bean的后置处理器,不需要id，IoC容器自动识别是一个BeanPostProcessor -->
	<bean class="com.linjie.cycle.MyBeanPostProcessor"></bean>

1 2 3 4 5 6 7 8 9 10 11 12 13 14 控制台显示结果

可以在applicationContext.xml中看到配置Bean后置处理器，不需要ID，只需要其全类名，因为IoC容器自动识别一个BeanPostProcessor

#####在控制台显示结果可以看出,Bean的后置处理器强大之处，可以对Bean实现自己想要做的事情，比如我这里的Demo就是在postProcessAfterInitialization方法中将成员变量name偷偷修改了，最后输出的就是偷偷修改之后的值

好了以上就是bean的一生，在控制台下将bean的一生映射出来，对理解bean的一生(生命周期)更加直观咯

####参考
《Spring揭秘》
《Spring IN ACTION》

————————————————
版权声明：本文为CSDN博主「浅然_」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/w_linux/article/details/80086950