Spring Bean生命周期中各方法的执行顺序及代码

方法的执行顺序

1. Bean 容器 / BeanFactory 通过对象的构造器或工厂方法先实例化 Bean；
2. 设置对象属性
3. 检查 xxxAware 相关接口,如果有就调用相应的 setxxx 方法把所需要的 xxx 传入到 Bean 中。
4. 检查是否存在有关联的 BeanPostProcessors执行执行 postProcessBeforeInitialization() 方法进行前置处理
5. 调用 @PostConstruct注解的方法
6. 如果 Bean 实现了 InitializingBean 接口，执行 afterPropertiesSet() 方法。
7. 检查是否配置了自定义的 init-method 属性，如果有就调用指定方法。
8. 检查是否存在有关联的 BeanPostProcessors 执行 postProcessAfterInitialization() 方法进行后置处理
9. 使用bean
10. 当容器关闭时，调用@PreDestroy注解的方法
11. 如果实现了 DisposableBean 接口，如果有就调用 destory() 方法。
12. 如果 Bean 配置文件中的定义包含 destroy-method 属性，执行指定的方法。

实验代码

bean.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       "
       default-init-method="init_method" default-destroy-method="destroy_method">
  <context:component-scan   base-package="spring" />
  <bean class="spring.InitHelloWorld"/>
  <bean id="hello" class="spring.Hello1" >
    <property name="message" value="ccccccccc"/>
  </bean>
</beans>

Hello1.java

package spring;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;    
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;     
public class Hello1 implements InitializingBean, BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean{
  private String message;      
  public String getMessage(){
    return message;
  }      
  public void setMessage(String message){
    System.out.println("Hello1 setMessage");
    this.message = message;
  }      
  public Hello1(){
    System.out.println("Hello1 构造器");
  }      
  public void hello(){
    System.out.println("Hello1 我是：" + message);
  }      
  public void init_method(){
    System.out.println("Hello1 init-method ");
  }    
  @PostConstruct
  public void postConstruct(){
    System.out.println("Hello1 @PostConstruct");
  }      
  @Override
  public void afterPropertiesSet() throws Exception{
    System.out.println("Hello1 InitializingBean.afterPropertiesSet");
  }      
  @Override
  public void setBeanName(String s){
    System.out.println("Hello1 setBeanName " + s);
  }      
  @Override
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException{
    System.out.println("Hello1 setBeanFactory " );
  }      
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{      
    System.out.println("Hello1 setApplicationContext " );
  }      
  @Override
  public void destroy() throws Exception{
    System.out.println("Hello1 DisposableBean.destroy " );
  }      
  public void destroy_method() throws Exception{
    System.out.println("Hello1 destroy-method " );
  }      
  @PreDestroy
  public void preDestroy() throws Exception{
    System.out.println("Hello1 @PreDestroy " );
  }
}

InitHelloWord.java

package spring;    
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.core.Ordered;    
public class InitHelloWorld implements BeanPostProcessor,Ordered{
  @Override
  public Object postProcessBeforeInitialization(Object o, String s) throws BeansException{
    System.out.println("BeanPostProcessor1.postProcessBeforeInitialization:" + s);
    return o;
  }      
  @Override
  public Object postProcessAfterInitialization(Object o, String s) throws BeansException{
    System.out.println("BeanPostProcessor1.postProcessAfterInitialization:" + s);
    return o;
  }      
  @Override
  public int getOrder(){
    return 10;
  }
}

MainApp.java

package spring;    
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;    
public class MainApp{
  public static void main(String... args){
    AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    Hello1 hello = (Hello1) ctx.getBean("hello");
    hello.hello();
    ctx.close();
  }
}

代码执行结果如下：

Hello1 构造器
Hello1 setMessage
Hello1 setBeanName hello
Hello1 setBeanFactory 
Hello1 setApplicationContext 
BeanPostProcessor1.postProcessBeforeInitialization:hello
Hello1 @PostConstruct
Hello1 InitializingBean.afterPropertiesSet
Hello1 init-method 
BeanPostProcessor1.postProcessAfterInitialization:hello
Hello1 我是：ccccccccc
Hello1 @PreDestroy 
Hello1 DisposableBean.destroy 
Hello1 destroy-method