`
fanjf
  • 浏览: 332768 次
  • 性别: Icon_minigender_1
  • 来自: 安徽
社区版块
存档分类
最新评论

源码解析:init-method、@PostConstruct、afterPropertiesSet孰先孰后

 
阅读更多

Spring 容器中的 Bean 是有生命周期的 Spring  允许在 Bean  在初始化完成后以及 Bean  销毁前执行特定的操作,常用的设定

方式有以下三种:

  • 通过实现 InitializingBean/DisposableBean  接口来定制初始化之后 / 销毁之前的操作方法;
  • 通过 <bean>  元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法;
  • 在指定方法上加上 @PostConstruct  @PreDestroy 注解 来制定该方法是在初始化之后还是销毁之前调用。  

这是我们就有个疑问,这三种方式是完全等同的吗,孰先孰后?

 

下面我们将带着这个疑问,试图通过测试代码以及分析 Spring 源码找到答案。

 

首先,我们还是编写一个简单的测试代码:

Java代码  
  1. public   class  InitSequenceBean  implements  InitializingBean {   
  2.     
  3.      public  InitSequenceBean() {   
  4.        System.out.println( "InitSequenceBean: constructor" );   
  5.     }   
  6.       
  7.      @PostConstruct   
  8.      public   void  postConstruct() {   
  9.        System.out.println( "InitSequenceBean: postConstruct" );   
  10.     }   
  11.       
  12.      public   void  initMethod() {   
  13.        System.out.println( "InitSequenceBean: init-method" );   
  14.     }   
  15.       
  16.      @Override   
  17.      public   void  afterPropertiesSet()  throws  Exception {   
  18.        System.out.println( "InitSequenceBean: afterPropertiesSet" );   
  19.     }   
  20. }  

public class InitSequenceBean implements InitializingBean {

public InitSequenceBean() {

System.out.println("InitSequenceBean: constructor");

}

@PostConstruct

public void postConstruct() {

System.out.println("InitSequenceBean: postConstruct");

}

public void initMethod() {

System.out.println("InitSequenceBean: init-method");

}

@Override

public void afterPropertiesSet() throws Exception { System.out.println("InitSequenceBean: afterPropertiesSet"); }

}

  

并且在配置文件中添加如下 Bean 定义:

< bean class = "InitSequenceBean" init-method = "initMethod" ></ bean >

 

好了,我们启动 Spring 容器,观察输出结果,就可知道三者的先后顺序了:

InitSequenceBean: constructor

InitSequenceBean: postConstruct

InitSequenceBean: afterPropertiesSet

InitSequenceBean: init-method

 

通过上述输出结果,三者的先后顺序也就一目了然了:

Constructor > @PostConstruct > InitializingBean > init-method

 

先大致分析下为什么会出现这些的结果:构造器( Constructor )被率先调用毋庸置疑, InitializingBean 先于 init-method

们也可以理解(在 也谈 Spring 容器的生命周期 中已经讨论过),但是 PostConstruct 为何率先于 InitializingBean 执行呢?

 

我们再次带着这个疑问去查看 Spring 源代码来一探究竟。

 

通过 Debug 并查看调用栈,我们发现了这个类 org.springframework.context.annotation.CommonAnnotationBeanPostProcessor ,从命名上,我们就可以得到某些信

息——这是一个 BeanPostProcessor 。想到了什么?在 也谈 Spring 容器的生命周期 中,我们提到过 BeanPostProcessor postProcessBeforeInitialization 是在 Bean 生命周期中 afterPropertiesSet init-method 之前执被调用的。

 

再次观察 CommonAnnotationBeanPostProcessor 这个类,它继承自 InitDestroyAnnotationBeanPostProcessor InitDestroyAnnotationBeanPostProcessor 顾名思义,就是在 Bean 初始化和销毁的时候所作的一个前置 / 后置处理器。

 

通过查看 InitDestroyAnnotationBeanPostProcessor 类下的 postProcessBeforeInitialization 方法:

Java代码  
  1. public  Object postProcessBeforeInitialization(Object bean, String beanName)  throws  BeansException {   
  2.        LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());   
  3.         try  {   
  4.            metadata.invokeInitMethods(bean, beanName);   
  5.        }   
  6.         catch  (InvocationTargetException ex) {   
  7.             throw   new  BeanCreationException(beanName,  "Invocation of init method failed" , ex.getTargetException());   
  8.        }   
  9.         catch  (Throwable ex) {   
  10.             throw   new  BeanCreationException(beanName,  "Couldn't invoke init method" , ex);   
  11.        }   
  12.          return  bean;   
  13.     }  
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {       LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());       try {           metadata.invokeInitMethods(bean, beanName);       }       catch (InvocationTargetException ex) {           throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());       }       catch (Throwable ex) {           throw new BeanCreationException(beanName, "Couldn't invoke init method", ex);       }        return bean;    }

  

查看 findLifecycleMetadata 方法,继而我们跟踪到 buildLifecycleMetadata 这个方法体中,看下 buildLifecycleMetadata 这个方法体的内容:

Java代码  
  1. private  LifecycleMetadata buildLifecycleMetadata( final  Class clazz) {   
  2.         final  LifecycleMetadata newMetadata =  new  LifecycleMetadata();   
  3.         final   boolean  debug = logger.isDebugEnabled();   
  4.        ReflectionUtils.doWithMethods(clazz,  new  ReflectionUtils.MethodCallback() {   
  5.             public   void  doWith(Method method) {   
  6.                if  (initAnnotationType !=  null ) {   
  7.                    if  (method.getAnnotation(initAnnotationType) !=  null ) {   
  8.                      newMetadata.addInitMethod(method);   
  9.                       if  (debug) {   
  10.                          logger.debug( "Found init method on class ["  + clazz.getName() +  "]: "  + method);   
  11.                      }   
  12.                   }   
  13.               }   
  14.                if  (destroyAnnotationType !=  null ) {   
  15.                    if  (method.getAnnotation(destroyAnnotationType) !=  null ) {   
  16.                      newMetadata.addDestroyMethod(method);   
  17.                       if  (debug) {   
  18.                          logger.debug( "Found destroy method on class ["  + clazz.getName() +  "]: "  + method);   
  19.                      }   
  20.                   }   
  21.               }   
  22.            }   
  23.        });   
  24.         return  newMetadata;   
  25. }  

private LifecycleMetadata buildLifecycleMetadata(final Class clazz) {

final LifecycleMetadata newMetadata = new LifecycleMetadata();

final boolean debug = logger.isDebugEnabled();

ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() {

public void doWith(Method method) {

if (initAnnotationType != null) {

if (method.getAnnotation(initAnnotationType) != null) {

newMetadata.addInitMethod(method);

if (debug) {

logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);

 }

}

}

if (destroyAnnotationType != null) {

if (method.getAnnotation(destroyAnnotationType) != null) { newMetadata.addDestroyMethod(method); if (debug) { logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method); } } } } }); return newMetadata;}

  

分析这段代码发现,在这里会去判断某方法有没有被 initAnnotationType/destroyAnnotationType 注释,如果有,则添加

init/destroy 队列中,后续一一执行。

 

initAnnotationType/destroyAnnotationType 注释是什么呢,我们在 CommonAnnotationBeanPostProcessor 的构造函数

中看到下面这段代码:

Java代码  
  1. public  CommonAnnotationBeanPostProcessor() {   
  2.        setOrder(Ordered.LOWEST_PRECEDENCE -  3 );   
  3.        setInitAnnotationType(PostConstruct. class );   
  4.        setDestroyAnnotationType(PreDestroy. class );   
  5.        ignoreResourceType( "javax.xml.ws.WebServiceContext" );   
  6. }  

public CommonAnnotationBeanPostProcessor() {

setOrder(Ordered.LOWEST_PRECEDENCE - 3);

setInitAnnotationType(PostConstruct.class);

setDestroyAnnotationType(PreDestroy.class);

ignoreResourceType("javax.xml.ws.WebServiceContext");

}

  

一切都清晰了吧。一言以蔽之, @PostConstruct 注解后的方法在 BeanPostProcessor 前置处理器中就被执行了,所以当然

要先于 InitializingBean init-method 执行了。

 

最后,给出本文的结论, Bean 在实例化的过程中:

Constructor > @PostConstruct > InitializingBean > init-method

 

本文源代码下载: https://lb-multi-demo.googlecode.com/svn/trunk/spring-lifecycle-test

分享到:
评论

相关推荐

    14、加载spring启动首先进入的类方法注解1

    System.out.println("I'm init method using @PostConstruct...." + message); } @PreDestroy public void dostory(){ System.out.println("I'm destroy method using @PreDestroy....." + message); } } `...

    Spring Bean 生命周期之“我从哪里来?”.docx

    初始化顺序为:首先调用`@PostConstruct`注解的方法,然后是`InitializingBean`的`afterPropertiesSet()`方法,最后是XML配置的`init-method`。 此外,Spring还提供了`BeanPostProcessor`接口,它允许自定义在Bean...

    Spring bean初始化及销毁你必须要掌握的回调方法.docx

    而在使用@Bean注解的Java配置中,可以通过`initMethod`属性来指定。 **销毁回调方法** 1. **@PreDestroy注解** 类似于@PostConstruct,@PreDestroy是Java的JSR-250规范的一部分,用于标记一个方法,在Bean即将被...

    Spring框架中Bean的生命周期 Spring中Bean有几种作用域

    - `destroy-method`属性:与`init-method`类似,此处指定的方法会在Bean销毁前执行。 接下来,我们讨论Spring中Bean的几种作用域: 1. **单例(Singleton)**:这是默认的作用域,Spring容器只会创建一个Bean实例...

    如何写好一个Spring组件的实现步骤

    同时,我们还定义了一个 initMethod 方法,它将在 Bean 创建完成后被调用。 接下来,我们需要创建一个 BeanPostProcessor 来处理 DemoBean: ```java @Configuration public class DemoBeanPostProcessor ...

    jsf学习资料2

    在Spring中,Bean的初始化可以通过多种方式实现,包括使用`@PostConstruct`注解、InitializingBean接口以及XML配置中的`init-method`属性。 - **@PostConstruct注解**: 在Bean的方法上添加`@PostConstruct`注解,该...

    spring里面想要让一个类的实例在所有属性都准备好之后就让它自动执行某些方法

    在Spring框架中,如果你希望一个类的实例在所有属性注入完成后自动执行某些特定的方法,你可以利用Spring的初始化回调机制。这个机制允许你在对象完全构造并准备好执行业务逻辑时执行一些自定义的操作。以下是对这个...

    spring容器初始化bean和销毁bean之前进行一些操作的方法

    3. 初始化:Bean实例完成属性注入后,会调用初始化方法,可以是`@PostConstruct`注解的方法或者通过`init-method`属性指定的方法。 4. 使用:容器将Bean暴露给其他Bean使用。 5. 销毁:当容器关闭时,或者Bean不再...

    spring加载顺序讨论

    2. **初始化回调**:除了`@PostConstruct`,Spring还支持自定义初始化回调方法,即在`&lt;bean&gt;`标签中使用`init-method`属性指定的方法。此方法会在依赖注入完成且`@PostConstruct`方法执行后被调用。 ### Bean的生命...

    Spring注解驱动开发.pdf

    - `@Bean`中的`initMethod`属性:指定初始化方法。 - **销毁**: - `DisposableBean`接口:实现该接口的类会在bean销毁前调用`destroy()`方法。 - `@PreDestroy`:用于标记在销毁前执行的方法。 - `@Bean`中的`...

    Spring Bean初始化及销毁多种实现方式

    &lt;bean id="demoService" class="com.dubbo.example.provider.DemoServiceImpl" destroy-method="close" init-method="initMethod"/&gt; ``` 或者,我们也可以使用注解方式配置: ```java @Configurable public class ...

    Spring.pdf

    值得注意的是,Spring 2.5版本后引入了注解的方式,可以使用@PostConstruct和@PreDestroy来代替XML中的init-method和destroy-method,从而更简洁地指定Bean的初始化和销毁方法。 容器本身也具备了极高的扩展性,...

    bean的生命周期1

    如果一个Bean实现了Spring的`InitializingBean`接口,那么它需要提供一个名为`afterPropertiesSet()`的方法,这个方法会在Bean的所有依赖注入完成后被自动调用。同样,如果实现了`DisposableBean`接口,那么Bean...

    Spring Bean Lifecycle Control

    另外,还可以通过`init-method`属性指定一个非注解的方法作为初始化方法。 2. **依赖注入**:Spring会根据Bean定义中的属性和构造器参数,将依赖注入到Bean实例中。这可以通过`@Autowired`、`@Value`等注解实现,...

    Spring面试问答

    Bean可以通过实现InitializingBean接口的afterPropertiesSet()方法或定义init-method属性进行初始化,通过DisposableBean接口的destroy()方法或定义destroy-method属性进行销毁。此外,还可以使用@PostConstruct和@...

    spring启动加载程序的几种方法介绍

    根据Spring的源码,`afterPropertiesSet()`方法会先于`initMethod()`执行,而`destroyMethod()`会先于`destroy()`执行。 ### Spring Bean的初始化过程 Spring容器在初始化Bean时,首先会进行依赖注入,然后按照...

    测试spring中的org.springframework.beans.factory.InitializingBean

    **替代方案:@PostConstruct** 随着Spring的发展,`@PostConstruct`注解提供了一种更简洁的实现初始化回调的方式。使用此注解的方法会在所有依赖注入完成后调用,与`InitializingBean`接口类似,但不需要实现整个...

    Spring part 2 :Bean的生命周期

    声明式则是在XML配置文件中使用`init-method`和`destroy-method`属性来指定初始化和销毁方法。 Bean的初始化阶段可以通过以下几种方式: 1. 实现InitializingBean接口,重写afterPropertiesSet()方法。 2. 使用@...

    spring资料5

    Spring提供了多种方式来管理Bean的生命周期,包括配置元数据(如`init-method`和`destroy-method`属性)、实现InitializingBean和DisposableBean接口、使用JSR-250注解(@PostConstruct和@PreDestroy)等。Bean的生命...

Global site tag (gtag.js) - Google Analytics