结合spring的一些钩子函数，看bean的生命周期

本次用了spring的这些接口：
接口名实现接口方法
BeanFactoryAware setBeanFactory()
BeanNameAware setBeanName()
InitializingBean afterPropertiesSet()
DisposableBean destroy()
BeanFactoryPostProcessor postProcessBeanFactory
BeanPostProcessor postProcessBeforeInitialization
postProcessAfterInitialization
继承了类InstantiationAwareBeanPostProcessorAdapter，重写里面的三个方法postProcessBeforeInstantiation(),postProcessAfterInstantiation(),postProcessPropertyValues。

下面我们通过一个例子，来看bean的生命周期：
1.创建Student类，实现接口BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean

public class Student implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{

	private String name;
	private Integer age;
	
	private BeanFactory beanFactory;
	private String beanName;
	
	
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		System.out.println("调用了  Student->setName");
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		System.out.println("调用了  Student->setAge");
		this.age = age;
	}

	public Student() {
		System.out.println("调用了 Student->构造器");
	}
	
	@Override
	public void destroy() throws Exception {//DisposableBean
		System.out.println("调用了  DisposableBean->destroy");
	}

//在初始化时调用
	@Override
	public void afterPropertiesSet() throws Exception {//InitializingBean
		System.out.println("调用了  InitializingBean->afterPropertiesSet");
	}
	//在对象实例化后调用
	@Override
	public void setBeanName(String name) {//BeanNameAware
		System.out.println("调用了  BeanNameAware->setBeanName");
		this.beanName = name;
	}
//在对象实例化后调用
	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {//BeanFactoryAware
		System.out.println("调用了  BeanFactoryAware->setBeanName");
		this.beanFactory = beanFactory;
		
	}
	//初始化时调用
	public void stuInitMethod() {
		System.out.println("调用了 Student->initmethod");
	}
	//对象销毁前调用
	public void stuDestoryMethod() {
		System.out.println("调用了 Student->stuDestoryMethod");
	}

2.创建MyBeanFactoryPostProcess类，实现接口BeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{


	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("调用了  MyBeanFactoryPostProcessor->postProcessBeanFactory");
		
	}

}

3.创建MyBeanPostProcessor,实现接口BeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {
	//初始化前调用
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("调用了  MyBeanPostProcessor-》postProcessBeforeInitialization");
		return bean;
	}
//初始化后调用
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("调用了  MyBeanPostProcessor-》postProcessAfterInitialization");
		return bean;
	}

}

4.创建MyInstantiationAwareBeanPostProcessor类，继承InstantiationAwareBeanPostProcessorAdapter类

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
//对象实例化前调用
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		System.out.println("调用了 MyInstantiationAwareBeanPostProcessor -》postProcessBeforeInstantiation");
		return super.postProcessBeforeInstantiation(beanClass, beanName);
	}

	//给对象设置属性，结合postProcessAfterInstantiation方法的返回结果
	//postProcessAfterInstantiation返回为false时，后面不会调用对象的set方法，给对象赋值（比如setAge）,如果为true，后面会调用set方法覆盖掉这个方法设置的值
	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
			String beanName) throws BeansException {
		System.out.println("调用了  MyInstantiationAwareBeanPostProcessor-》postProcessPropertyValues");
		return super.postProcessPropertyValues(pvs, pds, bean, beanName);
	}

//对象实例化后调用，返回为false时后面不会调用对象的set方法
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		System.out.println("调用了  MyInstantiationAwareBeanPostProcessor-》postProcessAfterInstantiation");
		return super.postProcessAfterInstantiation(bean, beanName);
	}

}

5.在resource下创建spring配置文件-applicationContext.xml

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

<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 id="beanFactoryPostProcessor" class="wf.testspringbean.MyBeanFactoryPostProcessor"/>
	
	<bean id="beanPostProcessor" class="wf.testspringbean.MyBeanPostProcessor"/>
	
	<bean id="instantiationAwareBeanPostProcessor" class="wf.testspringbean.MyInstantiationAwareBeanPostProcessor"/>

    <bean id="student" class="wf.testspringbean.Student" init-method="stuInitMethod"
        destroy-method="stuDestoryMethod" scope="singleton" p:name="王五" p:age="23" />
</beans>

6.创建测试类Test

public class Test {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:/applicationContext.xml");
		Student student = (Student)context.getBean("student");
		context.close();
	}

}

7.看控制台的输出顺序：

1 .调用了  MyBeanFactoryPostProcessor->postProcessBeanFactory
2 .调用了 MyInstantiationAwareBeanPostProcessor -》postProcessBeforeInstantiation
3 .调用了 Student->构造器
4 .调用了  MyInstantiationAwareBeanPostProcessor-》postProcessAfterInstantiation
5 .调用了  MyInstantiationAwareBeanPostProcessor-》postProcessPropertyValues
6 .调用了  Student->setAge
7 .调用了  Student->setName
8 .调用了  BeanNameAware->setBeanName
9 .调用了  BeanFactoryAware->setBeanName
10.调用了  MyBeanPostProcessor-》postProcessBeforeInitialization
11.调用了  InitializingBean->afterPropertiesSet
12.调用了 Student->initmethod
13.调用了  MyBeanPostProcessor-》postProcessAfterInitialization
14.调用了  DisposableBean->destroy
15.调用了 Student->stuDestoryMethod

从这个输出，就可以看出来执行顺序了。
总结执行顺序是：
1.BeanFactoryPostProcessor ->postProcessBeanFactory (肯定要bean工厂初始化完后才能创建bean)
2.InstantiationAwareBeanPostProcessor ->postProcessBeforeInstantiation(实例化bean前调用)
3.实例化对象调用对象构造方法
4.InstantiationAwareBeanPostProcessor ->postProcessAfterInstantiation（实例化bean后调用）
5.InstantiationAwareBeanPostProcessor -> postProcessPropertyValues
6.设置对象属性调用对象属性的set方法
7.实现了Aware接口,调用实现的接口方法
8.调用BeanPostProcessor -> postProcessBeforeInitialization(初始化前调用)
9.调用InitializingBean -> afterPropertiesSet(可覆盖第五步设置的属性值)
10.调用对象指定的init-method
11.调用BeanPostProcessor -> postProcessAfterInitialization (初始化完毕调用)
12.调用DisposableBean->destroy
13.调用对象指定的 destory-method

fly丶

发布了42 篇原创文章 · 获赞 29 · 访问量 2540

私信关注

结合spring的一些钩子函数，看bean的生命周期

猜你喜欢