【Spring】配置initMethod 与 配置destroyMethod 的实现原理（七）

　　关于在Spring 容器 初始化和销毁 bean 前所做的操作有三种方式定义：

• 第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化后和销毁bean之前进行的操作

• 第二种：通过bean实现InitializingBean和 DisposableBean接口

• 第三种：通过 在xml中配置init-method 和 destory-method方法，或者 配置@Bean(initMethod = "initMethod", destroyMethod = "destroyMethod") 注解

　　执行顺序：@PostConstruct -> InitializingBean -> 配置initMethod -> @PreDestroy -> DisposableBean -> 配置destroyMethod

　　本章介绍第一种

　　第一种见：【Spring】@PostConstruct 与 @PreDestroy 的实现原理（五）

　　第二种见：【Spring】InitializingBean与 DisposableBean 接口的实现原理（六）

一、配置initMethod 与 配置destroyMethod 方法

1、BeanPerson类

public class BeanPerson {

    public void say(String word) {
        System.out.println("Hello, " + word);
    }

    public BeanPerson() {
        System.out.println("BeanPerson() ");
    }

    public void initMethod(){
        System.out.println("initMethod()....");
    }

    public void destroyMethod(){
        System.out.println("destroyMethod()....");
    }
}

2、xml配置

<bean id="person" class="com.test.ioc.BeanPerson" init-method="initMethod" destroy-method="destroyMethod"></bean>　　 

3、@Bean注解配置

@Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")

二、原理图

　　

三、配置initMethod 方法实现原理

1、实例化bean时，createBeat()->doCreateBeat()->initializeBean()

　　初始化 initializeBean() 方法如下：

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    } else {
        // 若bean实现了XXXAware接口进行方法的回调
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 支持初始化前bean的后置处理器
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 调用初始化方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    } catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

2、其中调用了初始化方法 invokeInitMethods() ，如下：

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {
    // 判断容器中是否实现了InitializingBean接口
    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接口的afterPropertiesSet()方法
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }

    if (mbd != null && bean.getClass() != NullBean.class) {
        // bean定义中看是否有配置的init方法
        String initMethodName = mbd.getInitMethodName();
        // 判断自定义的init方法名称不叫afterPropertiesSet
        if (StringUtils.hasLength(initMethodName) &&
                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 调用配置的初始化方法
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

3、invokeCustomInitMethod() 调用配置的初始化方法

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    // 从bean定义中获取初始化方法名称
    String initMethodName = mbd.getInitMethodName();
    Assert.state(initMethodName != null, "No init method set");
    // 获得初始化方法
    Method initMethod = (mbd.isNonPublicAccessAllowed() ?
            BeanUtils.findMethod(bean.getClass(), initMethodName) :
            ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));

    if (initMethod == null) {
        if (mbd.isEnforceInitMethod()) {
            throw new BeanDefinitionValidationException("Could not find an init method named '" +
                    initMethodName + "' on bean with name '" + beanName + "'");
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("No default init method named '" + initMethodName +
                        "' found on bean with name '" + beanName + "'");
            }
            // Ignore non-existent default lifecycle methods.
            return;
        }
    }

    if (logger.isTraceEnabled()) {
        logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
    }
    Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);

    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(methodToInvoke);
            return null;
        });
        try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
                    methodToInvoke.invoke(bean), getAccessControlContext());
        } catch (PrivilegedActionException pae) {
            InvocationTargetException ex = (InvocationTargetException) pae.getException();
            throw ex.getTargetException();
        }
    } else {
        try {
            ReflectionUtils.makeAccessible(methodToInvoke);
            // 调用对象的初始化方法
            methodToInvoke.invoke(bean);
        } catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

　　注：bean定义的初始化方法名称，是在Spring解析的时候，通过判断注解或xml配置的到的，同时解析也会把销毁方法名称，放到bean定义中

四、配置destroyMethod 方法实现原理

 1、在容器关闭时，调用方法链：context.clonse() -> doClose() -> destroyBeans() -> destroySingletons() ->destroySingleton()

　　销毁单例方法 destroySingleton() 如下：

public void destroySingleton(String beanName) {
    // Remove a registered singleton of the given name, if any.
    // 移除缓存
    removeSingleton(beanName);

    // Destroy the corresponding DisposableBean instance.
    DisposableBean disposableBean;
    // 加锁
    synchronized (this.disposableBeans) {
        // 根据名称，从需要销毁的是实例集合移除实例，得到disposableBean
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    // 销毁bean
    destroyBean(beanName, disposableBean);
}

2、销毁时，从disposableBeans 获取对象（对象是在bean创建的时候，放入的，具体见上一篇）

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
        // Trigger destruction of dependent beans first...
        Set<String> dependencies;
        // 移除依赖
        synchronized (this.dependentBeanMap) {
            // Within full synchronization in order to guarantee a disconnected Set
            dependencies = this.dependentBeanMap.remove(beanName);
        }
        if (dependencies != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
            }
            for (String dependentBeanName : dependencies) {
                destroySingleton(dependentBeanName);
            }
        }

        // Actually destroy the bean now...
        // 现在真正销毁
        if (bean != null) {
            try {
                // 调用销毁方法
                bean.destroy();
            }
            catch (Throwable ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
                }
            }
        }

        // Trigger destruction of contained beans...
        Set<String> containedBeans;
        synchronized (this.containedBeanMap) {
            // Within full synchronization in order to guarantee a disconnected Set
            containedBeans = this.containedBeanMap.remove(beanName);
        }
        if (containedBeans != null) {
            for (String containedBeanName : containedBeans) {
                destroySingleton(containedBeanName);
            }
        }

        // Remove destroyed bean from other beans' dependencies.
        synchronized (this.dependentBeanMap) {
            for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
                Map.Entry<String, Set<String>> entry = it.next();
                Set<String> dependenciesToClean = entry.getValue();
                dependenciesToClean.remove(beanName);
                if (dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        // Remove destroyed bean's prepared dependency information.
        // 移除依赖关系集中对象
        this.dependenciesForBeanMap.remove(beanName);
    }

3、bean.destroy() 方法， 这里的bean对象是 DisposableBeanAdapter对象 如下：

// 销毁
@Override
public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
            // 调持销毁前bean的后置处理器
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }

    // 判断是否实现DisposableBean接口
    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 {
                // 强转，调用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);
            }
        }
    }

    if (this.destroyMethod != null) {
        // 调用配置的销毁方法
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
        if (methodToInvoke != null) {
            // 调用配置的销毁方法
            invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
        }
    }
}

4、其中invokeCustomDestroyMethod() 方法，调用了对象的销毁方法

private void invokeCustomDestroyMethod(final Method destroyMethod) {
    // 销毁方法参数数量
    int paramCount = destroyMethod.getParameterCount();
    final Object[] args = new Object[paramCount];
    if (paramCount == 1) {
        args[0] = Boolean.TRUE;
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Invoking destroy method '" + this.destroyMethodName +
                "' on bean with name '" + this.beanName + "'");
    }
    try {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                ReflectionUtils.makeAccessible(destroyMethod);
                return null;
            });
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
                    destroyMethod.invoke(this.bean, args), this.acc);
            }
            catch (PrivilegedActionException pax) {
                throw (InvocationTargetException) pax.getException();
            }
        }
        else {
            ReflectionUtils.makeAccessible(destroyMethod);
            // 调用对象的销毁方法
            destroyMethod.invoke(this.bean, args);
        }
    }
    catch (InvocationTargetException ex) {
        String msg = "Destroy method '" + this.destroyMethodName + "' on bean with name '" +
                this.beanName + "' threw an exception";
        if (logger.isDebugEnabled()) {
            logger.warn(msg, ex.getTargetException());
        }
        else {
            logger.warn(msg + ": " + ex.getTargetException());
        }
    }
    catch (Throwable ex) {
        logger.warn("Failed to invoke destroy method '" + this.destroyMethodName +
                "' on bean with name '" + this.beanName + "'", ex);
    }
}