spring5 IOC 源码DefaultSingletonBeanRegistry分析

r囧r小猫 2022-02-26 06:34 328阅读 0赞

> ## 1、类的继承关系 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70][]

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

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

> ## 2、 重要字段说明 ##

/** Cache of singleton objects: bean name to bean instance. */
        //是存放singleton对象的缓存  
    	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    	/** Cache of singleton factories: bean name to ObjectFactory. */
        // 是存放制造singleton的工厂对象的缓存  
    	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    
    	/** Cache of early singleton objects: bean name to bean instance. */
        //是存放早期singleton 的缓存
    	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    
        /** Disposable bean instances: bean name to disposable instance. */
        //存放一次性bean的缓存
    	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
    
    	/** Map between containing bean names: bean name to Set of bean names that the bean contains. */
    	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
    
    	/** Map between dependent bean names: bean name to Set of dependent bean names. */
    	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
    
    	/** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */
    	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
    
    	/** Set of registered singletons, containing the bean names in registration order. */
        //单例注册表
    	private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
    
    	/** Names of beans that are currently in creation. */
        //目前正在创建中的单例bean的名称的集合
    	private final Set<String> singletonsCurrentlyInCreation =
    			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    
    	/** Names of beans currently excluded from in creation checks. */
        //排除创建检查的集合
    	private final Set<String> inCreationCheckExclusions =
    			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    
    	/** List of suppressed Exceptions, available for associating related causes. */
          // 存放异常的集合
    	@Nullable
    	private Set<Exception> suppressedExceptions;
    
    	/** Flag that indicates whether we're currently within destroySingletons. */
    	private boolean singletonsCurrentlyInDestruction = false;

7个map

<table> 
 <tbody> 
  <tr> 
   <td style="width:347px;">集合</td> 
   <td style="width:502px;">作用</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>singletonObjects</code></pre> </td> 
   <td style="width:502px;">存放singleton对象的缓存 &nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>singletonFactories</code></pre> </td> 
   <td style="width:502px;">存放制造singleton对象工厂对象的缓存 &nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>earlySingletonObjects</code></pre> </td> 
   <td style="width:502px;">早期单例对象的缓存</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>disposableBeans</code></pre> </td> 
   <td style="width:502px;">存放一次性bean的缓存</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>containedBeanMap</code></pre> </td> 
   <td style="width:502px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>dependentBeanMap</code></pre> </td> 
   <td style="width:502px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:347px;"> <pre><code>dependenciesForBeanMap</code></pre> </td> 
   <td style="width:502px;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

4个set集合

<table> 
 <tbody> 
  <tr> 
   <td style="width:329px;">set集合</td> 
   <td style="width:520px;">作用</td> 
  </tr> 
  <tr> 
   <td style="width:329px;"> <pre><code>registeredSingletons</code></pre> </td> 
   <td style="width:520px;">单例注册表</td> 
  </tr> 
  <tr> 
   <td style="width:329px;"> <pre><code>singletonsCurrentlyInCreation</code></pre> </td> 
   <td style="width:520px;">正在创建bean的集合</td> 
  </tr> 
  <tr> 
   <td style="width:329px;"> <pre><code>inCreationCheckExclusions</code></pre> </td> 
   <td style="width:520px;">排除正在创建检查的bean的集合</td> 
  </tr> 
  <tr> 
   <td style="width:329px;"> <pre><code>suppressedExceptions</code></pre> </td> 
   <td style="width:520px;">存放异常的集合</td> 
  </tr> 
 </tbody> 
</table>

> ## 3、重要方法 ##

### 3.1 registerSingleton ###

public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
            //beanName和singletonObject不能为空
    		Assert.notNull(beanName, "Bean name must not be null");
    		Assert.notNull(singletonObject, "Singleton object must not be null");
            //缓存的单例map作锁对象
    		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);
    		}
    	}

### 3.2 addSingleton ###

protected void addSingleton(String beanName, Object singletonObject) {
    		synchronized (this.singletonObjects) {
    			this.singletonObjects.put(beanName, singletonObject);
    			this.singletonFactories.remove(beanName);
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}

### 3.3 addSingletonFactory ###

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

### 3.4 getSingleton ###

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

上面的方法简单易懂

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;
    					}
    				}
                    //遍历set集合中的异常追加异常产生原因
    				catch (BeanCreationException ex) {
    					if (recordSuppressedExceptions) {
    						for (Exception suppressedException : this.suppressedExceptions) {
    							ex.addRelatedCause(suppressedException);
    						}
    					}
    					throw ex;
    				}
    				finally {
    					if (recordSuppressedExceptions) {
    						this.suppressedExceptions = null;
    					}
                        //如果当前正在创建的单例池中有这个对象，抛出循环依赖异常
    					afterSingletonCreation(beanName);
    				}
                    //将创造好的对象加入map中
    				if (newSingleton) {
    					addSingleton(beanName, singletonObject);
    				}
    			}
    			return singletonObject;
    		}
    	}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]: /images/20220226/91d7fc42baf74d46aed0c8f6a67b3244.png