Spring源码学习（六）-spring初始化回调方法源码学习

1.spring官方指定了三种初始化回调方法

　　1.1、@PostConstruct、@PreDestory

　　1.2、实现 InitializingBean DisposableBean 接口

　　1.3、设置init-method和destory-method

  三种方式的优先级从高到低

在spring官方文档里面有明确指出

 Multiple lifecycle mechanisms configured for the same bean, with
     different initialization methods, are called as follows:
       Methods annotated with @PostConstruct
       afterPropertiesSet() as defined by the InitializingBean callback interface
      A custom configured init() method
     Destroy methods are called in the same order:
       Methods annotated with @PreDestroy
       destroy() as defined by the DisposableBean callback interface
       A custom configured destroy() method 

2.三种配置初始化bean的方式，调用时机不同，对于注解，是在spring生命周期中第七个bean后置处理器调用的时候，由CommonAnnotationBeanPostProcessor的postProcessBeforeInitialization()方法来处理

而剩下的两种是在 第七个bean后置处理器执行之后的下一行代码中执行的 

 

3.@PostConstruct和@PreDestroy源码 

　　3.1、在spring生命周期中，第三个后置处理器方法：org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors；在CommonAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法，调用了buildLifecycleMetadata()方法，有一段比较重要的代码： 

　　

 do {
   final List<LifecycleElement> currInitMethods = new ArrayList<>();
   final List<LifecycleElement> currDestroyMethods = new ArrayList<>();

   ReflectionUtils.doWithLocalMethods(targetClass, method -> {
     //如果目标类中的方法，添加了@PostConstruct注解，就添加到currInitMethods
     if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
       LifecycleElement element = new LifecycleElement(method);
       currInitMethods.add(element);
       if (logger.isTraceEnabled()) {
         logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
       }
     }
     //如果目标类的方法，添加了@PreDestory注解，就添加到currDestroyMethod中
     if (this.destroyAnnotationType != null && method.isAnnotationPresent(this.destroyAnnotationType)) {
       currDestroyMethods.add(new LifecycleElement(method));
       if (logger.isTraceEnabled()) {
         logger.trace("Found destroy method on class [" + clazz.getName() + "]: " + method);
       }
     }
   });

   initMethods.addAll(0, currInitMethods);
   destroyMethods.addAll(currDestroyMethods);
   targetClass = targetClass.getSuperclass();
 }
 while (targetClass != null && targetClass != Object.class);

这里，最终会根据initMethods和destroyMethods来初始化一个LifecycleMetadata对象，然后再把new出来的元对象，存到了一个map中 lifecycleMetadataCache 

 

 private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
   if (this.lifecycleMetadataCache == null) {
     // Happens after deserialization, during destruction...
     return buildLifecycleMetadata(clazz);
   }
   // Quick check on the concurrent map first, with minimal locking.
   LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
   if (metadata == null) {
     synchronized (this.lifecycleMetadataCache) {
       metadata = this.lifecycleMetadataCache.get(clazz);
       if (metadata == null) {
         metadata = buildLifecycleMetadata(clazz);
         this.lifecycleMetadataCache.put(clazz, metadata);
       }
       return metadata;
     }
   }
   return metadata;
 }

　　3.2、在spring生命周期的第七个后置处理器方法中，org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization

会尝试先从lifecycleMetadataCache中根据class，获取到元对象，然后调用元对象的 invokeInitMethods()方法 

　　

 public void invokeInitMethods(Object target, String beanName) throws Throwable {
     Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
     Collection<LifecycleElement> initMethodsToIterate =
         (checkedInitMethods != null ? checkedInitMethods : this.initMethods);
     if (!initMethodsToIterate.isEmpty()) {
       boolean debug = logger.isDebugEnabled();
       for (LifecycleElement element : initMethodsToIterate) {
         if (debug) {
           logger.debug("Invoking init method on bean '" + beanName + "': " + element.getMethod());
         }
         element.invoke(target);
       }
     }
   }

这里的element.invoke()就是调用bean中添加了@PostConstruct注解的方法(method.invoke())

@PreDestory注解的原理是一样的，只是调用时机是在调用annotationConfigApplicationContext.close()方法的时候，会调用

org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeDestruction 

 

4.剩下的两种初始化方法，执行处理逻辑，是在一块代码中 

 

//在调用第七个后置处理器的下一行，是这个代码

　　try {

　　　　invokeInitMethods(beanName, wrappedBean, mbd);

　　} 

　　

 protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
       throws Throwable {

   //判断当前bean是否是 InitializingBean接口的实现类，如果是，判断是否实现了 afterPropertiesSet() 方法
   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
     if (logger.isTraceEnabled()) {
       logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
     }
     if (System.getSecurityManager() != null) {
       try {
         AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
           ((InitializingBean) bean).afterPropertiesSet();
           return null;
         }, getAccessControlContext());
       }
       catch (PrivilegedActionException pae) {
         throw pae.getException();
       }
     }
     else {
       ((InitializingBean) bean).afterPropertiesSet();
     }
   }

   //如果是在@Bean中配置了init-method和destroy-method，那执行的是这里的方法
   if (mbd != null && bean.getClass() != NullBean.class) {
     String initMethodName = mbd.getInitMethodName();
     if (StringUtils.hasLength(initMethodName) &&
         !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
         !mbd.isExternallyManagedInitMethod(initMethodName)) {
       invokeCustomInitMethod(beanName, bean, mbd);
     }
   }
 }

　　对于在@Bean注解指定init-method方式的，是在将class扫描到beanDefinition的时候，会对@Bean这种方式的bean进行处理

　　　　loadBeanDefinitionsForBeanMethod(beanMethod);在这里会设置bean的initMethod

　　spring扫描bean，将class扫描到beanDefinitionMap中有三种方式；

　　　　@ComponentScan注解

　　　　@Import

　　　　    importBeanDefinitionRegistrar

　　　　    importSelector

　　　　@Bean 

 

 

5.对于销毁方法，还没仔细研究，后面了解之后，再做补充： 

 

　　

 public void destroy() {
     //这里是处理@PreDestroy注解的销毁方法
     if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
         for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
             processor.postProcessBeforeDestruction(this.bean, this.beanName);
         }
     }

     if (this.invokeDisposableBean) {
         if (logger.isTraceEnabled()) {
             logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
         }
         try {
             if (System.getSecurityManager() != null) {
                 AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                     ((DisposableBean) this.bean).destroy();
                     return null;
                 }, this.acc);
             }
             else {
                 //这里是处理 DisposableBean 接口实现类中destroy()销毁方法的逻辑
                 ((DisposableBean) this.bean).destroy();
             }
         }
         catch (Throwable ex) {
             String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
             if (logger.isDebugEnabled()) {
                 logger.warn(msg, ex);
             }
             else {
                 logger.warn(msg + ": " + ex);
             }
         }
     }

     //这是处理@Bean中 destory-method这种方式的销毁方法
     if (this.destroyMethod != null) {
         invokeCustomDestroyMethod(this.destroyMethod);
     }
     else if (this.destroyMethodName != null) {
         Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
         if (methodToInvoke != null) {
             invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
         }
     }
 }