Spring源码之路-DefaulListableBeanFactory
- DefaultSingletonBeanRegistry总结
- 源码注释的大概翻译
DefaultSingletonBeanRegistry总结
- 这个类继承了SimpleAliasRegistry并且实现了SingletonBeanRegistry，那么说明此类拥有了给Bean起别名以及单例Bean注册的相关功能，此类主要是实现了单例Bean注册的功能
- 当前单例Bean在注册的时候有几个比较关键的属性来做Bean的生命周期状态的转换
singletonObjects保存的是实力化过后的单例BeansingletonFactories保存的是单例的Bean的Bean工厂，在当前成员属性中存在的，肯定在singletonObjects中没有(解决循环依赖，通过它向外暴露)earlySingletonObjects这个成员属性存放的是已经实例化后的Bean对象，但此时还没有完全准备好，不能被外部使用的Bean。(解决循环依赖，通过它向外暴露)registeredSingletons已经注册过的单例Bean的名字的集合
- 单例Bean实例化过程中，上面的4个成员属性的变化，由如下方法影响:
protected void addSingleton(String beanName, Object singletonObject)这个方法是最终将实例化过后并且已经完全就绪的Bean添加到singletonObjects这个成员属性中的方法，并且还会将Bean的名称添加到registeredSingletons中，只要在这两个成员变量中存在，那么此时的Bean就是已经完全就绪，可以使用的Bean，这个方法的实现是可以被多次调用，如果两个Bean的名字一样，后面的Bean会覆盖前面添加进来的Bean。但是这个protected的，应该来说提供给子类注册使用的public void registerSingleton(String beanName, Object singletonObject)这个方法是SingletonBeanRegistry接口中的一个方法，但底层就是调用protected void addSingleton(String beanName, Object singletonObject)这个方法，只不过这里面做了个判断，就是如果相同的Bean名称已经注册过了，那么这里就会抛出异常protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory)这个方法是注册一个ObjectFactory对象，他会将Bean的名称和ObjectFactory对象存入到singletonFactories这个成员属性中，并且也会向registeredSingletons这个成员属性中将Bean的名称加入进去。
- 先说下循环依赖的问题，比如说，如果我们当前正在创建一个BeanA，BeanA已经实例化结束了，那么这个时候，他里面有需要自动注入BeanB这个对象，这个时候又去实例化需要注入的BeanB，在实例化完BeanB以后，BeanB又需要注入的BeanA，这个时候BeanA和BeanB就产生了循环依赖的问题。
- spring的解决方案，当在容器中获取BeanA的时候，会先去
singletonObjects中找，没有，再去earlySingletonObjects里面找，没有，再去singletonFactories里面找，这个里面也没有，那么这个时候开始创建实例化BeanA，实例化完毕后，判断如果当前BeanA正在创建，会调用这个方法将当前已经实例化过但是还没有完全准备完毕的BeanA通过ObjectFactory接口的getObject()方法包装，调用protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory)方法将这个对象存到singletonFactories这个属性中，然后开始进行属性装配或者是实例化依赖的对象，假如这时候BeanA依赖于BeanB，这个时候会去容器中获取BeanB，BeanB会执行相同的过程，会先去singletonObjects中找，没有，然后去earlySingletonObjects中找，还没有，再去singletonFactories里面找，找到以后就调用getObject()方法获取到BeanA对象，然后会删除singletonFactories中的BeanA的ObjectFactory，将获取到的BeanA对象引用存入earlySingletonObjects中，并返回BeanA对象引用，这个时候就会将已经实例化但是还没有完全准备好的BeanA注入进来，等BeanB完全准备好以后，再将BeanB注入到BeanA中，这样就解决了循环依赖的问题
- 上述的创建Bean前的查找过程，就是调用了当前类的
public Object getSingleton(String beanName)，这个方法又调用了protected Object getSingleton(String beanName, boolean allowEarlyReference)，这个方法里面就是上面的查找的逻辑。
- 上面操作只要是注册或者添加，都会向
registeredSingletons这个成员属性写入数据，则它保存的是所有单例Bean的名称，不管是初始化好还是没有初始化好的。
- 获取单例Bean的入口方法是
public Object getSingleton(String beanName, ObjectFactory singletonFactory)，如果子类要获取单例的Bean则需要调用这个方法，因为这个方法里面有保存，对象在创建过程中的状态。例如：上面说的解决循环依赖的问题的时候，判断BeanA是否正在创建public boolean isSingletonCurrentlyInCreation(String beanName)的方法，其实是判断当前类中的singletonsCurrentlyInCreation这个成员属性的集合中是否包含BeanA这个名字，BeanA这个名字就是在public Object getSingleton(String beanName, ObjectFactory singletonFactory)这个入口方法中添加的
源码注释的大概翻译
/**
* 共享bean实例的通用注册表，实现
* {@link org.springframework.beans.factory.config.SingletonBeanRegistry}。
* 允许注册应该由bean名称获得的所有注册表调用者共享的单例实例。
* 还支持 {@link org.springframework.beans.factory.DisposableBean}实例
* （可能对应 或可能不对应已注册的单例）的注册，在注册表关闭时销毁。
* 可以注册 bean 之间的依赖关系以强制执行适当的关闭命令。
*
* 此类主要用作{@link org.springframework.beans.factory.BeanFactory}
* 实现的基类，从而排除了单例bean实例的常见管理。请注意，
* {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}
* 接口扩展了{@link SingletonBeanRegistry}接口。
*
* 请注意，与{{link AbstractBeanFactory}和{@link DefaultListableBeanFactory}
* （从其继承）相比，该类既不假设beanDefinition概念也不为bean实例指定创建过
* 程。也可以用作委托的嵌套助手。
* @author Juergen Hoeller
* @since 2.0
* @see #registerSingleton
* @see #registerDisposableBean
* @see org.springframework.beans.factory.DisposableBean
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/ **要保留的最大抑制异常数。 * /
private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;
/ **单例对象的缓存：bean名称到bean实例。 * /
private final Map singletonObjects = new ConcurrentHashMap<>(256);
/ **单例工厂的高速缓存：Bean名称为ObjectFactory。 * /
private final Map> singletonFactories = new HashMap<>(16);
/ **早期的单例对象的高速缓存：bean名称到bean实例。 * /
private final Map earlySingletonObjects = new HashMap<>(16);
/ **已注册的单例集，按注册顺序包含Bean名称。 * /
private final Set registeredSingletons = new LinkedHashSet<>(256);
/ **当前正在创建的bean的名称。 * /
private final Set singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/ **当前在创建检查中排除的bean名称。 * /
private final Set inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/ **收集抑制的异常，可用于关联相关原因。 * /
@Nullable
private Set suppressedExceptions;
/ **标志，指示我们当前是否在destroySingletons中。 * /
private boolean singletonsCurrentlyInDestruction = false;
/ ** 需要被销毁bean实例：Bean名称到Bean实例。 * /
private final Map disposableBeans = new LinkedHashMap<>();
/ **在包含的bean名称之间映射：bean name到bean包含的bean名称集。 * /
private final Map> containedBeanMap = new ConcurrentHashMap<>(16);
/ **在依赖bean名称之间映射：bean name到相关bean名称的集合。 * /
private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);
/ **在相关的Bean名称之间映射：Bean名称到Bean依赖项的Bean名称集。 * /
private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
@Override
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);
}
}
/**
* 将给定的单例对象添加到该工厂的单例缓存中。
* 被要求进行单例的Bean的登记。
* @param beanName Bean的名称
* @param singletonObject 单例Bean的实例
*/
protected void addSingleton(String beanName, Object singletonObject) {
// ***** 这里添加单例Bean的时候 跟当前Bean相关的状态容器需要同步更新 ****
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
/**
* 如有必要，添加给定的单例工厂以构建指定的单例。
* 被要求进行单身者的紧急注册，例如能够解析循环引用。
* resolve circular references.
* @param beanName Bean的名称
* @param singletonFactory 创建单例Bean的工厂
*/
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);
}
}
}
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* 返回以给定名称注册的（原始）单例对象。
* <检查已经实例化的单例，并且还允许对当前创建的单例的早期引用（解析循环引用）。
* @param beanName 要查找的bean的名称
* @param allowEarlyReference 是否应创建早期引用
* @return 返回注册的单例对象，如果找不到则返回{@code null}
*/
@Nullable
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) {
ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
/**
* 返回以给定名称注册的（原始）单例对象，
* 如果尚未注册，则创建并注册一个新对象。
* @param beanName bean的名称
* @param singletonFactory 如果有必要的话，要懒惰地创建单例的ObjectFactory
* @return 返回注册的单例对象
*/
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) {
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 {
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.
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) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
/**
* 注册一个在创建单例bean实例期间碰巧被抑制的异常，例如临时循环参考解析问题。
* 默认实现保留此注册表的抑制异常集合中的任何给定异常，最多100个异常，并将它
* 们作为相关原因添加到最终的顶级{@link BeanCreationException}中。
* @param ex 表示要注册的异常
* @see BeanCreationException#getRelatedCauses()
*/
protected void onSuppressedException(Exception ex) {
synchronized (this.singletonObjects) {
if (this.suppressedExceptions != null && this.suppressedExceptions.size() < SUPPRESSED_EXCEPTIONS_LIMIT) {
this.suppressedExceptions.add(ex);
}
}
}
/**
* 从该工厂的单例缓存中删除具有给定名称的Bean，
* 如果创建失败，则能够清理急于注册的单例。
* @param beanName bean的名称
* @see #getSingletonMutex()
*/
protected void removeSingleton(String beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
}
@Override
public boolean containsSingleton(String beanName) {
return this.singletonObjects.containsKey(beanName);
}
@Override
public String[] getSingletonNames() {
synchronized (this.singletonObjects) {
return StringUtils.toStringArray(this.registeredSingletons);
}
}
@Override
public int getSingletonCount() {
synchronized (this.singletonObjects) {
return this.registeredSingletons.size();
}
}
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);
}
}
public boolean isCurrentlyInCreation(String beanName) {
Assert.notNull(beanName, "Bean name must not be null");
return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
}
protected boolean isActuallyInCreation(String beanName) {
return isSingletonCurrentlyInCreation(beanName);
}
/**
* 返回指定的单例bean当前是否在创建中在整个工厂内）
* @param beanName bean的名称
*/
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
/**
* 创建单例之前的回调。默认实现将单例注册为当前正在创建中。
* @param beanName 要创建的单例的名称
* @see #isSingletonCurrentlyInCreation
*/
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
/**
* 创建单例后的回调。
* 默认实现将单例标记为不在创建中。
* @param beanName 已创建的单例的名称
* @see #isSingletonCurrentlyInCreation
*/
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
/**
* 将给定的bean添加到此注册表中的disposableBeans列表中。
* DisposableBean通常对应于注册的单例，匹配Bean名称，但可能是不同的实例
* 有一个适配类DisposableBeanAdapter，该Bean实例可以不直接实现DisposableBean接口
* 通过对DisposableBeanAdapte适配器模式，间接的实现DisposableBean接口
* @param beanName bean的名称
* @param bean bean的实例
*/
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
/**
* 在两个bean之间注册一个包含关系，例如在内部bean及其包含的外部bean之间。
* 还根据破坏顺序将包含的bean注册为依赖于包含的bean。
* @param containedBeanName 包含的（内部）bean的名称
* @param containingBeanName 包含的（外部）bean的名称
* @see #registerDependentBean
*/
public void registerContainedBean(String containedBeanName, String containingBeanName) {
synchronized (this.containedBeanMap) {
Set containedBeans =
this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
if (!containedBeans.add(containedBeanName)) {
return;
}
}
registerDependentBean(containedBeanName, containingBeanName);
}
/**
* 为给定的bean注册一个依赖的bean，
* 在给定的bean被销毁之前被销毁。
* @param beanName bean的名称
* @param dependentBeanName 依赖的bean的名称
*/
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
Set dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
synchronized (this.dependenciesForBeanMap) {
Set dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
/**
* 确定是否已将指定的依赖bean注册为依赖于给定bean或其任何传递依赖项。
* 简单的就是说判断给定的beanName 是否依赖于给定的dependentBeanName
* @param beanName 要检查的bean的名称
* @param dependentBeanName 依赖的bean的名称
* @since 4.0
*/
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set alreadySeen) {
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
String canonicalName = canonicalName(beanName);
Set dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
return false;
}
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
/**
* 确定是否已为给定名称的Bean注册了依赖bean。
* @param beanName 要检查的bean的名称
*/
protected boolean hasDependentBean(String beanName) {
return this.dependentBeanMap.containsKey(beanName);
}
/**
* 如果有依赖的Bean，则返回依赖于指定bean的所有bean的名称。
* @param beanName bean的名称
* @return 返回依赖的bean名称的数组，如果没有则为空数组
*/
public String[] getDependentBeans(String beanName) {
Set dependentBeans = this.dependentBeanMap.get(beanName);
if (dependentBeans == null) {
return new String[0];
}
synchronized (this.dependentBeanMap) {
return StringUtils.toStringArray(dependentBeans);
}
}
/**
* 如果有依赖的Bean，返回指定bean所依赖的所有bean的名称。
* @param beanName bean的名称
* @return 返回bean所依赖的bean的名称数组，如果没有则为空数组
*/
public String[] getDependenciesForBean(String beanName) {
Set 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());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
clearSingletonCache();
}
/**
* 清除此注册表中的所有缓存的单例实例
* @since 4.3.15
*/
protected void clearSingletonCache() {
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;
}
}
/**
* 销毁给定的bean。如果找到相应的单例的Bean实例，则委托给
* {@code destroyBean}
* @param beanName bean的名称
* @see #destroyBean
*/
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) this.disposableBeans.remove(beanName);
}
destroyBean(beanName, disposableBean);
}
/**
* 销毁给定的bean。必须先销毁依赖于给定bean的bean，
* 然后再销毁bean。不应抛出任何异常。
* @param beanName bean的名称
* @param bean 要销毁的bean实例
*/
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// Trigger destruction of dependent beans first...
Set 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 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>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry> entry = it.next();
Set dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// Remove destroyed bean's prepared dependency information.
this.dependenciesForBeanMap.remove(beanName);
}
/**
* 将单例互斥对象公开给子类和外部协作者。
* 如果子类执行任何扩展的单例创建阶段，则它们应在给定的对象上同步。
* 特别要注意的是，子类不应该具有自己的互斥体，以创建单例，以避免在
* 惰性初始化情况下出现死锁的可能性。
*/
@Override
public final Object getSingletonMutex() {
return this.singletonObjects;
}
}
