spring源码（十七）--DefaultSingletonBeanRegistry

最新推荐文章于 2025-01-17 14:51:46 发布

ljz2016

最新推荐文章于 2025-01-17 14:51:46 发布

阅读量336

点赞数

CC 4.0 BY-SA版权

分类专栏： spring源码解析

本文链接：https://blog.youkuaiyun.com/ljz2016/article/details/85625624

spring源码解析专栏收录该内容

21 篇文章

订阅专栏

本文深入探讨Spring框架中单例对象的管理机制，包括singletonObjects等四个集合容器的作用，以及如何通过这些容器实现单例实例的存储与销毁。文章详细解析了destroySingletons方法的工作流程，展示了如何遍历并销毁所有单例bean，同时清理相关依赖关系。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

singletonObjects存储了所有的单例实例，k-v: name-ref。

4个集合容器用来存储实例

 private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
    private final Map<String, Object> earlySingletonObjects = new HashMap(16);
    private final Set<String> registeredSingletons = new LinkedHashSet(256);

销毁所有的实例，销毁时把实例从容器中移除。都是用singletonObjects来同步

 public void destroySingletons() {

        synchronized(this.singletonObjects) {
            this.singletonsCurrentlyInDestruction = true;
        }

        String[] disposableBeanNames;
        synchronized(this.disposableBeans) {
            disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
        }

        for(int i = disposableBeanNames.length - 1; i >= 0; --i) {
            this.destroySingleton(disposableBeanNames[i]);
        }

        this.containedBeanMap.clear();
        this.dependentBeanMap.clear();
        this.dependenciesForBeanMap.clear();
        this.clearSingletonCache();
    }

dependentBeanMap保存每个bean所依赖的beanName的集合，如果发现有依赖，则递归清除依赖。

protected void destroyBean(String beanName, DisposableBean bean) {
        Map var4 = this.dependentBeanMap;
        Set dependencies;
        synchronized(this.dependentBeanMap) {//处理依赖
            dependencies = (Set)this.dependentBeanMap.remove(beanName);
        }

        if(dependencies != null) {
            Iterator var14 = dependencies.iterator();

            while(var14.hasNext()) {
                String dependentBeanName = (String)var14.next();
                this.destroySingleton(dependentBeanName);
            }
        }

        if(bean != null) {
            try {
                bean.destroy();//bean是一次性的，则调用相应的销毁方法。
            } catch (Throwable var13) {
            }
        }

        Map var16 = this.containedBeanMap;
        Set containedBeans;
        synchronized(this.containedBeanMap) {//和上面一样
            containedBeans = (Set)this.containedBeanMap.remove(beanName);
        }

        if(containedBeans != null) {
            Iterator var17 = containedBeans.iterator();

            while(var17.hasNext()) {
                String containedBeanName = (String)var17.next();
                this.destroySingleton(containedBeanName);
            }
        }

        var16 = this.dependentBeanMap;
        synchronized(this.dependentBeanMap) {
            Iterator it = this.dependentBeanMap.entrySet().iterator();

            while(it.hasNext()) {
                Map.Entry<String, Set<String>> entry = (Map.Entry)it.next();
                Set<String> dependenciesToClean = (Set)entry.getValue();
                dependenciesToClean.remove(beanName);
                if(dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        this.dependenciesForBeanMap.remove(beanName);
    }

移除bean时，会把它依赖的bean也移除，包含的也移除，同时也会从依赖它的bean中去除对它的依赖。