DefaultSingletonBeanRegistry

DefaultSingletonBeanRegistry

英文注释分别阐述了以下内容(一个段落用一个小标)：
⑴、类DefaultSingletonBeanRegistry实现了接口SingletonBeanRegistry，是通用注册表的基础实现类:
①、它允许注册bean对象实例(这些对象实例都是单例模式)。
②、已经注册的bean对象实例是注册表的所有调用者共享的(所以特别需要注意线程安全)。
③、可以通过bean名称获得目标bean对象实例。
⑵、类DefaultSingletonBeanRegistry还支持类DisposableBean对象实例的注册(在关闭注册表时销毁)，该实例可能与已注册的bean对象实例相对应。bean对象实例之间的依赖关系也可以注册，以此控制销毁bean对象实例的顺序。
⑶、类DefaultSingletonBeanRegistry主要作为实现接口BeanFactory的基类，它分解了单例bean对象实例的常见管理(比如注册，获取等等，但不包含创建)。
①、另一个接口ConfigurableBeanFactory扩展了接口SingletonBeanRegistry。
⑷、类DefaultSingletonBeanRegistry与类AbstractBeanFactory和类DefaultListableBeanFactory(继承自类DefaultSingletonBeanRegistry)相比，既不涉及bean对象实例概念的定义也不涉及bean对象实例的创建过程,还可以用作委托的嵌套助手(涉及Java设计模式)。

 public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry   
 implements SingletonBeanRegistry {
    //单例bean对象实例都存储在Map中,但Map不允许存储null
    //所以当bean为null时,就用NULL_OBJECT代替null存储到Map中
	protected static final Object NULL_OBJECT = new Object();
	//日志对象,供子类使用
	protected final Log logger = LogFactory.getLog(getClass());
	//存储已经创建完毕的单例bean对象实例
	//(创建完毕是指构造方法已经执行
	//并且属性也已经根据配置文件赋值完毕)
	//singletonObjects也称为三级缓存
	private final Map<String, Object> singletonObjects = new 
	ConcurrentHashMap<String, Object>(256);
	//存储创建单例bean对象实例的工厂对象实例
	//一个工厂对象实例创建一种类型bean
	//具体的创建过程在类DefaultListableBeanFactory中
	//所有的工厂类都需要implements接口ObjectFactory
	//singletonFactories也称为一级缓存(必须先有工厂才能创建bean)
	private final Map<String, ObjectFactory<?>> singletonFactories = 
	new HashMap<String, ObjectFactory<?>>(16);
	//Spring创建bean对象实例大多都是调用默认构造函数
	//再通过set方法为属性赋值
	//存储已经执行默认构造函数但未给属性赋值的对象
	//earlySingletonObjects也称为二级缓存
	//主要解决bean之间循环依赖的问题
	//(需要明白循环依赖问题后面的源码才能看的懂)
	//Spring中的循环依赖有三种:
	//①、类A类B互为构造方法依赖
	//这种依赖Spring无法解决:创建类A对象的时候
	//发现类A的构造方法参数为类B对象,这时候需要
	//创建类B对象,但是又发现类B的构造方法参数为类A对象
	//结果类A和类B对象都无法创建
	//②、类A的构造方法参数为类B对象,类B的某个
	//setter方法参数为类A对象,创建类A对象的时候
	//需要创建类B对象可以直接通过类B的默认构造方法
	//类B对象创建完毕后类A对象的创建过程得以继续
	//这时类B对象需要暂时放入earlySingletonObjects缓存中
	//因为它只创建了对象,并未给属性赋值
	//③、类A类B互为setter方法参数依赖,举例与第二种
	//情况类似,都是通过默认构造方法创建对象
	//这时类A与类B都会被放入earlySingletonObjects缓存中
	private final Map<String, Object> earlySingletonObjects = 
	new HashMap<String, Object>(16);
	//存储已经创建完毕的单例bean对象实例的名称
	//(创建完毕是指构造方法已经执行
	//并且属性也已经根据配置文件赋值完毕)
	//存储的顺序是单例bean对象实例的注册顺序
	private final Set<String> registeredSingletons = 
	new LinkedHashSet<String>(256);
	//存储正在创建的bean对象实例的名称
	//(正在创建是指构造方法已经执行
	//所有或者部分属性还未根据配置文件赋值)
	private final Set<String> singletonsCurrentlyInCreation =
	Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
	//
	private final Set<String> inCreationCheckExclusions =
	Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
	//禁止的异常,可用于关联相关原因
	private Set<Exception> suppressedExceptions;
	//指示我们当前是否在destroySingletons中的标志
	private boolean singletonsCurrentlyInDestruction = false;
	
	private final Map<String, Object> disposableBeans = 
	new LinkedHashMap<String, Object>();
	
	private final Map<String, Set<String>> containedBeanMap = 
	new ConcurrentHashMap<String, Set<String>>(16);
	
	private final Map<String, Set<String>> dependentBeanMap = 
	new ConcurrentHashMap<String, Set<String>>(64);
	
	private final Map<String, Set<String>> dependenciesForBeanMap = 
	new ConcurrentHashMap<String, Set<String>>(64);
	//在注册表(Map)中注册一个已经创建完毕的单例bean
	//对象实例singletonObject,名称为指定名称beanName
    public void registerSingleton(String beanName, Object singletonObject) 
    throws IllegalStateException {
       //保证指定名称beanName不为null
	   Assert.notNull(beanName, "'beanName' must not be null");
	   //因为注册表中的单例bean对象实例是它的所有调用者共享的
	   //所以在多线程环境下同一时间内只能有一个调用者操作
	   //singletonObjects,需要通过关键字synchronized保证线程安全
	   synchronized (this.singletonObjects) {
	      //判断指定名称beanName是否已经注册,通过它
	      //去一级缓存中获取对象
	      Object oldObject = this.singletonObjects.get(beanName);
	      //如果oldObject != null,说明beanName已经注册
		  if (oldObject != null) {
		     //直接抛出异常,并提示已注册的名称不能重复注册
		     //因为Map的key是唯一的
		     throw new IllegalStateException("Could not register object 
		     [" + singletonObject +"] under bean name '" + beanName + "': 
		     there is already object [" + oldObject + "] bound");
		  }
		  //如果oldObject == null,说明beanName未注册
		  //继续执行注册流程,参考方法
		  //addSingleton(String beanName, Object singletonObject)
		  addSingleton(beanName, singletonObject);
	   }
	}
	//向注册表的一级缓存中添加已经
	//创建完毕的单例bean对象实例singletonObject
	protected void addSingleton(String beanName, Object singletonObject) {
	   //保证线程安全
	   synchronized (this.singletonObjects) {
	      //向一级缓存中添加键值对beanName->singletonObject
	      //因为Map不允许添加null,如果singletonObject == null
	      //就用NULL_OBJECT代替
	      this.singletonObjects.put(beanName, (singletonObject != null ? 
	      singletonObject : NULL_OBJECT));
	      //singletonObject是已经创建完毕的单例bean对象实例
	      //所以三级缓存中的记录需要删除
	      //(如果有,如果没有,remove()不会执行任何操作)
	      //从另一个角度理解:因为是单例,既然已经有已经创建完毕的
	      //singletonObject,自然不再需要创建的工厂,所以删除
		  this.singletonFactories.remove(beanName);
		  //同样,二级缓存中的记录也需要删除
	      //(如果有,如果没有,remove()不会执行任何操作)
		  this.earlySingletonObjects.remove(beanName);
		  //将beanName添加到存储已经创建完毕的
		  //单例bean实例对象的名称集合中
		  //在添加三级缓存的方法addSingletonFactory
		  //(String beanName, ObjectFactory singletonFactory)
		  //中已经添加过了,这里只是为了保证一定添加进去
		  //如果beanName已经存在,这里不会执行任何操作
		  //registeredSingletons是Set,Set不存储重复元素
		  this.registeredSingletons.add(beanName);
		}
	}
	//向注册表的三级缓存中添加创建单例bean对象的工厂实例对象
	protected void addSingletonFactory(String beanName, ObjectFactory<?> 
	singletonFactory) {
	   //保证singletonFactory不为null
	   Assert.notNull(singletonFactory, "Singleton factory must not be 
	   null");
	   //保证线程安全
       synchronized (this.singletonObjects) {
          //如果beanName不在以及缓存中
		  if (!this.singletonObjects.containsKey(beanName)) {
		     //向三级缓存中添加键值对beanName->singletonFactory
			 this.singletonFactories.put(beanName, singletonFactory);
			 //按道理,二级缓存中应该是没有beanName的
			 //但是不管有没有,调用一下总是没错的
			 this.earlySingletonObjects.remove(beanName);
			 //将beanName添加到存储已经创建完毕的
		     //单例bean实例对象的名称集合中
			 this.registeredSingletons.add(beanName);
		  }
	   }
	}
	//返回指定名称为beanName的单例bean对象实例
	public Object getSingleton(String beanName) {
	   //参考方法getSingleton(String beanName, boolean 
	   //allowEarlyReference)
	   return getSingleton(beanName, true);
	}
	//返回指定名称为beanName的单例bean对象实例
	protected Object getSingleton(String beanName, boolean 
	allowEarlyReference) {
	   //先从一级缓存中获取
	   Object singletonObject = this.singletonObjects.get(beanName);
	   //如果一级缓存中没有并且bean对象实例正在创建中
	   if (singletonObject == null && 
	   isSingletonCurrentlyInCreation(beanName)) {
	      //保证线程安全
		  synchronized (this.singletonObjects) {
		     //从二级缓存中获取
		     singletonObject = this.earlySingletonObjects.get(beanName);
		     //如果二级缓存中也没有,并且bean对象实例允许创建提前的引用
			 if (singletonObject == null && allowEarlyReference) {
			    //从三级缓存中获取
			    ObjectFactory<?> singletonFactory = 
				this.singletonFactories.get(beanName);
				//如果三级缓存有
				if (singletonFactory != null) {
				   //直接从三级缓存中获取bean对象实例
			       singletonObject = singletonFactory.getObject();
			       //将bean对象实例放入二级缓存中
				   this.earlySingletonObjects.put(beanName, 
				   singletonObject);
				   //将bean对象实例从三级缓存中移除
				   this.singletonFactories.remove(beanName);
				}
			 }
		  }
	   }
	   //如果一级缓存中有,直接返回
	   return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}
	//返回指定名称为beanName的单例bean对象实例
	public Object getSingleton(String beanName, ObjectFactory<?> 
	singletonFactory) {
	   //保证beanName不为null
	   Assert.notNull(beanName, "'beanName' must not be null");
	   //保证线程安全
	   synchronized (this.singletonObjects) {
	      //先从一级缓存获取bean对象实例
		  Object singletonObject = this.singletonObjects.get(beanName);
		  //如果一级缓存中没有
		  if (singletonObject == null) {
		     //先判断生产目标bean的工厂单例是否正在被销毁
			 if (this.singletonsCurrentlyInDestruction) {
			    //如果正在被销毁,则抛出BeanCreationNotAllowedException异常
			    //以及提示信息：当该工厂的单例销毁时，不允许创建单例bean
			    //在销毁工厂单例的方法实现中，请勿向BeanFactory请求Bean！
			    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 + "'");
			 }
			 //创建单例之前的回调。
             //将单例注册为当前正在创建中的默认实现。
			 beforeSingletonCreation(beanName);
			 //boolean类型的变量newSingleton,初始化为false
			 boolean newSingleton = false;
			 //boolean类型的变量recordSuppressedExceptions
			 //如果this.suppressedExceptions == null为true
			 //初始化为true,否则初始化为false
			 boolean recordSuppressedExceptions = 
			 (this.suppressedExceptions == null);
			 //如果this.suppressedExceptions == null
			 if (recordSuppressedExceptions) {
			    //初始化suppressedExceptions为LinkedHashSet
				this.suppressedExceptions = new LinkedHashSet<Exception>();
			 }
			 //捕捉异常
			 try {
			    //从三级缓存中获取对象
				singletonObject = singletonFactory.getObject();
				//将变量newSingleton变为true
				newSingleton = true;
			 }
			 //捕捉IllegalStateException异常
			 catch (IllegalStateException ex) {
			    //从一级缓存中获取对象
				singletonObject = this.singletonObjects.get(beanName);
				//如果获取不到
				if (singletonObject == null) {
				   //抛出异常
				   throw ex;
				}
			 }
             //捕捉IllegalStateException异常
			 catch (BeanCreationException ex) {
			    //如果this.suppressedExceptions == null
				if (recordSuppressedExceptions) {
				   //循环添加异常
				   for (Exception suppressedException : 
				   this.suppressedExceptions) {
					  ex.addRelatedCause(suppressedException);
					}
				}
				//抛出异常
				throw ex;
			 }
			 //无论在何种情况下一定会执行的语句
			 finally {
			    //如果如果this.suppressedExceptions == null
				if (recordSuppressedExceptions) {
				   //清空
				   this.suppressedExceptions = null;
				}
				//将当前的bean移除正在创建的状态
				afterSingletonCreation(beanName);
			 }
			 //如果创建成功
			 if (newSingleton) {
			    //将当前的bean添加到一级缓存中
				addSingleton(beanName, singletonObject);
			 }
		  }
		  //如果一级缓存中有对象,直接返回
		  return (singletonObject != NULL_OBJECT ? singletonObject : null);
	   }
	}
    //注册一个在创建单例bean实例期间被抑制的异常
    //例如 临时循环参考解析问题。
	protected void onSuppressedException(Exception ex) {
	   //保证线程安全
	   synchronized (this.singletonObjects) {
		  if (this.suppressedExceptions != null) {
			 this.suppressedExceptions.add(ex);
		  }
	   }
	}
    //从该工厂的单例缓存中删除具有给定名称的Bean
    //以便在创建失败时清除急于注册的单例。
	protected void removeSingleton(String beanName) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.remove(beanName);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.remove(beanName);
		}
	}
    //判断一级缓存中是否包含指定名称bean对象实例
	public boolean containsSingleton(String beanName) {
	   //返回一级缓存中是否包含指定名称的单例Bean
		return this.singletonObjects.containsKey(beanName);
	}
    //返回一级缓存中的单例bean名称
	public String[] getSingletonNames() {
		synchronized (this.singletonObjects) {
			return StringUtils.toStringArray(this.registeredSingletons);
		}
	}
    //返回一级缓存中的单例bean数量
	public int getSingletonCount() {
		synchronized (this.singletonObjects) {
			return this.registeredSingletons.size();
		}
	}
    //将指定名称的bean设置为正在创建中
	public void setCurrentlyInCreation(String beanName, boolean inCreation) 
	{
	   //保证名称不为null
	   Assert.notNull(beanName, "Bean name must not be null");
	   //如果不允许创建,则加入到inCreationCheckExclusions中
	   if (!inCreation) {
		  this.inCreationCheckExclusions.add(beanName);
	   }
	   //否则将指定的名称从inCreationCheckExclusions清除
	   else {
		  this.inCreationCheckExclusions.remove(beanName);
	   }
	}
    //返回当前指定的实例名称是否是正在创建的bean
	public boolean isCurrentlyInCreation(String beanName) {
	   //保证名称不为null
		Assert.notNull(beanName, "Bean name must not be null");
		//返回结果：指定名称不在inCreationCheckExclusions中
		//同时isActuallyInCreation()返回true
		return (!this.inCreationCheckExclusions.contains(beanName) && 
		isActuallyInCreation(beanName));
	}
    //判断指定名称bean是否正在创建中
	protected boolean isActuallyInCreation(String beanName) {
	   //返回isSingletonCurrentlyInCreation的结果
		return isSingletonCurrentlyInCreation(beanName);
	}
	//判断指定名称的bean是否正在创建中
	public boolean isSingletonCurrentlyInCreation(String beanName) {
	    //返回指定名称的bean是否在singletonsCurrentlyInCreation
	    //中
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}
	//创建单例之前的回调。默认实现将单例注册为当前正在创建中。
	protected void beforeSingletonCreation(String beanName) {
	   //先执行inCreationCheckExclusions.contains(beanName)
	   //得出结果,再执行singletonsCurrentlyInCreation.add(beanName)
	   //得出结果
	   //如果不在inCreationCheckExclusions中,同时添加失败
	   if (!this.inCreationCheckExclusions.contains(beanName) && 
	   !this.singletonsCurrentlyInCreation.add(beanName)) {
	      //则抛出BeanCurrentlyInCreationException异常
		  throw new BeanCurrentlyInCreationException(beanName);
	   }
	}
	//创建单例后的回调。默认实现将单例标记为不在创建中。
	protected void afterSingletonCreation(String beanName) {
	   //先执行inCreationCheckExclusions.contains(beanName)
	   //得出结果,再执行singletonsCurrentlyInCreation.remove(beanName)
	   //得出结果
	   if (!this.inCreationCheckExclusions.contains(beanName) && 
	   !this.singletonsCurrentlyInCreation.remove(beanName)) {
	      //如果不在inCreationCheckExclusions中,同时删除失败
	      //则抛出BeanCurrentlyInCreationException异常
		  throw new IllegalStateException("Singleton '" + beanName + "' 
		  isn't currently in creation");
	   }
	}
	//将给定的bean添加到此注册表中的一次性bean列表中。一次性
	//Bean通常与注册的单例相对应，与Bean名称匹配
	//但可能是不同的实例（例如，用于单例的DisposableBean适配器
	//该适配器自然不实现Spring的DisposableBean接口）。
	public void registerDisposableBean(String beanName, 
	DisposableBean bean) {
	   //保证线程安全
	   synchronized (this.disposableBeans) {
	      //将指定的bean放入一次性bean集合中
		  this.disposableBeans.put(beanName, bean);
	   }
	}
	//在两个bean之间注册一个包含关系，例如 在内部bean及其包含的
	//外部bean之间。也按照破坏顺序将包含的bean注册为依赖于包含的bean。
	public void registerContainedBean(String containedBeanName, String 
	containingBeanName) {
	   //快速检查现有条目，避免同步...
	   //尝试从containedBeanMap获取bean
	   Set<String> containedBeans =    
	   this.containedBeanMap.get(containingBeanName);
	   //如果获取成功同时containedBeans包含了containedBeanName
	   if (containedBeans != null && 
	   containedBeans.contains(containedBeanName)) {
	      //直接退出程序
	      //不需要重复进行包含操作
		  return;
	   }
	   //保证线程安全
	   synchronized (this.containedBeanMap) {
	      //尝试从containedBeanMap获取bean
		  containedBeans = 
		  this.containedBeanMap.get(containingBeanName);
		  //如果获取失败
		  if (containedBeans == null) {
		     //将containedBeans初始化为LinkedHashSet
		     containedBeans = new LinkedHashSet<String>(8);
		     //将containedBeans添加到containedBeanMap
			 this.containedBeanMap.put(containingBeanName, 
			 containedBeans);
		  }
		  //如果不为null,直接添加
		  containedBeans.add(containedBeanName);
	   }
	   //注册依赖的bean
	   registerDependentBean(containedBeanName, containingBeanName);
	}
	//为给定的bean注册一个从属bean，要在给定的bean被销毁之前将其销毁。
	public void registerDependentBean(String beanName, String 
	dependentBeanName) {
		String canonicalName = canonicalName(beanName);
		Set<String> dependentBeans = 
		this.dependentBeanMap.get(canonicalName);
		if (dependentBeans != null && 
		dependentBeans.contains(dependentBeanName)) {
			return;
		}
		synchronized (this.dependentBeanMap) {
			dependentBeans = this.dependentBeanMap.get(canonicalName);
			if (dependentBeans == null) {
				dependentBeans = new LinkedHashSet<String>(8);
				this.dependentBeanMap.put(canonicalName, dependentBeans);
			}
			dependentBeans.add(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) {
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		String canonicalName = canonicalName(beanName);
		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;
	}
	protected boolean hasDependentBean(String beanName) {
		return this.dependentBeanMap.containsKey(beanName);
	}
	public String[] getDependentBeans(String beanName) {
		Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
		if (dependentBeans == null) {
			return new String[0];
		}
		return StringUtils.toStringArray(dependentBeans);
	}
	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;
		}

		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) {
		removeSingleton(beanName);
		DisposableBean disposableBean;
		synchronized (this.disposableBeans) {
			disposableBean = (DisposableBean) 
			this.disposableBeans.remove(beanName);
		}
		destroyBean(beanName, disposableBean);
	}
	protected void destroyBean(String beanName, DisposableBean bean) {
		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);
			}
		}
		if (bean != null) {
			try {
				bean.destroy();
			}
			catch (Throwable ex) {
				logger.error("Destroy method on bean with name '" + beanName 
				+ "' threw an exception", ex);
			}
		}
		Set<String> containedBeans = this.containedBeanMap.remove(beanName);
		if (containedBeans != null) {
			for (String containedBeanName : containedBeans) {
				destroySingleton(containedBeanName);
			}
		}
		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();
				}
			}
		}
		this.dependenciesForBeanMap.remove(beanName);
	}
	//将单例互斥锁公开给子类和外部协作者。
	//如果子类执行任何扩展的单例创建阶段
	//则它们应在给定的Object上进行同步。 
	//特别是，子类不应在单例创建中涉及其自己的互斥体
	//以避免在惰性初始化情况下出现死锁的可能性。
	public final Object getSingletonMutex() {
		return this.singletonObjects;
	}
 }