spring源码分析(六) 销毁方法，初始化之前的方法加载和执行过程分析

本文主要是介绍spring源码分析(六) 销毁方法，初始化之前的方法加载和执行过程分析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

先看两个注解:

@Component
public class People {

    // bean销毁之前执行，容器关闭的时候执行
    @PreDestroy
    public void predesory(){
        System.out.println("predesory 执行了");
    }
    // bean创建之前执行
    @PostConstruct
    public void init(){
        System.out.println("PostConstruct 执行了");
    }
}

bean销毁之前执行的方法还有一种定义的方式，就是实现  DisposableBean 接口，里面有一个destory方法，这个方法在容器关闭之前，bean销毁之前执行。

容器关闭:

手动关闭，手动关闭容器，容器中的bean会被正常销毁。

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);
applicationContext.close();

 注册一个钩子函数。

// 注入一个关闭的钩子，引用是jvm的一个关闭钩子（线程），也就是当前jvm关闭的时候，spring容器也会关闭，bean会销毁。
applicationContext.registerShutdownHook();

public void registerShutdownHook() {
        if (this.shutdownHook == null) {
            // No shutdown hook registered yet.
            this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
                @Override
                public void run() {
                    synchronized (startupShutdownMonitor) {
                        doClose();
                    }
                }
            };
            Runtime.getRuntime().addShutdownHook(this.shutdownHook);
        }
    }

 上面两个注解能够正常执行，和上篇分析的 CommonAnnotationBeanPostProcessor 有关系，它不止处理@Resource注解，也有其它作用。

public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
        implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {

上面继承了一个 InitDestroyAnnotationBeanPostProcessor ，这个类有个方法：postProcessMergedBeanDefinition，在CommonAnnotationBeanPostProcessor 子类中中这个方法还有一个功能:@Resource ,@Autowire都经过这个方法找到注入点的

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        //调用父类的方法找到
        super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
        // 找到注入点
        InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
        metadata.checkConfigMembers(beanDefinition);
    }

父类:postProcessMergedBeanDefinition 方法

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        // 生命周期有关的注解方法封装成 LifecycleMetadata
        LifecycleMetadata metadata = findLifecycleMetadata(beanType);
        metadata.checkConfigMembers(beanDefinition);
    }

private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
        // 如果这个bean不是候选者bean,直接返回空的
        if (!AnnotationUtils.isCandidateClass(clazz, Arrays.asList(this.initAnnotationType, this.destroyAnnotationType))) {
            return this.emptyLifecycleMetadata;
        }
       // 存放初始化方法的element集合
        List<LifecycleElement> initMethods = new ArrayList<>();
        //  存放销毁方法的element集合
        List<LifecycleElement> destroyMethods = new ArrayList<>();
        Class<?> targetClass = clazz;

        do {
            final List<LifecycleElement> currInitMethods = new ArrayList<>();
            final List<LifecycleElement> currDestroyMethods = new ArrayList<>();
            
            // 和前面找@Autowire的注解很像
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                // 初始化注解方法查找
                //this.initAnnotationType 通过 setInitAnnotationType 设置的，这个方法可以自己调用设置自定义的注解
                // 默认在子类 CommonAnnotationBeanPostProcessor 构造函数中调用注入 setInitAnnotationType(PostConstruct.class)
                if (this.initAnnotationType != null && method.isAnnotationPresent(this.initAnnotationType)) {
                    // 方法封装成  LifecycleElement
                    LifecycleElement element = new LifecycleElement(method);
                    // 放入 currInitMethods中
                    currInitMethods.add(element);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Found init method on class [" + clazz.getName() + "]: " + method);
                    }
                }
                // 销毁方法查找
                // this.destroyAnnotationType 是通过 setDestroyAnnotationType方法设置的，
                // 默认也是在子类的构造函数中注入默认的 setDestroyAnnotationType(PreDestroy.class) 
                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);

        return (initMethods.isEmpty() && destroyMethods.isEmpty() ? this.emptyLifecycleMetadata :
                new LifecycleMetadata(clazz, initMethods, destroyMethods));
    }

在InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization 方法中调用initMethods 集合中存放的初始化之前的方法。

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  // 会从缓存中获取了      
  LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
        try {
            //调用 postProcessMergedBeanDefinition方法中找到的注解标注的初始化方法
            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, "Failed to invoke init method", ex);
        }
        return bean;
    }

就是调用反射调用那些加了PostConstruct 注解的方法。

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()) {
                for (LifecycleElement element : initMethodsToIterate) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
                    }
                    element.invoke(target);
                }
            }
        }

 销毁方法执行:

 主要看applicationContext.close();  这个方法，里面调用了doClose方法，通过发布关闭事件关闭容器。注意：spring容器关闭，并不是JVM关闭，比如applicationContext.close(); 后面还可以有其它的逻辑。

 在 DefaultSingletonBeanRegistry类中有一个属性 disposableBeans 记录所有实现了DisposableBean 接口的，在destroyBeans（）方法中会遍历这个集合，找到对应的bean，然后调用里面的destroy方法。

但是这里的disposableBeans 这个map中不止只有实现了DisposableBean 这个接口的bean，还有其它的一些bean，这个map的赋值是在创建bean的时候进行的，在doCreateBean中。 

 AbstractAutowireCapableBeanFactory#doCreateBean中，在创建完bean之后，最后一步就是注入disposable相关的bean到disposableBeans这个map中，

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
   AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
   //只有非原型bean才会去执行它们的构造和销毁的前置方法
// 并且还要是 requiresDestruction中指定的几种方式
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
      if (mbd.isSingleton()) {
         // Register a DisposableBean implementation that performs all destruction
         // work for the given bean: DestructionAwareBeanPostProcessors,
         // DisposableBean interface, custom destroy method.
         //如果上面判断有销毁方法，就封装成DisposableBeanAdapter 类
// put进  disposableBeans 这个map中，放进去的只是个适配器
// 从disposableBeans.get出来的对象要强转成DisposableBean调用close方法
registerDisposableBean(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
      else {
         // A bean with a custom scope...
Scope scope = this.scopes.get(mbd.getScope());
         if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
         }
         scope.registerDestructionCallback(beanName,
               new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
      }
   }
}

 requiresDestruction(bean, mbd)  中判断bean中是否销毁的方法，有写重要的逻辑判断。

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
        // 判断某个bean是否有销毁的方法
        // 1:  实现了Disposable 或者AutoCloseable接口
        // 2：  BeanDefinition中定义了destroyMethodName方法
        // 类中是否存在@PreDestroy注解的方法
        return (bean.getClass() != NullBean.class &&

                (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
                        DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
    }

第一个判断非空判断不用多说。

第二个判断:DisposableBeanAdapter.hasDestroyMethod(bean, mbd)

public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
        // 首先判断 bean是否实现了 DisposableBean，AutoCloseable接口
        if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
            return true;
        }
        //  beanDefinition 中定义了 destroyMethodName,如果xml定义的bean 可以通过destroy-method属性指定这个name
        String destroyMethodName = beanDefinition.getDestroyMethodName();
        // 如果从 beanDefinition.getDestroyMethodName() 得到的destroyName是 INFER_METHOD,那么bean中定义的 close方法或者shutdown 方法都可以作为销毁的方法
        // 但是要注意，这个close,shutdown方法的bean要以@Bean的方式注入到容器中才会生效。因为@Bean中的有默认的 AbstractBeanDefinition.INFER_METHOD destroyName
        if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
            return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) ||
                    ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME));
        }
        return StringUtils.hasLength(destroyMethodName);
    }

 第三个判断：(hasDestructionAwareBeanPostProcessors() &&DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))

                    hasDestructionAwareBeanPostProcessors()： 判断容器中是否有实现DestructionAwareBeanPostProcessor 接口的bean,之前提到的CommonAnnotationBeanPostProcessor继承的InitDestroyAnnotationBeanPostProcessor 便实现了这个接口,

          DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()) 则判断bean中是否有@PreDestroy注解标注的方法。

 public static boolean hasApplicableProcessors(Object bean, List<BeanPostProcessor> postProcessors) {

   if (!CollectionUtils.isEmpty(postProcessors)) {
      for (BeanPostProcessor processor : postProcessors) {
         if (processor instanceof DestructionAwareBeanPostProcessor) {
            DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
            // 这里会走到 之前提到的CommonAnnotationBeanPostProcessor继承的InitDestroyAnnotationBeanPostProcessor 便实现了DestructionAwareBeanPostProcessor这个接口
//  InitDestroyAnnotationBeanPostProcessor#requiresDestruction
if (dabpp.requiresDestruction(bean)) {
               return true;
            }
         }
      }
   }
   return false;
}           

注意点：

这个map的value是Object的，调用的时候把它强转成DisposableBean,然后调用destroy方法，但是我们上面看它注入时候是注入的DisposableBeanAdapter 类。

这里用到了适配器模式。我们看DisposableBeanAdapter 这个类实现了DisposableBeanAdapter 接口。

 所以调用的时候，执行的是DisposableBeanAdapter#destroy, 这个方法会根据不同情况的调用不同的销毁方法。

@Override
    public void destroy() {
        // 执行@PreDestroy方法
        if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
            for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
                processor.postProcessBeforeDestruction(this.bean, this.beanName);
            }
        }
        // bean实现了 DisposableBean 接口而且前面通过后置处理器找到的destroyName不是 "destroy"
        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) 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);
                }
            }
        }
        //  在构造函数中 得到的  destroyName
        if (this.destroyMethod != null) {
            invokeCustomDestroyMethod(this.destroyMethod);
        }
        else if (this.destroyMethodName != null) {
            Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
            if (methodToInvoke != null) {
                invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
            }
        }
    }

构造函数中：

private String  inferDestroyMethodIfNecessary(Object bean, RootBeanDefinition beanDefinition) {
        // 只返回一个值   指定的destroy方法名   close方法   shutdown方法
        // 如果 beanDefinition 中指定了destroy方法，判断是否为默认值 INFER_METHOD
        // 是默认值或者实现了 AutoCloseable接口 走下面的逻辑
        String destroyMethodName = beanDefinition.getDestroyMethodName();
        if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName) ||
                (destroyMethodName == null && bean instanceof AutoCloseable)) {
            // Only perform destroy method inference or Closeable detection
            // in case of the bean not explicitly implementing DisposableBean
            if (!(bean instanceof DisposableBean)) {
                try {
                    return bean.getClass().getMethod(CLOSE_METHOD_NAME).getName();
                }
                catch (NoSuchMethodException ex) {
                    try {
                        return bean.getClass().getMethod(SHUTDOWN_METHOD_NAME).getName();
                    }
                    catch (NoSuchMethodException ex2) {
                        // no candidate destroy method found
                    }
                }
            }
            return null;
        }
        return (StringUtils.hasLength(destroyMethodName) ? destroyMethodName : null);
    }

总结： 

public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
   // 生命周期有关的注解方法封装成 LifecycleMetadata
LifecycleMetadata metadata = findLifecycleMetadata(beanType);
   metadata.checkConfigMembers(beanDefinition);
}

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
   // 判断某个bean是否有销毁的方法
// 1:  实现了Disposable 或者AutoCloseable接口
// 2：  BeanDefinition中定义了destroyMethodName方法
// 类中是否存在@PreDestroy注解的方法
return (bean.getClass() != NullBean.class &&

         (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || (hasDestructionAwareBeanPostProcessors() &&
               DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}

这篇关于spring源码分析(六) 销毁方法，初始化之前的方法加载和执行过程分析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！