Spring【版本5.2.2】容器初始化过程（六）getBean 详解

淩亂°似流年 2023-06-16 10:38 9阅读 0赞

接着上文的

### 6.registerBeanPostProcessors ###

#### 代码块4：getBean ####

这个是重点：

@Override
    	public Object getBean(String name) throws BeansException { 
    	    // 获取name对应的bean实例，如果不存在，则创建一个
    	    return doGetBean(name, null, null, false);
    	}
    
    	/** * 真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方 */
    	@SuppressWarnings("unchecked")
    	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 
    
    		/* * 通过name获取beanName，这里不用name直接作为beanName的原因： * 1. name可能是以&开头，表名调用者想获取FactoryBean本身，而非FactoryBean实现类所创建的bean * 在BeanFactory中，FactoryBean的实现类和其他的Bean存储方式是一致的，所以要讲name中首字符&移除， * 这样才能从缓存中渠道FactoryBean实例 * 2. 如果是别名，这将别名转成规范的Bean名称 */
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		// 先从缓存中取是否已经有被创建的单态类型的Bean
    		// 对于单例模式的Bean，整个IOC容器只创建一次，不需要重复创建
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) { 
    			// 3.如果beanName的实例存在于缓存中
    			if (logger.isTraceEnabled()) { 
    				// 校验Bean的创建状态
    				if (isSingletonCurrentlyInCreation(beanName)) { 
    					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else { 
    					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    			/* 3.1 获取给定Bean的实例对象，主要是完成FactoryBean的相关处理 * 如果sharedInstance是普通的单例Bean，下面的方法直接返回。 * 如果sharedInstance是FactoryBean类型，则需要调用FactoryBean.getObject工厂方法获取真正的Bean实例 * 如果用户想获取FactoryBean本身，这里面也不会做特别处理直接返回即可 * 注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是创建创建对象的工厂Bean，两者之间有区别 */
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else { 
    			// 4.bean的状态是正在创建中，还没有被实例化，所以如果是原型，直接抛出异常
    			// scope为prototype的循环依赖校验：如果beanName已经正在创建Bean实例中，
    			// 而此时我们又要再一次创建beanName的实例，则代表出现了循环依赖，需要抛出异常。
    			// 例子：如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，
    			// 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖
    			if (isPrototypeCurrentlyInCreation(beanName)) { 
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    			// Check if bean definition exists in this factory.
    			// 5. 检查是否存在默认的父工厂
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			// 5.1 如果parentBeanFactory存在，并且beanName在当前BeanFactory不存在Bean定义，
    			// 则尝试从parentBeanFactory中获取bean实例
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
    				// Not found -> check parent.
    				// 5.2 将别名解析成真正的beanName
    				String nameToLookup = originalBeanName(name);
    				if (parentBeanFactory instanceof AbstractBeanFactory) { 
    					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
    							nameToLookup, requiredType, args, typeCheckOnly);
    				}
    				// 5.3 尝试在parentBeanFactory中获取bean对象实例
    				else if (args != null) { 
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else if (requiredType != null) { 
    					// No args -> delegate to standard getBean method.
    					// 这个方法，以前版本里面没有的，
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    				else { 
    					return (T) parentBeanFactory.getBean(nameToLookup);
    				}
    			}
    			if (!typeCheckOnly) { 
    				// 6.如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存
    				markBeanAsCreated(beanName);
    			}
    
    			try { 
    				// 7.根据beanName重新获取MergedBeanDefinition（步骤6将MergedBeanDefinition删除了，这边获取一个新的）
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				// 7.1 检查MergedBeanDefinition
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				// 8.拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) { 
    					// 8.1 遍历当前bean依赖的bean名称集合
    					for (String dep : dependsOn) { 
    						// 8.2 检查dep是否依赖于beanName，即检查是否存在循环依赖
    						if (isDependent(beanName, dep)) { 
    							// 8.3 如果是循环依赖则抛异常
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						// 8.4 将dep和beanName的依赖关系注册到缓存中
    						registerDependentBean(dep, beanName);
    						try { 
    							// 8.5 获取dep对应的bean实例，如果dep还没有创建bean实例，则创建dep的bean实例
    							getBean(dep);
    						}
    						catch (NoSuchBeanDefinitionException ex) { 
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// Create bean instance.
    				// 9.针对不同的scope进行bean的创建
    				if (mbd.isSingleton()) { 
    					// 实例化bean
    					// 9.1 scope为singleton的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
    					sharedInstance = getSingleton(beanName, () -> { 
    						try { 
    							// 9.1.1 创建Bean实例
    							return createBean(beanName, mbd, args);
    						}
    						catch (BeansException ex) { 
    							// Explicitly remove instance from singleton cache: It might have been put there
    							// eagerly by the creation process, to allow for circular reference resolution.
    							// Also remove any beans that received a temporary reference to the bean.
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    					// 9.1.2 返回beanName对应的实例对象
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    				// 下面检查其他工作，暂时不做细说
    				else if (mbd.isPrototype()) { 
    					// It's a prototype -> create a new instance.
    					// 9.2 scope为prototype的bean创建，创建一个新的实例
    					Object prototypeInstance = null;
    					try { 
    						// 9.2.1 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
    						beforePrototypeCreation(beanName);
    						// 9.2.2 创建Bean实例
    						prototypeInstance = createBean(beanName, mbd, args);
    					}
    					finally { 
    						// 9.2.3 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
    						afterPrototypeCreation(beanName);
    					}
    					// 9.2.4 返回beanName对应的实例对象
    					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    				else { 
    					// 9.3 其他scope的bean创建，可能是request之类的
    					// 9.3.1 根据scopeName，从缓存拿到scope实例
    					String scopeName = mbd.getScope();
    					final Scope scope = this.scopes.get(scopeName);
    					if (scope == null) { 
    						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    					}
    					try { 
    						// 9.3.2 其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
    						Object scopedInstance = scope.get(beanName, () -> { 
    							// 9.3.3 创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
    							beforePrototypeCreation(beanName);
    							try { 
    								// 9.3.4 创建bean实例
    								return createBean(beanName, mbd, args);
    							}
    							finally { 
    								// 9.3.5 创建实例后的操作（将创建完的beanName从prototypesCurrentlyInCreation缓存中移除）
    								afterPrototypeCreation(beanName);
    							}
    						});
    						// 9.3.6 返回beanName对应的实例对象
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) { 
    						throw new BeanCreationException(beanName,
    								"Scope '" + scopeName + "' is not active for the current thread; consider " +
    								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    								ex);
    					}
    				}
    			}
    			catch (BeansException ex) { 
    				// 如果创建bean实例过程中出现异常，则将beanName从alreadyCreated缓存中移除
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		// 10.检查所需类型是否与实际的bean对象的类型匹配
    		if (requiredType != null && !requiredType.isInstance(bean)) { 
    			try { 
    				// 10.1 类型不对，则尝试转换bean类型
    				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    				if (convertedBean == null) { 
    					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    				}
    				return convertedBean;
    			}
    			catch (TypeMismatchException ex) { 
    				if (logger.isTraceEnabled()) { 
    					logger.trace("Failed to convert bean '" + name + "' to required type '" +
    							ClassUtils.getQualifiedName(requiredType) + "'", ex);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		// 11.返回创建出来的bean实例对象
    		return (T) bean;
    	}

9.1.2、9.2.4、9.3.6 返回 beanName 对应的实例对象，见代码块1详解。

##### 代码块4.1：getObjectForBeanInstance #####

protected Object getObjectForBeanInstance(
    			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { 
    
    		// Don't let calling code try to dereference the factory if the bean isn't a factory.
    		// 1.判断他是不是FactoryBean,只要看他是不是&开头,
    		if (BeanFactoryUtils.isFactoryDereference(name)) { 
    			if (beanInstance instanceof NullBean) { 
    				return beanInstance;
    			}
    			if (!(beanInstance instanceof FactoryBean)) { 
    				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
    			}
    			if (mbd != null) { 
    				mbd.isFactoryBean = true;
    			}
    			return beanInstance;
    		}
    
    		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
    		// If it's a FactoryBean, we use it to create a bean instance, unless the
    		// caller actually wants a reference to the factory.
    		// 2.1 如果beanInstance不是FactoryBean（也就是普通bean），则直接返回beanInstance
    		// 2.2 如果beanInstance是FactoryBean，并且name以“&”为前缀，则直接返回beanInstance（以“&”为前缀代表想获取的是FactoryBean本身）
    		if (!(beanInstance instanceof FactoryBean)) { 
    			return beanInstance;
    		}
    		// 3.走到这边，代表beanInstance是FactoryBean，但name不带有“&”前缀，表示想要获取的是FactoryBean创建的对象实例
    		Object object = null;
    		if (mbd != null) { 
    			// 标记是否是FactoryBean
    			mbd.isFactoryBean = true;
    		}
    		else { 
    			// 4.如果mbd为空，则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
    			object = getCachedObjectForFactoryBean(beanName);
    		}
    		if (object == null) { 
    			// Return bean instance from factory.
    			// 5.只有beanInstance是FactoryBean才能走到这边，因此直接强转
    			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
    			// Caches object obtained from FactoryBean if it is a singleton.
    			if (mbd == null && containsBeanDefinition(beanName)) { 
    				// 6.mbd为空，但是该bean的BeanDefinition在缓存中存在，则获取该bean的MergedBeanDefinition
    				mbd = getMergedLocalBeanDefinition(beanName);
    			}
    			// 7.mbd是否是合成的（这个字段比较复杂，mbd正常情况都不是合成的，也就是false，有兴趣的可以自己查阅资料看看）
    			boolean synthetic = (mbd != null && mbd.isSynthetic());
    			// 8.从FactoryBean获取对象实例
    			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    		}
    		// 9.返回对象实例
    		return object;
    	}

##### 代码块4.2：postProcessObjectFromFactoryBean #####

/** * 对所有已注册的BeanPostProcessors应用postProcessAfterInitialization回调， * 使它们有机会对从FactoryBeans获得的对象进行后处理(例如，自动代理它们)。 */
    	@Override
    	protected Object postProcessObjectFromFactoryBean(Object object, String beanName) { 
    		return applyBeanPostProcessorsAfterInitialization(object, beanName);
    	}

##### 代码块4.3：markBeanAsCreated #####

protected void markBeanAsCreated(String beanName) { 
    
    		if (!this.alreadyCreated.contains(beanName)) { 
    			synchronized (this.mergedBeanDefinitions) { 
    				// 1.如果alreadyCreated缓存中不包含beanName,
    				// 这边代码为啥判断两次contains，知道的留个言告知一下。
    				if (!this.alreadyCreated.contains(beanName)) { 
    					// Let the bean definition get re-merged now that we're actually creating
    					// the bean... just in case some of its metadata changed in the meantime.
    					// 2.这边跟以前版本有变化，如果mergedBeanDefinitions中存在当前的bean
    					// 将当前的RootBeanDefinition的stale设置成true
    					clearMergedBeanDefinition(beanName);
    					// 3.将beanName添加到alreadyCreated缓存中，代表该beanName的bean实例已经创建（或即将创建）
    					this.alreadyCreated.add(beanName);
    				}
    			}
    		}
    	}
    	/** * 删除指定bean的合并bean定义，在下一次访问时重新创建它。 */
    	protected void clearMergedBeanDefinition(String beanName) { 
    		RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
    		if (bd != null) { 
    			bd.stale = true;
    		}
    	}

##### 代码块4.4：isDependent #####

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) { 
    		// 已经检查过的直接跳过
    		if (alreadySeen != null && alreadySeen.contains(beanName)) { 
    			return false;
    		}
    		// 1.将别名解析为真正的名称
    		String canonicalName = canonicalName(beanName);
    		// 2.拿到依赖canonicalName的beanName集合
    		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    		// 3.如果dependentBeans为空，则两者必然还未确定依赖关系，返回false
    		if (dependentBeans == null) { 
    			return false;
    		}
    		// 4.如果dependentBeans包含dependentBeanName，则表示两者已确定依赖关系，返回true
    		if (dependentBeans.contains(dependentBeanName)) { 
    			return true;
    		}
    		// 5.循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即传递依赖）
    		// 传递依赖:例如：A 依赖了B，B依赖了C，则A也算依赖了C
    		for (String transitiveDependency : dependentBeans) { 
    			if (alreadySeen == null) { 
    				alreadySeen = new HashSet<>();
    			}
    			// 6.已经检查过的添加到alreadySeen，避免重复检查
    			alreadySeen.add(beanName);
    			// 通过迭代的方式，处理传递依赖
    			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) { 
    				return true;
    			}
    		}
    		return false;
    	}

##### 代码块4.5：registerDependentBean #####

这边又引入了一个跟 dependentBeanMap 类似的缓存，dependenciesForBeanMap：beanName -> beanName 对应的 bean 依赖的所有 bean 的 beanName 集合。  
 这两个缓存很容易搞混，举个简单例子：例如B依赖了A，则dependentBeanMap缓存中应该存放一对映射：其中 key为A，value为含有B的Set；而dependenciesForBeanMap缓存中也应该存放一对映射：其中key为：B，value为含有A的Set。

public void registerDependentBean(String beanName, String dependentBeanName) { 
    		// 处理Bean名称，将别名转换为规范的Bean名称
    		String canonicalName = canonicalName(beanName);
    
    		// 4.如果依赖关系还没有注册，则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存
    		synchronized (this.dependentBeanMap) { 
    			// 4.1 将dependentBeanName添加到依赖canonicalName的beanName集合中
    			Set<String> dependentBeans =
    					this.dependentBeanMap.computeIfAbsent(canonicalName,
    							k -> new LinkedHashSet<>(8));
    			// 向容器中：bean名称-->全部依赖Bean名称集合添加Bean的依赖信息
    			// 即，将Bean所依赖的Bean添加到容器的集合中
    			if (!dependentBeans.add(dependentBeanName)) { 
    				return;
    			}
    		}
    
    		synchronized (this.dependenciesForBeanMap) { 
    			// 4.2 将canonicalName添加到dependentBeanName依赖的beanName集合中
    			Set<String> dependenciesForBean =
    					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName,
    							k -> new LinkedHashSet<>(8));
    			dependenciesForBean.add(canonicalName);
    		}
    	}

##### 代码块4.6：getSingleton #####

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
    		Assert.notNull(beanName, "Bean name must not be null");
    		// 1.加锁，避免重复创建单例对象
    		synchronized (this.singletonObjects) { 
    			// 2.首先检查beanName对应的bean实例是否在缓存中存在，如果已经存在，则直接返回
    			Object singletonObject = this.singletonObjects.get(beanName);
    			// 3.beanName对应的bean实例不存在于缓存中，则进行Bean的创建
    			if (singletonObject == null) { 
    				// 4.当bean工厂的单例处于destruction状态时，不允许进行单例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 + "'");
    				}
    				// 5.创建单例前的操作
    				beforeSingletonCreation(beanName);
    				boolean newSingleton = false;
    				// suppressedExceptions用于记录异常相关信息
    				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    				if (recordSuppressedExceptions) { 
    					this.suppressedExceptions = new LinkedHashSet<>();
    				}
    				try { 
    					// 6.执行singletonFactory的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.
    					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;
    					}
    					// 7.创建单例后的操作
    					afterSingletonCreation(beanName);
    				}
    				if (newSingleton) { 
    					// 8.如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）
    					addSingleton(beanName, singletonObject);
    				}
    			}
    			// 9.返回创建出来的单例对象
    			return singletonObject;
    		}
    	}

##### 代码块4.7：beforeSingletonCreation、afterSingletonCreation #####

protected void beforeSingletonCreation(String beanName) { 
    		// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    		// 则将beanName加入到正在创建bean的缓存中（Set），
    		// 如果beanName已经存在于该缓存，会返回false抛出异常（这种情况出现在构造器的循环依赖）
    		if (!this.inCreationCheckExclusions.contains(beanName) 
    		&& !this.singletonsCurrentlyInCreation.add(beanName)) { 
    			throw new BeanCurrentlyInCreationException(beanName);
    		}
    	}
    	protected void afterSingletonCreation(String beanName) { 
    		// 先校验beanName是否为要在创建检查排除掉的（inCreationCheckExclusions缓存），如果不是，
    		// 则将beanName从正在创建bean的缓存中（Set）移除，
    		// 如果beanName不存在于该缓存，会返回false抛出异常
    		if (!this.inCreationCheckExclusions.contains(beanName) 
    		&& !this.singletonsCurrentlyInCreation.remove(beanName)) { 
    			throw new IllegalStateException("Singleton '" + 
    			beanName + "' isn't currently in creation");
    		}
    	}

##### 代码块4.8：beforePrototypeCreation、afterPrototypeCreation #####

该方法上面两个方法类似。主要是在进行 bean 实例的创建前，将 beanName 添加到 prototypesCurrentlyInCreation 缓存；bean 实例创建后，将 beanName 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object，在只有一个 beanName 的时候，直接存该 beanName，也就是 String 类型；当有多个 beanName 时，转成 Set 来存放。

protected void beforePrototypeCreation(String beanName) { 
    		// 1.拿到当前线程中正在创建的prototype的bean的beanName集合
    		Object curVal = this.prototypesCurrentlyInCreation.get();
    		if (curVal == null) { 
    			// 2.如果为空，则将ThreadLocal设置成当前的beanName
    			this.prototypesCurrentlyInCreation.set(beanName);
    		}
    		// 3.如果不为空，并且是String类型，则代表目前只有一个beanName，
    		// 将之前和当前的一起封装成Set<String>，设置到ThreadLocal中
    		else if (curVal instanceof String) { 
    			Set<String> beanNameSet = new HashSet<>(2);
    			beanNameSet.add((String) curVal);
    			beanNameSet.add(beanName);
    			this.prototypesCurrentlyInCreation.set(beanNameSet);
    		}
    		// 4.如果不为空，并且不是String，则必然是Set<String>类型，将当前的beanName加到Set中去
    		else { 
    			Set<String> beanNameSet = (Set<String>) curVal;
    			beanNameSet.add(beanName);
    		}
    	}
    	protected void afterPrototypeCreation(String beanName) { 
    		// 1.拿到当前线程中正在创建的prototype的bean的beanName集合
    		Object curVal = this.prototypesCurrentlyInCreation.get();
    		// 2.如果是String类型，则代表目前只有一个beanName，则直接移除
    		if (curVal instanceof String) { 
    			this.prototypesCurrentlyInCreation.remove();
    		}
    		else if (curVal instanceof Set) { 
    			// 3.如果是Set类型，则从Set从移除beanName
    			Set<String> beanNameSet = (Set<String>) curVal;
    			beanNameSet.remove(beanName);
    			if (beanNameSet.isEmpty()) { 
    				this.prototypesCurrentlyInCreation.remove();
    			}
    		}
    	}

#### 单元测试 ####

留个坑。。

#### 总结 ####

留个坑。。

#### 参考 ####

https://blog.csdn.net/v123411739/article/details/87954818