spring源码学习：ApplicationListener监听器添加到disposableBeans过程

disposableBeans缓存作用

主要是在后续bean销毁时执行销毁前的一些指定操作对于自定义的ApplicationListener主要是执行ApplicationListenerDetector的一些方法

源码解析

进入到AnnotationConfigApplicationContext的refresh

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //执行一些准备工作其中包括添加部分后置处理器，包括ApplicationListenerDetector
            this.prepareBeanFactory(beanFactory);

进入prepareBeanFactory

...
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        //添加ApplicationListener的后置处理器
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        if (!IN_NATIVE_IMAGE && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
        ...

关于ApplicationListenerDetector的继承结构如下

可见实现自BeanPostProcessor接口
之后debug到this.finishBeanFactoryInitialization(beanFactory)

可以看到此时beanFactory中已经注册了ApplicationListenerDetector但是disposableBeans还未缓存ApplicationListener
继续进入finishBeanFactoryInitialization(beanFactory)`

...
beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
        //完成disposableBeans的缓存
        beanFactory.preInstantiateSingletons();

进入preInstantiateSingletons()

 if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
                    
					//获取自定义的监听器也即是在创建bean
                    this.getBean(beanName);
                }

进入到doGetBean

if (mbd.isSingleton()) {
					//通过回调函数完成监听器bean创建
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });

进入到doCreateBean,在完成实例创建、属性填充和初始化之后会进行如下过程

try {
			//该方法就是添加监听器到disposableBeans
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }

registerDisposableBeanIfNecessary主要逻辑如下

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = System.getSecurityManager() != null ? this.getAccessControlContext() : null;
        //判断是否时原型对象和是否需要执行销毁操作
        if (!mbd.isPrototype() && this.requiresDestruction(bean, mbd)) {
        	//满足之后判断是否为单例
            if (mbd.isSingleton()) {
            	//执行真正的添加到disposableBeans存操作
                this.registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, this.getBeanPostProcessorCache().destructionAware, acc));
            } else {
                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, this.getBeanPostProcessorCache().destructionAware, acc));
            }
        }

    }

requiresDestruction判断逻辑

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
        return 
        bean.getClass() != NullBean.class && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd) || this.hasDestructionAwareBeanPostProcessors() && DisposableBeanAdapter.hasApplicableProcessors(bean, this.getBeanPostProcessorCache().destructionAware));
    }

1 首先判断是否是否为NullBean类型，再判断hasDestroyMethod逻辑如下

//是否为DisposableBean或者AutoCloseable
if (!(bean instanceof DisposableBean) && !(bean instanceof AutoCloseable)) {
			//destroyMethodName是否存在，和是否包含close或者shutdown方法
            String destroyMethodName = beanDefinition.getDestroyMethodName();
            if (!"(inferred)".equals(destroyMethodName)) {
                return StringUtils.hasLength(destroyMethodName);
            } else {
                return ClassUtils.hasMethod(bean.getClass(), "close", new Class[0]) || ClassUtils.hasMethod(bean.getClass(), "shutdown", new Class[0]);
            }
        } else {
            return true;
        }

2 判断hasDestructionAwareBeanPostProcessors是否存在销毁处理器

可看出销毁处理器有两个，包括监听器的处理器

3 判断 DisposableBeanAdapter.hasApplicableProcessors(bean, this.getBeanPostProcessorCache().destructionAware)也即当前bean是否有合适的销毁处理器

public static boolean hasApplicableProcessors(Object bean, List<DestructionAwareBeanPostProcessor> postProcessors) {
        if (!CollectionUtils.isEmpty(postProcessors)) {
            Iterator var2 = postProcessors.iterator();

            while(var2.hasNext()) {
            	//判断逻辑
                DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var2.next();
                //该逻辑为return (bean instanceof ApplicationListener);
                if (processor.requiresDestruction(bean)) {
                    return true;
                }
            }
        }

        return false;
    }

4 从而通过上述判断我们自定义的监听器符合条件会执行registerDisposableBean(代码加入到缓存中

synchronized(this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }

ApplicationListenerDetector

主要是在监听器被注销时执行如下操作

public void postProcessBeforeDestruction(Object bean, String beanName) {
        if (bean instanceof ApplicationListener) {
            try {
                ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
                //销毁前通过事件广播器移除监听器和对应存储的bean名字
                multicaster.removeApplicationListener((ApplicationListener)bean);
                multicaster.removeApplicationListenerBean(beanName);
            } catch (IllegalStateException var4) {
            }
        }

    }