【Spring】InitializingBean与 DisposableBean 接口的实现原理（六）

　　关于在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 的实现原理（五）

一、InitializingBean 和 @DisposableBean 接口使用

public class BeanPerson implements InitializingBean, DisposableBean {

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

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

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet()......");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("destroy()......");
    }

}

 二、原理图

　　实现原理是通过代码逻辑判断bean的类型，是否实现的对应的接口

　　

三、InitializingBean 接口实现原理

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

　　其中，判断类bean是否属于InitializingBean接口，然后调用了afterPropertiesSet()方法

四、DisposableBean 接口实现原理

 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、从bean工厂的 disposableBeans 中，获取移除对象，而这个 disposableBeans 销毁对象集合中的对象是从注册的时候来的

　 查看bean创建逻辑: createBeat()->doCreateBeat()，在 doCreateBeat() 调用了registerDisposableBeanIfNecessary() 方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
        throws BeanCreationException {

    // Instantiate the bean.
    // 实例化的bean会封装成一个BeanWrapper对象
    // BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器，
    // 由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        // 移除工厂bean实例缓存，并获取
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化 该方法很复杂也很重要
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 获取包装Bean中的bean实例
    final Object bean = instanceWrapper.getWrappedInstance();
    // 获取包装Bean中的bean的类clazz对象
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        // 在bean定义中设置类clazz对象类型
        mbd.resolvedTargetType = beanType;
    }

    ......

    // Initialize the bean instance.
    // 早起暴露的对象
    Object exposedObject = bean;
    try {
        // 给的属性进行赋值(调用set方法进行赋值)
        populateBean(beanName, mbd, instanceWrapper);
        // 进行对象初始化操作(在这里可能生成代理对象)，调用init方法
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        } else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }
    
    ......

    // Register bean as disposable.
    try {
        // 注册销毁对象
        // 将给定Bean添加到该工厂中的可丢弃Bean列表中，注册器可丢弃Bean接口 和/或
        // 在工厂关闭 时调用给定销毁方法（如果适用）。只适用单例
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

3、注册销毁对象方法：registerDisposableBeanIfNecessary()

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    //     如果有安全管理器器，获取其访问控制上下文
    AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
    // 判断是否是非多例  && 是否需要在关闭时销毁
    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.
            // 注册一个一次性Bean实现来执行给定Bean的销毁工作：DestructionAwareBeanPostProcessors 一次性Bean接口，
            // 自定义销毁方法。
            // DisposableBeanAdapter：实际一次性Bean和可运行接口适配器，对给定Bean实例执行各种销毁步骤
            // 构建Bean对应的DisposableBeanAdapter对象，与beanName绑定到 注册中心的一次性Bean列表中
            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));
        }
    }
}

4、其中调用了registerDisposableBean() 方法，并且把原对象和一些其他信息封装成了一个DisposableBeanAdapter对象，放入了工厂的 disposableBeans 集合中

// 注册需要销毁的是实例
public void registerDisposableBean(String beanName, DisposableBean bean) {
    synchronized (this.disposableBeans) {
        this.disposableBeans.put(beanName, bean);
    }
}

5、销毁时，从disposableBeans 获取对象，继续从1步骤的 destroyBean() 方法，往下走

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

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

　　可以看到其中，判断是否实现DisposableBean接口，然后调用了 ((DisposableBean) this.bean).destroy();

　　this.bean 即是封装前原实例对象，即调用了原实例对象的 destroy() 方法