Bean声明周期中的post-initialization和pre-destruction .

在Bean的声明周期中，有两个事件尤为重要：post-initialization和pre-destruction。

Spring提供了两种机制：interface-based和method-based，供bean签入上述事件。

所谓的post-initialization和pre-destruction，是指在bean的属性设置完毕执行的事件和在bean销毁之前执行的事件。

method-based机制：通过在BeanFactory中的配置，init-method和destory-method，通过设置这两个属性来指定要执行的回调方法。

interface-based机制：bean需要实现InitializatingBean接口和DisposableBean接口。这两个接口分别拥有afterPropertiesSet()方法和destroy()方法。这两个方法在bean初始化后和销毁前被执行。效果与method-based机制等同。

 

以下是网上流传一个例子，我在eclipse中运行了一下

package com.test;
import javax.annotation.PostConstruct; 
import javax.annotation.PreDestroy; 

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; 

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

public LifeCycle() { 
System.out.println("Constructor executing"); 
} 

private String cycle; 

public void setCycle(String cycle) { 
System.out.println("Setter methods executing"); 
this.cycle = cycle; 
} 

@Override 
public void setBeanName(String beanName) { 
System.out.println("BeanNameAware.setBeanName(String beanName) executing"); 
} 

@Override 
public void setBeanFactory(BeanFactory beanFactory) throws BeansException { 
System.out.println("BeanFactoryAware.setBeanFactory(BeanFactory beanFactory) executing"); 
} 

@PostConstruct 
public void beforeBeanConstructed() { 
System.out.println("BeanPostProcessor executing (before bean constructed)"); 
} 

@Override 
public void afterPropertiesSet() throws Exception { 
System.out.println("InitializingBean.afterPropertiesSet() executing"); 
} 

public void initMethod() { 
System.out.println("InitMethod executing"); 
} 

@PreDestroy 
public void afterBeanConstructed() { 
System.out.println("BeanPostProcessor executing (after bean constructed)"); 
} 

@Override 
public void destroy() throws Exception { 
System.out.println("DisposableBean.destroy() executing"); 
} 

public void destroyMethod() { 
System.out.println("DestroyMethod executing"); 
} 

} 

 

 

<?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-3.0.xsd"> 
	
		<bean id="lifeCycle" class="com.test.LifeCycle" init-method="initMethod" destroy-method="destroyMethod"> 
		<property name="cycle" value="Life Cycle"/> 
		</bean> 
		
		<bean id="beanPostProcessor" class="org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor"> 
		<property name="initAnnotationType" value="javax.annotation.PostConstruct"/> 
		<property name="destroyAnnotationType" value="javax.annotation.PreDestroy"/> 
		</bean> 
	
	</beans>

 

package com.test;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class LifeCycleDemo { 

	public static void main(String[] args) { 
	XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("beans-config.xml")); 
	
	BeanPostProcessor bpp = (BeanPostProcessor)factory.getBean("beanPostProcessor"); 
	factory.addBeanPostProcessor(bpp); 
	
	LifeCycle lifeCycle = (LifeCycle)factory.getBean("lifeCycle"); 
	
	factory.destroySingleton("lifeCycle"); 
	} 

}

 

 

最后运行结果是：
Constructor executing
Setter methods executing
BeanNameAware.setBeanName(String beanName) executing
BeanFactoryAware.setBeanFactory(BeanFactory beanFactory) executing
BeanPostProcessor executing (before bean constructed)
InitializingBean.afterPropertiesSet() executing
InitMethod executing
BeanPostProcessor executing (after bean constructed)
DisposableBean.destroy() executing
DestroyMethod executing

 注入Bean具体的实现：
具体的bean创建过程和依赖关系的注入在createBean中，这个方法在AbstractAutowireCapableBeanFactory中给出了实现：

protected Object createBean(String beanName, RootBeanDefinition
mergedBeanDefinition, Object[] args)
throws BeanCreationException {
 // Guarantee initialization of beans that the current one depends on.
 // 这里对取得当前bean的所有依赖bean，确定能够取得这些已经被确定的bean，如果没有被创建，那么这个createBean会被这些IOC
 // getbean时创建这些bean
 if (mergedBeanDefinition.getDependsOn() != null) {
  for (int i = 0; i < mergedBeanDefinition.getDependsOn().length; i++) {
   getBean(mergedBeanDefinition.getDependsOn()[i]);
  }
 }
 ........
 // 这里是实例化bean对象的地方，注意这个BeanWrapper类，是对bean操作的主要封装类
 if (instanceWrapper == null) {
  instanceWrapper = createBeanInstance(beanName, mergedBeanDefinition,args);
 }
 Object bean = instanceWrapper.getWrappedInstance();
 ......
 //这个populate方法，是对已经创建的bean实例进行依赖注入的地方，会使用到在loadBeanDefinition的时候得到的那些propertyValue来对bean进行注入。
 if (continueWithPropertyPopulation) {
  populateBean(beanName, mergedBeanDefinition, instanceWrapper);
 }
 //这里完成客户自定义的对bean的一些初始化动作
 Object originalBean = bean;
 bean = initializeBean(beanName, bean, mergedBeanDefinition);
 // Register bean as disposable, and also as dependent on specified "dependsOn"beans.
 registerDisposableBeanIfNecessary(beanName, originalBean,mergedBeanDefinition);
 return bean;
}
.........
}