解释Spring框架中bean的生命周期

一、Bean生命周期的流程图

二、spring的生命周期

    spring生命周期中的阶段，包括初始化、使用、销毁。

    1、初始化阶段
        1）调用bean的构造函数，创建实例；
        2）进行参数依赖注入；
        3）若实现org.springframework.beans.BeanNameAware接口，则调用BeanNameAware的setBeanName()方法;
        4）若实现org.springframework.beans.factory.BeanClassLoaderAware接口，则调用BeanClassLoaderAware的setBeanClassLoader()方法;
        5）若实现org.springframework.context.ApplicationContextAware接口，则调用ApplicationContextAware的setApplicationContext()方法;
        6）若使用了注解@PostConstruct，则调相应方法；
        7）若实现org.springframework.beans.factory.InitializingBean接口，则调用InitializingBean接口的afterPropertiesSet方法;
        8）若bean定义的使用了initMethod，则调相应方法；
        9）若实现org.springframework.beans.factory.config.BeanPostProcessor接口，则调用BeanPostProcessor的postProcessBeforeInitialization()方法和              postProcessAfterInitialization方法;
  
  2、使用阶段
        1）bean在项目的使用；
  
  3、销毁阶段
        1）若使用注解@PreDestroy，则调用相应方法；
        2）若bean定义中配置了destroyMethod，则调用相应方法；
        3）若实现org.springframework.beans.factory.DisposableBean接口，则调用DisposableBean接口的destroy方法; 

四、bean生命周期示例

         1、定义bean文件　SpringBeanLife.class

         import org.springframework.beans.BeansException;
         import org.springframework.beans.factory.BeanClassLoaderAware;
         import org.springframework.beans.factory.BeanNameAware;
         import org.springframework.beans.factory.DisposableBean;
         import org.springframework.beans.factory.InitializingBean;
         import org.springframework.beans.factory.config.BeanPostProcessor;
         import org.springframework.context.ApplicationContext;
         import org.springframework.context.ApplicationContextAware;

         import javax.annotation.PostConstruct;
         import javax.annotation.PreDestroy;

          public class SpringBeanLife implements BeanNameAware, BeanClassLoaderAware, ApplicationContextAware,
                          InitializingBean, BeanPostProcessor, DisposableBean {

                      private String id;

                      /******************* 下面是方法按时间执行的先后顺序 *************************/
                      //初始化
                      SpringBeanLife() {
                            System.out.println("bean init");
                      }

                      //参数注入
                      public void setId(String id) {
                            this.id = id;
                            System.out.println("invoke set method");
                      }

                      //来自BeanNameAware
                      @Override
                      public void setBeanName(String name) {
                            System.out.println("invoke setBeanName");
                      }

                     //来自BeanClassLoaderAware
                     @Override
                     public void setBeanClassLoader(ClassLoader classLoader) {
                            System.out.println("invoke setBeanClassLoader");
                     }  

                    //来自ApplicationContextAware
                    @Override
                    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
                            System.out.println("invoke setApplicationContext");
                    }

                    //来自注解@PostConstruct
                    @PostConstruct
                    public void postConstructMethod() {
                            System.out.println("invoke postConstructMethod");
                   }

                   //来自InitializingBean
                   @Override
                   public void afterPropertiesSet() throws Exception {
                            System.out.println("invoke afterPropertiesSet");
                  }

                  //来自配置initMethod = "initMethod"
                  public void initMethod() {
                           System.out.println("invoke init-method");
                  }

                 //来自BeanPostProcessor
                 @Override
                 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                          System.out.println("invoke postProcessBeforeInitialization");
                           return bean;
                 }

                 //来自BeanPostProcessor
                 @Override
                 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                         System.out.println("invoke postProcessAfterInitialization");
                         return bean;
                 }

                 //bean使用（如此时调用了下面的use方法）
                 public void use() {
                        System.out.println("use bean");
                 }

                 //来自注解@PreDestroy
                 @PreDestroy
                 public void preDestroyMethod() {
                        System.out.println("invoke preDestroyMethod");
                 }

                 //来自bean定义中的配置destroyMethod = "destoryMethod"
                 public void destoryMethod() {
                        System.out.println("invoke destory-method");
                 }

                 //来自DisposableBean
                 @Override
                 public void destroy() throws Exception {
                        System.out.println("invoke destroy");
                }
          }

      

          2、测试


          import org.springframework.beans.factory.annotation.Configurable;
          import org.springframework.context.annotation.AnnotationConfigApplicationContext;
          import org.springframework.context.annotation.Bean;

          @Configurable
          public class SpringConfig {

                      @Bean(initMethod = "initMethod", destroyMethod = "destoryMethod")
                      public SpringBeanLife springBeanLife() {
                              SpringBeanLife bean = new SpringBeanLife();
                              bean.setId("001");
                              return bean;
                      }

                      public static void main(String[] args) {
                              AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
                              SpringBeanLife bean = ctx.getBean(SpringBeanLife.class);
                              bean.use();
                              ctx.close();
                    }
            }


            输出：
                    
                bean init
                invoke set method
                invoke setBeanName
                invoke setBeanClassLoader
                invoke setApplicationContext
                invoke postConstructMethod
                invoke afterPropertiesSet
                invoke init-method
                invoke postProcessBeforeInitialization
                invoke postProcessAfterInitialization
                invoke postProcessBeforeInitialization
                invoke postProcessAfterInitialization
                use bean
                invoke preDestroyMethod
                invoke destroy
                invoke destory-method