spring学习之源码分析DefaultSingletonBeanRegistry

共计 13644 个字符，预计需要花费 35 分钟才能阅读完成。

DefaultSingletonBeanRegistry 类继承了 SimpleAliasRegistry 以及实现了 SingletonBeanRegistry 的接口。处理 Bean 的注册, 销毁, 以及依赖关系的注册和销毁。

截取部分

// 单例对象的缓存: 从 beanname 到 bean 实例
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 单例工厂的缓存: 从 beanname 到 ObjectFactory
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 早期单例对象的缓存: 从 beanname 到 bean 实例
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 一组已注册的单例，包含按注册顺序排列的 beanname
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
// 正在创建的单例的 beanName 的集合
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 当前不检查的 bean 的集合
private final Set<String> inCreationCheckExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 异常集合
private Set<Exception> suppressedExceptions;
// 当前是否在销毁 bean 中
private boolean singletonsCurrentlyInDestruction = false;
// 一次性 bean 实例
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
// 内部 bean 和外部 bean 之间关系
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
// 指定 bean 与依赖指定 bean 的集合，比如 bcd 依赖 a，那么就是 key 为 a，bcd 为 value
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
// 指定 bean 与指定 bean 依赖的集合，比如 a 依赖 bcd，那么就是 key 为 a，bcd 为 value
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

通过 bean 的名称和对象进行注册。

public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {Assert.notNull(beanName, "Bean name must not be null");
    Assert.notNull(singletonObject, "Singleton object must not be null");
    synchronized (this.singletonObjects) {Object oldObject = this.singletonObjects.get(beanName);
        // 如果缓存有，说明已经注册过
        if (oldObject != null) {
            throw new IllegalStateException("Could not register object [" + singletonObject +
                    "] under bean name'" + beanName + "': there is already object [" + oldObject + "] bound");
        }
        // 缓存没有，开始注册
        addSingleton(beanName, singletonObject);
    }
}

单例加入到缓存中

protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {
        // 加入单例对象的缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 既然加入了单例对象的缓存，那 singletonFactories 和 earlySingletonObjects 就不再持有
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        // 加入已注册的 bean
        this.registeredSingletons.add(beanName);
    }
}

// 增加单例工程的单例，取单例的时候调用 getObject 方法
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

public Object getSingleton(String beanName) {return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 如果缓存有直接返回
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 缓存没有的情况且正在创建
        synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);// 如果早期缓存中有，直接返回
            if (singletonObject == null && allowEarlyReference) {//allowEarlyReference 允许是否从 singletonFactories 读取
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {// 如果单例工程有，调用 getObject 方法返回
                    singletonObject = singletonFactory.getObject();
                    // singletonFactories 产生的对象放入 earlySingletonObjects 中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    // 已经产生过一次对象了，所以就不能再用了，后面直接用 earlySingletonObjects 获取
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // 当前在销毁 bean，不能创建
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while singletons of this factory are in destruction" +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {logger.debug("Creating shared instance of singleton bean'" + beanName + "'");
            }
            // 创建前检查
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            // 如果当前没有异常，初始化异常集合
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                // 通过 ObjectFactory 的 getObject 创建 bean
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                // 有可能是其他方式创建的 bean
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {throw ex;}
            }
            catch (BeanCreationException ex) {if (recordSuppressedExceptions) {for (Exception suppressedException : this.suppressedExceptions) {ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {if (recordSuppressedExceptions) {this.suppressedExceptions = null;}
                // 创建后检查
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 是新创建的 bean，就加入到缓存中，如果是其他方式创建的 bean，说明已经加入过缓存了，这边不再加入
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

注册过程中发生的异常，加入到异常集合

protected void onSuppressedException(Exception ex) {synchronized (this.singletonObjects) {if (this.suppressedExceptions != null) {this.suppressedExceptions.add(ex);
        }
    }
}

移除单例，这四个同时移除

protected void removeSingleton(String beanName) {synchronized (this.singletonObjects) {this.singletonObjects.remove(beanName);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.remove(beanName);
    }
}

singletonObjects、registeredSingletons 的信息读取

@Override
public boolean containsSingleton(String beanName) {
    // 是否已经缓存过
    return this.singletonObjects.containsKey(beanName);
}

@Override
public String[] getSingletonNames() {
    // 获取已经注册过的 bean
    synchronized (this.singletonObjects) {return StringUtils.toStringArray(this.registeredSingletons);
    }
}

@Override
public int getSingletonCount() {
    // 获取单例的个数
    synchronized (this.singletonObjects) {return this.registeredSingletons.size();
    }
}

设置不检查的 beanName

public void setCurrentlyInCreation(String beanName, boolean inCreation) {Assert.notNull(beanName, "Bean name must not be null");
    if (!inCreation) {this.inCreationCheckExclusions.add(beanName);
    }
    else {this.inCreationCheckExclusions.remove(beanName);
    }
}

是否当前创建的 bean

public boolean isCurrentlyInCreation(String beanName) {Assert.notNull(beanName, "Bean name must not be null");
    // 如果这个 beanName 在不检查集合里，返回 false，说明当前没有创建
    // 如果这个 beanName 要检查，那就要返回是否是正在创建的 bean
    return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
}
protected boolean isActuallyInCreation(String beanName) {return isSingletonCurrentlyInCreation(beanName);
}
public boolean isSingletonCurrentlyInCreation(String beanName) {return this.singletonsCurrentlyInCreation.contains(beanName);
}

protected void beforeSingletonCreation(String beanName) {
    // 如果这个 beanName 要检查，看看 add 的时候返回什么，如果返回 false，说明已经在创建了，抛异常
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {throw new BeanCurrentlyInCreationException(beanName);
    }
}

protected void afterSingletonCreation(String beanName) {
    // 如果这个 beanName 要检查，看看 remove 返回什么，如果返回 false，说明已经创建完了。if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {throw new IllegalStateException("Singleton'" + beanName + "'isn't currently in creation");
    }
}

注册一次性 bean 实例

public void registerDisposableBean(String beanName, DisposableBean bean) {synchronized (this.disposableBeans) {this.disposableBeans.put(beanName, bean);
    }
}

public void registerContainedBean(String containedBeanName, String containingBeanName) {synchronized (this.containedBeanMap) {
        // 如果没有 key 为 containingBeanName 的 value，说明内部 bean 集合为空，则初始化一个
        Set<String> containedBeans =
                this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
        // 如果已经存在了对应关系，则直接返回，不存在，就添加对应关系
        if (!containedBeans.add(containedBeanName)) {return;}
    }
    registerDependentBean(containedBeanName, containingBeanName);
}

canonicalName 方法是属于 SimpleAliasRegistry 的方法。

public void registerDependentBean(String beanName, String dependentBeanName) {String canonicalName = canonicalName(beanName);

    synchronized (this.dependentBeanMap) {
        Set<String> dependentBeans =
                this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        // 如果已经存在了对应关系，则直接返回, 不存在，就添加对应关系
        if (!dependentBeans.add(dependentBeanName)) {return;}
    }

    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean =
                this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        // 添加对应关系
        dependenciesForBean.add(canonicalName);
    }
}

dependentBeanName 是否依赖 beanName

protected boolean isDependent(String beanName, String dependentBeanName) {synchronized (this.dependentBeanMap) {return isDependent(beanName, dependentBeanName, null);
    }
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {if (alreadySeen != null && alreadySeen.contains(beanName)) {return false;}
    String canonicalName = canonicalName(beanName);
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // 为空，说明没有 bean 依赖 beanName，直接返回 false
    if (dependentBeans == null) {return false;}
    // 有其他 bean 依赖 beanName，且包含了 dependentBeanName，返回 true
    if (dependentBeans.contains(dependentBeanName)) {return true;}
    // 有其他 bean 依赖 beanName，但是不包含 dependentBeanName
    for (String transitiveDependency : dependentBeans) {if (alreadySeen == null) {alreadySeen = new HashSet<>();
        }
        alreadySeen.add(beanName);
        // 是否有循环依赖
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {return true;}
    }
    return false;
}

是否有其他对象依赖指定 bean

protected boolean hasDependentBean(String beanName) {return this.dependentBeanMap.containsKey(beanName);
}

返回依赖指定 bean 的数组

public String[] getDependentBeans(String beanName) {Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
    if (dependentBeans == null) {return new String[0];
    }
    synchronized (this.dependentBeanMap) {return StringUtils.toStringArray(dependentBeans);
    }
}

返回指定 bean，依赖其他 bean 的数组

public String[] getDependenciesForBean(String beanName) {Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
    if (dependenciesForBean == null) {return new String[0];
    }
    synchronized (this.dependenciesForBeanMap) {return StringUtils.toStringArray(dependenciesForBean);
    }
}

销毁单例

public void destroySingletons() {if (logger.isTraceEnabled()) {logger.trace("Destroying singletons in" + this);
    }
    // 设置当前正在销毁
    synchronized (this.singletonObjects) {this.singletonsCurrentlyInDestruction = true;}

    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    // 销毁 disposableBeans 中的所有 bean
    for (int i = disposableBeanNames.length - 1; i >= 0; i--) {destroySingleton(disposableBeanNames[i]);
    }
    // 清空 containedBeanMap、dependentBeanMap、dependenciesForBeanMap
    this.containedBeanMap.clear();
    this.dependentBeanMap.clear();
    this.dependenciesForBeanMap.clear();
    // 清除单例缓存
    clearSingletonCache();}

清除单例缓存

protected void clearSingletonCache() {synchronized (this.singletonObjects) {this.singletonObjects.clear();
        this.singletonFactories.clear();
        this.earlySingletonObjects.clear();
        this.registeredSingletons.clear();
        // 清除完后，标志恢复为 false
        this.singletonsCurrentlyInDestruction = false;
    }
}

销毁单例 bean

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) {
        // 从 disposableBeans 移除，如果有 beanName 对应的对象，返回这个对象
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    // 消耗 bean
    destroyBean(beanName, disposableBean);
}

消耗 bean

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

    // Actually destroy the bean now...
    if (bean != null) {
        try {
            // 销毁 bean
            bean.destroy();}
        catch (Throwable ex) {if (logger.isInfoEnabled()) {logger.info("Destroy method on bean with name'" + beanName + "'threw an exception", ex);
            }
        }
    }

    // Trigger destruction of contained beans...
    // 异常 beanName 的对应关系的 bean
    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.
    // 这个对象被其他 bean 依赖，也要移除依赖关系
    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);
            // 如果除了当前的 beanName，没有其他依赖了，直接删除
            if (dependenciesToClean.isEmpty()) {it.remove();
            }
        }
    }

    // Remove destroyed bean's prepared dependency information.
    // 移除当前 bean 与依赖其他 bean 的关系
    this.dependenciesForBeanMap.remove(beanName);
}

用于加锁操作，返回 singletonObjects，通过方法暴露这个对象。

public final Object getSingletonMutex() {return this.singletonObjects;}

DefaultSingletonBeanRegistry

类结构

常量

方法解析

registerSingleton

addSingleton

addSingletonFactory

getSingleton

onSuppressedException

removeSingleton

containsSingleton

getSingletonNames

getSingletonCount

setCurrentlyInCreation

isCurrentlyInCreation

isActuallyInCreation

isSingletonCurrentlyInCreation

beforeSingletonCreation

afterSingletonCreation

registerDisposableBean

registerContainedBean

registerDependentBean

isDependent

hasDependentBean

getDependentBeans

getDependenciesForBean

destroySingletons

clearSingletonCache

destroySingleton

destroyBean

getSingletonMutex

Just My Socks（注册教程内含优惠码）