DefaultSingletonBeanRegistry

DefaultSingletonBeanRegistry

这是 DefaultSingletonBeanRegistry 类的体系结构,由一个类一个责任的原则：

• AliasRegistry : 提供别名注册的接口

• SimpleAliasRegistry : 它简单地实现了AliasRegistry接口。

• SingletonBeanRegistry : 提供单例bean注册的接口

• DefaultSingletonBeanRegistry :它继承SimpleAliasRegistry类和实现了SingletonBeanRegistry接口，因此这个类可以有别名注册的功能和单例bean注册的功能，并且他还支持注册DisposableBean实例;它依赖ObjectFactory接口和DisposableBean接口(关闭注册表时调用到了destroy方法)。

• ObjectFactory : 这个接口通常用于封装一个通用的工厂，它只有一个方法getObject() ,它调用getObject()方法返回一个新的实例，一些在每次调用的目标对象（原型）.

• DisposableBean : 接口实现为beans要破坏释放资源。它也只有一个方法destroy(),由一个破坏一个singleton的BeanFactory调用。

/**
 * 共享bean实例的通用注册表，实现了SingletonBeanRegistry. 允许注册表中注册的单例应该被所有调用者共享，通过bean名称获得。
 *
 * 还支持登记的DisposableBean实例，（这可能会或不能正确的注册单例），关闭注册表时destroyed.
 * 可以注册bean之间的依赖关系，执行适当的关闭顺序。
 *
 *
 * 这个类主要用作基类的BeanFactory实现， 提供基本的管理
 * singleton bean 实例功能。
 *
 */
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
    SingletonBeanRegistry {  

    // null 单例对象的内部标记：用作并发 Map(不支持null值)的标记值
    protected static final Object NULL_OBJECT = new Object();  

    // 日志用来记录子类
    protected final Log logger = LogFactory.getLog(getClass());  

    // singleton 对象的缓存：bean name --> bean instance
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>();  

    // singleton 的工厂对象的缓存：bean name --> ObjectFactory
    private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>();  

    // singletonFactory 制造出来的 singleton 的缓存：bean name --> bean instance
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>();
    //以上三个缓存是这个类存放单例 bean 的主要 Map  

    // 就是单例注册表
    private final Set<String> registeredSingletons = new LinkedHashSet<String>(16);  

    // 目前正在创建中的单例 bean 的名称的集合
    private final Set<String> singletonsCurrentlyInCreation = Collections.synchronizedSet(new HashSet<String>());

	// 当前在创建检查中排除的 bean 的名称
    private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    // 存放异常出现的相关的原因的集合
    private Set<Exception> suppressedExceptions;  

    // 标志，指示我们目前是否在销毁单例中
    private boolean singletonsCurrentlyInDestruction = false;  

    // 存放一次性bean的缓存
    private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();  

    // 外部 bean 与其所有内部 bean 集合：外部 bean name --> 外部 bean 所包含的内部 bean 集合
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>();  

    // 依赖这个 bean 的所有 bean 集合(依赖我的)：bean name --> 依赖这个 bean 的所有 bean 集合
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>();  

    // 这个 bean 依赖的所有 bean 集合(我依赖的) ：bean name --> bean 依赖的所有 bean 集合
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>();
    // 以上四个 map 集合都和 bean 的销毁有关

    // SingletonBeanRegistry 接口的 registerSingleton 方法的实现
    public void registerSingleton(String beanName, Object singletonObject)
        throws IllegalStateException {
        Assert.notNull(beanName, "'beanName' must not be null");
        synchronized (this.singletonObjects) {
            Object oldObject = this.singletonObjects.get(beanName);
            //如果 singletonObjects 缓存找到有指定名称为 beanName 的对象，则表示该了bean 已经注册
            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) {
            // 因为singletonObjects类型是 ConcurrentHashMap，并发Map不支持空值作为标志值，所以用NULL_OBJECT来代替
            this.singletonObjects.put(beanName,
                (singletonObject != null ? singletonObject : NULL_OBJECT));
            // singletonFactories、earlySingletonObjects 解决创建 singletonObject 的过程中的循环依赖用的
            // bean 创建完成后就没用的，需要销毁
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            // beanName放进单例注册表中
            this.registeredSingletons.add(beanName);
        }
    }  

    // 添加名称为 beanName 的 singletonFactory 对象
    protected void addSingletonFactory(String beanName,
        ObjectFactory singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            // 同理，bean 如果已经创建完成，就没有必要进行这步操作了
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }  

    // SingletonBeanRegistry 接口的 getSingleton 方法的实现
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }  

  	/**
  	 * 获取 bean 的单例
  	 * @param  beanName
  	 * @param  allowEarlyReference 是否允许循环引用
  	 */
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        // singletonObject = nul 说明 bean 还未创建或正在创建
        // 如果 isSingletonCurrentlyInCreation(beanName) = true，说明出现了循环引用
		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();
						// 显然 earlySingletonObjects、singletonFactories 是不能共存的
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }  

	/**
	 * 真正的根据 ObjectFactory 创建 singletonObject 对象了
	 * @param  beanName
	 * @param  singletonFactory 创建 singletonObject 对象的工厂对象
	 */
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			//1. 如果 singletonObject 还没有被创建，那就开始创建吧
			if (singletonObject == null) {
				//2. 如果 beanName 正在被销毁，那还创建个啥，直接抛出异常就好
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while the 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 + "'");
				}
				//3. 单例对象创建前的回调，一个重要的工作就是将该 bean 打上正在创建的标记
				beforeSingletonCreation(beanName);
				// beanName 创建成功与否的一个标记
				boolean newSingleton = false;

				// 判断存储异常相关原因的集合是否已存在，不存在就创建一个
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<Exception>();
				}
				try {
					//4. 好了，创建 singletonObject
					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
					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;
					}
					//5. 单例对象创建后的回调，一个重要的工作就是将该 bean 正在创建的标记销毁
					afterSingletonCreation(beanName);
				}
				//6. beanName 创建成功，注册创建后的单例
				if (newSingleton) {
					addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

    // 注册 singeton bean 实例创建过程中的异常
    protected void onSuppressedException(Exception ex) {
        synchronized (this.singletonObjects) {
            if (this.suppressedExceptions != null) {
                this.suppressedExceptions.add(ex);
            }
        }
    }  

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

    // singletonBeanRegistry 接口的 containsSingleton 方法实现
    public boolean containsSingleton(String beanName) {
        return (this.singletonObjects.containsKey(beanName));
    }  

    // singletonBeanRegistry 接口的 getSingletonNames 方法实现
    public String[] getSingletonNames() {
        // 对 singletonObjects 加锁，可能是为了防止 registeredSingletons 和 singletonObjects 出现不一致的问题
        synchronized (this.singletonObjects) {
            return StringUtils.toStringArray(this.registeredSingletons);
        }
    }  

    // singletonBeanRegistry 接口的 getSingletonCount 方法实现
    public int getSingletonCount() {
        synchronized (this.singletonObjects) {
            return this.registeredSingletons.size();
        }
    }

	// 将正在创建的 beanName 从 inCreationCheckExclusions 集合删除，已创建完成的加入 inCreationCheckExclusions
    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);
	}

	// 返回 beanName 是否正在创建，即出现了循环引用
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

    // 单例对象创建前的回调
    // 创建前 singletonsCurrentlyInCreation 注册该 beanName，如果已经添加则会抛出异常
    protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

    // 单例对象创建后的回调
    // 创建后 singletonsCurrentlyInCreation 移除该 beanName，如果该 beanName 已经创建完成则会抛出异常
    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 注册，存放在 disponsableBeans 集合中
    public void registerDisposableBean(String beanName, DisposableBean bean) {
        synchronized (this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }  

    /**
     * 注册两个 bean 之间的控制关系
     * @param  containedBeanName  the name of the contained (inner) bean
     * @param  containingBeanName the name of the containing (outer) bean
     */
    public void registerContainedBean(String containedBeanName,  String containingBeanName) {
    	// 先做一个简单的判断，避免使用 synchronized 关键字
        Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
		if (containedBeans != null && containedBeans.contains(containedBeanName)) {
			return;
		}

		synchronized (this.containedBeanMap) {
			containedBeans = this.containedBeanMap.get(containingBeanName);
			if (containedBeans == null) {
				containedBeans = new LinkedHashSet<String>(8);
				this.containedBeanMap.put(containingBeanName, containedBeans);
			}
			containedBeans.add(containedBeanName);
		}
		// 紧接着调用注册内部 bean 和外部 bean 的依赖关系的方法
		registerDependentBean(containedBeanName, containingBeanName);
    }  

    /**
     * 注册给定bean的一个依赖bean，给定的bean销毁之前被销毁。
     *
     */
    public void registerDependentBean(String beanName, String dependentBeanName) {
		// 调用 SimpleAliasRegistry 的 canonicalName 方法，这方法是将参数 beanName 当做别名寻找到注册名，并依此递归
		String canonicalName = canonicalName(beanName);
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
			return;
		}

		// 注册依赖 beanName 的集合，毫无疑问 containingBeanName 依赖 containedBeanName
		// 换句话说，依赖 containedBeanName 的集合中包括 containingBeanName
		synchronized (this.dependentBeanMap) {
			dependentBeans = this.dependentBeanMap.get(canonicalName);
			if (dependentBeans == null) {
				dependentBeans = new LinkedHashSet<String>(8);
				this.dependentBeanMap.put(canonicalName, dependentBeans);
			}
			dependentBeans.add(dependentBeanName);
		}
		// 注册 dependentBeanName 所依赖的集合
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
			if (dependenciesForBean == null) {
				dependenciesForBean = new LinkedHashSet<String>(8);
				this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
			}
			dependenciesForBean.add(canonicalName);
		}
	}

	protected boolean isDependent(String beanName, String dependentBeanName) {
		return isDependent(beanName, dependentBeanName, null);
	}

	private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
		String canonicalName = canonicalName(beanName);
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		Set<String> 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<String>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

    //  确定是否还存在名为 beanName 的被依赖关系
    protected boolean hasDependentBean(String beanName) {
        return this.dependentBeanMap.containsKey(beanName);
    }  

    // 返回依赖于指定的bean的所有bean的名称，如果有的话。(依赖我的)
    public String[] getDependentBeans(String beanName) {
		Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
		if (dependentBeans == null) {
			return new String[0];
		}
		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];
		}
		return dependenciesForBean.toArray(new String[dependenciesForBean.size()]);
	}

  	// 销毁所有单例
    public void destroySingletons() {
		if (logger.isDebugEnabled()) {
			logger.debug("Destroying singletons in " + this);
		}
		// 单例销毁标志开始
		synchronized (this.singletonObjects) {
			this.singletonsCurrentlyInDestruction = true;
		}

		// 销毁 disponsableBeans 缓存中所有单例 bean
		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();

		synchronized (this.singletonObjects) {
			this.singletonObjects.clear();
			this.singletonFactories.clear();
			this.earlySingletonObjects.clear();
			this.registeredSingletons.clear();
			// 单例目前正在销毁标志为结束
			this.singletonsCurrentlyInDestruction = false;
		}
	}

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

  	// 真正的销毁 beanName
  	// 毫无疑问，销毁该 beanName 之前要将依赖这个 beanName 的所有 bean 都销毁
    protected void destroyBean(String beanName, DisposableBean bean) {
		//1. 先销毁依赖这个 beanName 的所有实例
		Set<String> dependencies = this.dependentBeanMap.remove(beanName);
		if (dependencies != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
			}
			for (String dependentBeanName : dependencies) {
				destroySingleton(dependentBeanName);
			}
		}

		//2. 真正销毁该 beanName
		if (bean != null) {
			try {
				bean.destroy();
			}
			catch (Throwable ex) {
				logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
			}
		}

		//3. 销毁该 beanName 所包含的子 containedBean
		Set<String> containedBeans = this.containedBeanMap.remove(beanName);
		if (containedBeans != null) {
			for (String containedBeanName : containedBeans) {
				destroySingleton(containedBeanName);
			}
		}

		//4. 从其它 bean 的依赖 bean 集合中删除已销毁的 beanName
		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();
				}
			}
		}

		//5. 最后从 dependenciesForBeanMap 缓存中移除要销毁的 bean
		this.dependenciesForBeanMap.remove(beanName);
	}

    // 将所有的单例暴露给子类和外部
    protected final Object getSingletonMutex() {
        return this.singletonObjects;
    }
}