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));
        }
    }
}