<bean id="myBean" class="com.example.MyClass">
? ? <property name="property1" value="Value1" />
</bean>

public interface SingletonBeanRegistry {
    // 這個方法用于向注冊表中注冊一個新的單例Bean。參數(shù)beanName是Bean的名稱，而singletonObject則是要注冊的單例對象。
	void registerSingleton(String beanName, Object singletonObject);
	//根據(jù)單例bean的名稱獲取這個單例bean
	@Nullable
	Object getSingleton(String beanName);
     //判斷是不是包含指定名稱的單例bean
	boolean containsSingleton(String beanName);
	 //這個方法返回注冊表中所有已經(jīng)注冊的單例Bean的名稱。返回的是一個字符串?dāng)?shù)組
	String[] getSingletonNames();
     //這個方法返回注冊表中單例bean的數(shù)量
	int getSingletonCount();
     //單例模式下帶來的最嚴(yán)重的問題就是線程安全問題，
	 //getSingletonMutex() 方法在 SingletonBeanRegistry 接口中返回一個mutex（互斥鎖）對象，該對象用于單例Bean的外部同步。
	 // 當(dāng)你需要自定義的同步邏輯或者在進(jìn)行某些需要線程安全保障的操作時，你可以使用這個返回的mutex對象來進(jìn)行同步控制。
	Object getSingletonMutex();
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	//允許保留的警告的最多數(shù)量
	private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;
	//下面的幾個map就是用來存儲Bean的容器了，singletonObjects這個是一個ConcurrentHashMap，它是線程安全的，初始容量為256，用于存儲已經(jīng)完全初始化并可以被使用的單例對象。鍵是bean的名稱，值是對應(yīng)的bean實(shí)例
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    //這個Map存儲了對象工廠（ObjectFactory）,這些工廠負(fù)責(zé)產(chǎn)生單例對象。當(dāng)一個單例bean被創(chuàng)建但未初始化時，它將會被存儲在這個Map中
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    //這個Map存儲了早期的單例對象，即已經(jīng)實(shí)例化但還未完全初始化（例如，還沒有進(jìn)行屬性注入）的bean。這些早期的bean主要用于解決循環(huán)依賴的問題（兩個或者更多的bean彼此依賴，形成了一個依賴的循環(huán)）
	private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
    //這是一個Set，存儲了所有已經(jīng)注冊的單例bean的名字，按照注冊的順序排列
	private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
	//這是一個Set，存儲了當(dāng)前正在創(chuàng)建的bean的名字，這主要用于檢測bean的循環(huán)依賴
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	//這是一個Set，存儲了在創(chuàng)建檢查中被排除的bean的名字。這些bean不會被用于循環(huán)依賴檢查
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	//這是一個Exception的Set，用于收集在創(chuàng)建單例過程中被忽略的異常
	@Nullable
	private Set<Exception> suppressedExceptions;
	//這是一個布爾值，用于標(biāo)識當(dāng)前是否正在銷毀單例beans
	private boolean singletonsCurrentlyInDestruction = false;
    //這是一個Map，用于存儲所有的DisposableBean實(shí)例。DisposableBean是Spring中的一個接口，實(shí)現(xiàn)這個接口的bean在容器銷毀時會調(diào)用其destroy方法，進(jìn)行清理工作
	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
    //這是一個Map，存儲了包含關(guān)系的beans。鍵是包含其他beans的bean的名稱，值是被包含的beans的名稱的Set
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
    //這是一個Map，存儲了依賴關(guān)系的beans。鍵是依賴其他beans的bean的名稱，值是被依賴的beans的名稱的Set
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
	//這是一個Map，存儲了依賴關(guān)系的beans。鍵是被依賴的bean的名稱，值是依賴這個bean的beans的名稱的Set
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
	//這個方法用于向注冊表中注冊一個新的單例 bean。參數(shù) beanName 是 bean 的名稱
	@Override
	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		//判斷參數(shù)是否為空
		Assert.notNull(beanName, "Bean name must not be null");
		Assert.notNull(singletonObject, "Singleton object must not be null");
		//因?yàn)槭菃卫?，所以操作其時不能有別的線程，所以這里需要加鎖
		synchronized (this.singletonObjects) {
			//這句代碼和下面的判斷主要是為了判斷當(dāng)前bean的名稱是否已經(jīng)存在了，如果已經(jīng)存在了就會拋出IllegalStateException異常
			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");
			}
			//調(diào)用addSingleton方法，添加新的bean實(shí)例
			addSingleton(beanName, singletonObject);
		}
	}
	//該方法用于添加新的單例bean
	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			//向singletonObjects這個map中添加新的單例的鍵值對
			this.singletonObjects.put(beanName, singletonObject);
			//singletonFactories保存一個單例bean被創(chuàng)建但未初始，加入到singletonObjects意味著這個單例bean被創(chuàng)建了，所以需要從工廠中移除
			this.singletonFactories.remove(beanName);
			//和上面同樣的道理
			this.earlySingletonObjects.remove(beanName);
			//registeredSingletons存儲已經(jīng)被實(shí)例化的單例bean的名稱，這里將新創(chuàng)建的單例bean的名稱保存到set集合中
			this.registeredSingletons.add(beanName);
		}
	}
    //這個方法的作用是添加一個單例工廠
	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		//
		synchronized (this.singletonObjects) {
			//它首先檢查singletonObjects這個map中是否已經(jīng)包含了給定名稱的bean。如果已經(jīng)包含了，那么這個方法就什么都不做，直接返回。
			if (!this.singletonObjects.containsKey(beanName)) {
				//把給定的singletonFactory添加到singletonFactories這個map中。在這個map中，鍵是bean的名稱，值是對應(yīng)的ObjectFactory
				this.singletonFactories.put(beanName, singletonFactory);
				//從earlySingletonObjects這個map中移除給定名稱的bean。earlySingletonObjects這個map存儲了早期的單例對象，即已經(jīng)實(shí)例化但還未完全初始化的bean。這些早期的bean主要用于解決循環(huán)依賴的問題
				this.earlySingletonObjects.remove(beanName);
				//把給定的bean的名稱添加到registeredSingletons這個set中。registeredSingletons這個set存儲了所有已經(jīng)注冊的單例bean的名稱
				this.registeredSingletons.add(beanName);
			}
		}
	}
    //重寫SingletonBeanRegistry的getSingleton方法，獲得指定名稱的單例bean
	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}
	//主要目的是獲取指定名稱的單例對象。如果需要，它還會創(chuàng)建這個單例對象的早期引用，這段代碼的作用是獲取給定bean名稱的單例實(shí)例。
	// 它首先嘗試從singletonObjects映射中獲取完全初始化的單例實(shí)例。如果無法獲取，則檢查該bean是否正在創(chuàng)建中，如果是，則嘗
	// 試從earlySingletonObjects映射中獲取已實(shí)例化但未完全初始化的單例實(shí)例。如果仍然無法獲取，則根據(jù)allowEarlyReference
	// 參數(shù)的值，決定是否創(chuàng)建早期引用（解決循環(huán)依賴問題）。如果允許創(chuàng)建早期引用，則嘗試從singletonFactories映射中獲取bean工
	// 廠，并使用該工廠創(chuàng)建早期引用。最后，將創(chuàng)建的單例實(shí)例存儲在singletonObjects或earlySingletonObjects映射中，以便后續(xù)使用。
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//嘗試從singletonObjects映射（已經(jīng)完全初始化的單例對象映射）中獲取bean實(shí)例
		Object singletonObject = this.singletonObjects.get(beanName);
		//如果在singletonObjects中找不到對應(yīng)的實(shí)例，且該bean當(dāng)前正在創(chuàng)建中（通過isSingletonCurrentlyInCreation(beanName)檢查），則進(jìn)入下一步
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			//嘗試從earlySingletonObjects映射（已實(shí)例化但未完全初始化的對象映射）中獲取bean實(shí)例
			singletonObject = this.earlySingletonObjects.get(beanName);
			//如果在earlySingletonObjects中也找不到，且參數(shù)allowEarlyReference為true，表示允許創(chuàng)建早期引用(主要是解決循環(huán)依賴問題)，則進(jìn)入下一步
			if (singletonObject == null && allowEarlyReference) {
				synchronized (this.singletonObjects) {
					// 在singletonObjects上同步，確保線程安全，然后再次嘗試從singletonObjects和earlySingletonObjects映射中獲取bean實(shí)例
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							//如果以上嘗試都未能獲取到bean實(shí)例，那么嘗試從singletonFactories映射（存儲bean工廠的映射）中獲取對應(yīng)的bean工廠
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								//如果獲取到了bean工廠，就用它來創(chuàng)建bean實(shí)例（早期引用），然后將這個早期引用存儲在earlySingletonObjects映射中，并從singletonFactories映射中移除對應(yīng)的bean工廠
								singletonObject = singletonFactory.getObject();
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}
	//這個方法可以接受一個名為 singletonFactory 的 ObjectFactory 參數(shù)，它的功能主要是獲取指定名稱的單例對象，如果沒有找到，它將使用提供的 ObjectFactory 來創(chuàng)建一個。
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			//在已經(jīng)初始化的單例中查找指定名稱的bean
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				//如果當(dāng)前正在銷毀單例，這段代碼是Spring框架的一個安全機(jī)制，用于防止在容器正在銷毀單例bean時創(chuàng)建新的單例bean
				//是 Spring Framework 中用于獲取單例對象的核心方法之一。它首先在已經(jīng)初始化的單例對象中查找指定名稱的 bean，
				// 如果找到了就直接返回。如果沒有找到，則會嘗試從指定的工廠中獲取實(shí)例。在獲取實(shí)例之前，它會進(jìn)行循環(huán)依賴檢查，
				// 并記錄是否在單例創(chuàng)建的過程中出現(xiàn)過異常。如果成功獲取到了實(shí)例，則會將其添加到單例對象池中，并返回該實(shí)例。
				// 如果在獲取實(shí)例的過程中出現(xiàn)了異常，則會將異常記錄下來，并拋出 BeanCreationException 異常。
				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 + "'");
				}
				//循環(huán)依賴檢查
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				//recordSuppressedExceptions，記錄是否在單例創(chuàng)建的過程中出現(xiàn)過異常
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				//如果沒有出現(xiàn)過異常，則創(chuàng)建一個新的LinkedHashSet來記錄異常
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					//嘗試從指定的工廠中獲取實(shí)例
					singletonObject = singletonFactory.getObject();
					//標(biāo)記是不是新的實(shí)例
					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;
		}
	}
	//向異常集合中添加新的異常
	protected void onSuppressedException(Exception ex) {
		synchronized (this.singletonObjects) {
			if (this.suppressedExceptions != null && this.suppressedExceptions.size() < SUPPRESSED_EXCEPTIONS_LIMIT) {
				this.suppressedExceptions.add(ex);
			}
		}
	}
   //按照單例的名稱刪除已經(jīng)被初始化的單例對象
	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
	@Override
	public boolean containsSingleton(String beanName) {
		return this.singletonObjects.containsKey(beanName);
	}
    //獲得所有已經(jīng)初始化的實(shí)例的民初
	@Override
	public String[] getSingletonNames() {
		synchronized (this.singletonObjects) {
			return StringUtils.toStringArray(this.registeredSingletons);
		}
	}
	//獲得已經(jīng)初始化的bean的數(shù)量
	@Override
	public int getSingletonCount() {
		synchronized (this.singletonObjects) {
			return this.registeredSingletons.size();
		}
	}
    //用來設(shè)置一個bean是否正在被創(chuàng)建
	public void setCurrentlyInCreation(String beanName, boolean inCreation) {
		Assert.notNull(beanName, "Bean name must not be null");
		//如果正在創(chuàng)建就加入到inCreationCheckExclusions集合中
		if (!inCreation) {
			this.inCreationCheckExclusions.add(beanName);
		}
		//如果沒有在創(chuàng)建，就從這個集合中刪除這個bean（可能這個集合中不存在這個bean的名稱）
		else {
			this.inCreationCheckExclusions.remove(beanName);
		}
	}
    //判斷這個bean是否正在被創(chuàng)建
	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);
	}
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}
	//這段代碼的作用是在創(chuàng)建單例bean之前進(jìn)行檢查，以確保沒有循環(huán)依賴的問題。
	// 如果當(dāng)前正在創(chuàng)建的單例bean已經(jīng)在創(chuàng)建過程中，則會拋出一個BeanCurrentlyInCreationException異常。
	// 如果beanName不在inCreationCheckExclusions列表中，則會將其添加到singletonsCurrentlyInCreation集合中，
	// 以便檢查循環(huán)依賴。
	protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
    //這段代碼是 Spring Framework 中用于在單例對象創(chuàng)建完成之后進(jìn)行的一些清理工作的方法之一。它會檢查當(dāng)前單例對象是否處于創(chuàng)建狀態(tài)，如果是，
	// 則將其從單例對象的創(chuàng)建集合中移除。如果單例對象不處于創(chuàng)建狀態(tài)，則會拋出 IllegalStateException 異常，提示該單例對象并不處于創(chuàng)建狀態(tài)。
	//在 Spring Framework 中，為了避免循環(huán)依賴的問題，它會在創(chuàng)建單例對象之前先將該對象的名稱添加到單例對象的創(chuàng)建集合中。在單例對象創(chuàng)建完成之后，
	// 就需要將其從創(chuàng)建集合中移除，以便下一次獲取該單例對象時不會再次觸發(fā)循環(huán)依賴檢查
	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的集合
	public void registerDisposableBean(String beanName, DisposableBean bean) {
		synchronized (this.disposableBeans) {
			this.disposableBeans.put(beanName, bean);
		}
	}
    //這段代碼是 Spring Framework 中用于注冊一個 Bean 包含的其他 Bean 的方法之一。它會將被包含的 Bean 的名稱和包含它的 Bean 的名稱作為參數(shù)傳入，
	// 然后將被包含的 Bean 的名稱添加到包含它的 Bean 的 containedBeanMap 屬性中。如果 containedBeanMap 中已經(jīng)存在該被包含的 Bean，則直接返回，
	// 否則將其添加到 containedBeanMap 中。接著，該方法會調(diào)用 registerDependentBean 方法，將被包含的 Bean 和包含它的 Bean 之間建立依賴關(guān)系，
	// 以確保在包含它的 Bean 銷毀時，被包含的 Bean 也會被銷毀。
	public void registerContainedBean(String containedBeanName, String containingBeanName) {
		synchronized (this.containedBeanMap) {
			//如果指定的containingBeanName在containedBeanMap中不存砸，就創(chuàng)建一個新的LinkedHashSet，
			//computeIfAbsent 是 Java 8 中 Map 接口新增的方法，它的作用是：如果指定 key 對應(yīng)的 value 不存在，就使用 mappingFunction 計算出新的 value，
			// 并將其存儲到 Map 中。如果指定 key 對應(yīng)的 value 已經(jīng)存在，則直接返回該 value，不會再次執(zhí)行 mappingFunction。
			Set<String> containedBeans =
					this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
			if (!containedBeans.add(containedBeanName)) {
				return;
			}
		}
		registerDependentBean(containedBeanName, containingBeanName);
	}
	public void registerDependentBean(String beanName, String dependentBeanName) {
		String canonicalName = canonicalName(beanName);
		synchronized (this.dependentBeanMap) {
			Set<String> dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
			dependenciesForBean.add(canonicalName);
		}
	}
	//判讀兩個bean是否有依賴關(guān)系
	protected boolean isDependent(String beanName, String dependentBeanName) {
		synchronized (this.dependentBeanMap) {
			return isDependent(beanName, dependentBeanName, null);
		}
	}
	private boolean isDependent(String beanName, String dependentBeanName, @Nullable 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<>();
			}
			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];
		}
		synchronized (this.dependentBeanMap) {
			return StringUtils.toStringArray(dependentBeans);
		}
	}
	public String[] getDependenciesForBean(String beanName) {
		Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
		if (dependenciesForBean == null) {
			return new String[0];
		}
		synchronized (this.dependenciesForBeanMap) {
			return StringUtils.toStringArray(dependenciesForBean);
		}
	}
   //銷毀單例bean
	public void destroySingletons() {
		if (logger.isTraceEnabled()) {
			logger.trace("Destroying singletons in " + this);
		}
		synchronized (this.singletonObjects) {
			//用來標(biāo)記當(dāng)前正在執(zhí)行銷毀過程，不能再創(chuàng)建新的bean
			this.singletonsCurrentlyInDestruction = true;
		}
		String[] disposableBeanNames;
		synchronized (this.disposableBeans) {
			//獲得當(dāng)前正在銷毀集合中的bean的名稱
			disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
		}
		for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
			//調(diào)用銷毀方法
			destroySingleton(disposableBeanNames[i]);
		}
        //刪除所有的依賴關(guān)系
		this.containedBeanMap.clear();
		this.dependentBeanMap.clear();
		this.dependenciesForBeanMap.clear();
		clearSingletonCache();
	}
	protected void clearSingletonCache() {
		synchronized (this.singletonObjects) {
			//刪除所有的bean存儲信息
			this.singletonObjects.clear();
			this.singletonFactories.clear();
			this.earlySingletonObjects.clear();
			this.registeredSingletons.clear();
			this.singletonsCurrentlyInDestruction = false;
		}
	}
	//銷毀指定的名稱的bean
	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);
	}
	//刪除該單例的依賴信息
	protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
		// Trigger destruction of dependent beans first...
		Set<String> 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<String> 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<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();
				}
			}
		}
		// Remove destroyed bean's prepared dependency information.
		this.dependenciesForBeanMap.remove(beanName);
	}
	/**
	 * Exposes the singleton mutex to subclasses and external collaborators.
	 * <p>Subclasses should synchronize on the given Object if they perform
	 * any sort of extended singleton creation phase. In particular, subclasses
	 * should <i>not</i> have their own mutexes involved in singleton creation,
	 * to avoid the potential for deadlocks in lazy-init situations.
	 */
	@Override
	public final Object getSingletonMutex() {
		return this.singletonObjects;
	}
}

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
? @Override
?? ?public Object getBean(String name) throws BeansException {
?? ??? ?return doGetBean(name, null, null, false);
?? ?}
?? ?@Override
?? ?public Object getBean(String name) throws BeansException {
?? ??? ?return doGetBean(name, null, null, false);
?? ?}
? ? //獲得指定類型的bean
?? ?@Override
?? ?public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
?? ??? ?return doGetBean(name, requiredType, null, false);
?? ?}
? ? //獲得指定名稱的bean，并提供構(gòu)造參數(shù)（沒有創(chuàng)建時可以創(chuàng)建）
?? ?@Override
?? ?public Object getBean(String name, Object... args) throws BeansException {
?? ??? ?return doGetBean(name, null, args, false);
?? ?}
?? ?public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
?? ??? ??? ?throws BeansException {
?? ??? ?return doGetBean(name, requiredType, args, false);
?? ?}
?? ?protected <T> T doGetBean(
?? ??? ??? ?String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
?? ??? ??? ?throws BeansException {
? ? ? ? //在 Spring 中，Bean 名稱可以包含特殊字符，比如點(diǎn)號（.）和斜杠（/），這些特殊字符在 Bean 的定義中具有特殊的含義。
?? ??? ?// 為了避免這些特殊字符帶來的問題，Spring 使用了一個默認(rèn)的分隔符（默認(rèn)為點(diǎn)號），將 Bean 名稱中的特殊字符替換成默認(rèn)分隔符。
?? ??? ?String beanName = transformedBeanName(name);
?? ??? ?Object bean;
?? ??? ?//調(diào)用DefaultSingletonBeanRegistry的getSingleton方法，如果是單例就直接獲取
?? ??? ?Object sharedInstance = getSingleton(beanName);
?? ??? ?//AbstractBeanFactory
?? ??? ?if (sharedInstance != null && args == null) {
?? ??? ??? ?//判斷是否開啟類Trace級別的日志記錄
?? ??? ??? ?if (logger.isTraceEnabled()) {
?? ??? ??? ??? ?//判斷該單例對象是否正在創(chuàng)建
?? ??? ??? ??? ?if (isSingletonCurrentlyInCreation(beanName)) {
?? ??? ??? ??? ??? ?//記錄日志（提示該bean是一個早期引用還沒被初始化）
?? ??? ??? ??? ??? ?logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
?? ??? ??? ??? ??? ??? ??? ?"' that is not fully initialized yet - a consequence of a circular reference");
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else {
?? ??? ??? ??? ??? ?//提示該bean是一個緩沖實(shí)例（已經(jīng)被初始化類）
?? ??? ??? ??? ??? ?logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?//getObjectForBeanInstance ?方法是 AbstractAutowireCapableBeanFactory 類的一個私有方法，
?? ??? ??? ?// 用于從 Bean 實(shí)例中獲取對應(yīng)的 Bean 對象。
?? ??? ??? ?bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
?? ??? ?}
?? ??? ?//如果沒有找到指定的單例bean對象，此時就需要創(chuàng)建這個bean了
?? ??? ?else {
?? ??? ??? ?//它首先檢查指定名稱的Bean單例實(shí)例是否正在創(chuàng)建中，如果是，則拋出BeanCurrentlyInCreationException異常。
?? ??? ??? ?// 這是為了避免在Bean實(shí)例創(chuàng)建期間發(fā)生循環(huán)依賴或重復(fù)創(chuàng)建的情況
?? ??? ??? ?if (isPrototypeCurrentlyInCreation(beanName)) {
?? ??? ??? ??? ?throw new BeanCurrentlyInCreationException(beanName);
?? ??? ??? ?}
? ? ? ? ? ? //創(chuàng)建創(chuàng)建Bean的父工廠
?? ??? ??? ?BeanFactory parentBeanFactory = getParentBeanFactory();
?? ??? ??? ?//如果父工廠不為空，且工廠中有該Bean
?? ??? ??? ?if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
?? ??? ??? ??? ?//轉(zhuǎn)換Bean的名稱
?? ??? ??? ??? ?String nameToLookup = originalBeanName(name);
?? ??? ??? ??? ?//如果父工廠的類型是AbstractBeanFactory或是其子類
?? ??? ??? ??? ?if (parentBeanFactory instanceof AbstractBeanFactory) {
?? ??? ??? ??? ??? ?//調(diào)用doGetBean方法
?? ??? ??? ??? ??? ?return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
?? ??? ??? ??? ??? ??? ??? ?nameToLookup, requiredType, args, typeCheckOnly);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else if (args != null) {
?? ??? ??? ??? ??? ?//如果帶有參數(shù)，就調(diào)用帶參數(shù)的getBean方法
?? ??? ??? ??? ??? ?return (T) parentBeanFactory.getBean(nameToLookup, args);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else if (requiredType != null) {
?? ??? ??? ??? ??? ?// 沒有參數(shù)就會調(diào)用默認(rèn)的getBean的方法
?? ??? ??? ??? ??? ?return parentBeanFactory.getBean(nameToLookup, requiredType);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else {
?? ??? ??? ??? ??? ?//如果父類工廠不是AbstractBeanFactory或其子類，就會調(diào)用這個工廠的getBean方法
?? ??? ??? ??? ??? ?return (T) parentBeanFactory.getBean(nameToLookup);
?? ??? ??? ??? ?}
?? ??? ??? ?}
? ? ? ? ? ? //標(biāo)記該bean為已創(chuàng)建，將其添加到已創(chuàng)建bean的集合中，這樣可以防止重復(fù)創(chuàng)建
?? ??? ??? ?if (!typeCheckOnly) {
?? ??? ??? ??? ?markBeanAsCreated(beanName);
?? ??? ??? ?}
? ? ? ? ? ? //創(chuàng)建一個 StartupStep 實(shí)例，這是Spring的新特性，用于監(jiān)控應(yīng)用的啟動過程，可以幫助我們更好地理解和優(yōu)化應(yīng)用的啟動過程
?? ??? ??? ?StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
?? ??? ??? ??? ??? ?.tag("beanName", name);
?? ??? ??? ?try {
?? ??? ??? ??? ?if (requiredType != null) {
?? ??? ??? ??? ??? ?beanCreation.tag("beanType", requiredType::toString);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?//通過 getMergedLocalBeanDefinition(beanName) 獲取Bean的合并后的定義信息，即 RootBeanDefinition
?? ??? ??? ??? ?RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
?? ??? ??? ??? ?//檢查獲取的 RootBeanDefinition。如果bean定義的信息有問題，比如說定義的類不能被實(shí)例化，那么這個方法會拋出異常
?? ??? ??? ??? ?checkMergedBeanDefinition(mbd, beanName, args);
?? ??? ??? ??? ?//獲取該beam所依賴的bean
?? ??? ??? ??? ?String[] dependsOn = mbd.getDependsOn();
?? ??? ??? ??? ?if (dependsOn != null) {
?? ??? ??? ??? ??? ?for (String dep : dependsOn) {
?? ??? ??? ??? ??? ??? ?//存在循環(huán)依賴的問題，拋出異常
?? ??? ??? ??? ??? ??? ?if (isDependent(beanName, dep)) {
?? ??? ??? ??? ??? ??? ??? ?throw new BeanCreationException(mbd.getResourceDescription(), beanName,
?? ??? ??? ??? ??? ??? ??? ??? ??? ?"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
?? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ??? ?//將這些依賴關(guān)系注冊到依賴管理的數(shù)據(jù)結(jié)構(gòu)中（通過 registerDependentBean(dep, beanName)）
?? ??? ??? ??? ??? ??? ?registerDependentBean(dep, beanName);
?? ??? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ??? ?//獲取Bean
?? ??? ??? ??? ??? ??? ??? ?getBean(dep);
?? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ??? ?catch (NoSuchBeanDefinitionException ex) {
?? ??? ??? ??? ??? ??? ??? ?throw new BeanCreationException(mbd.getResourceDescription(), beanName,
?? ??? ??? ??? ??? ??? ??? ??? ??? ?"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
?? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ?}
? ? ? ? ? ? ? ? //判斷是不是單例bean
?? ??? ??? ??? ?// Create bean instance.
?? ??? ??? ??? ?if (mbd.isSingleton()) {
?? ??? ??? ??? ??? ?sharedInstance = getSingleton(beanName, () -> {
?? ??? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ??? ?//創(chuàng)建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;
?? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?});
?? ??? ??? ??? ??? ?//將新創(chuàng)建的單例對象賦值給bean
?? ??? ??? ??? ??? ?bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
?? ??? ??? ??? ?}
? ? ? ? ? ? ? ? ?//如果是原型作用域
?? ??? ??? ??? ?else if (mbd.isPrototype()) {
?? ??? ??? ??? ??? ?// It's a prototype -> create a new instance.
?? ??? ??? ??? ??? ?Object prototypeInstance = null;
?? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ?//beforePrototypeCreation(beanName) 和 afterPrototypeCreation(beanName) 是在Bean創(chuàng)建前后的擴(kuò)展點(diǎn)，
?? ??? ??? ??? ??? ??? ?// 用于執(zhí)行一些自定義的邏輯。
?? ??? ??? ??? ??? ??? ?beforePrototypeCreation(beanName);
?? ??? ??? ??? ??? ??? ?//創(chuàng)建原型bean
?? ??? ??? ??? ??? ??? ?prototypeInstance = createBean(beanName, mbd, args);
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?finally {
?? ??? ??? ??? ??? ??? ?afterPrototypeCreation(beanName);
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?//將創(chuàng)建的原型bean賦值給bean
?? ??? ??? ??? ??? ?bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
?? ??? ??? ??? ?}
? ? ? ? ? ? ? ? //處理自定義作用域
?? ??? ??? ??? ?else {
?? ??? ??? ??? ??? ?//獲得作用域
?? ??? ??? ??? ??? ?String scopeName = mbd.getScope();
?? ??? ??? ??? ??? ?//判斷Scope是否為空
?? ??? ??? ??? ??? ?if (!StringUtils.hasLength(scopeName)) {
?? ??? ??? ??? ??? ??? ?throw new IllegalStateException("No scope name defined for bean ′" + beanName + "'");
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?//獲得作用域的名稱
?? ??? ??? ??? ??? ?Scope scope = this.scopes.get(scopeName);
?? ??? ??? ??? ??? ?if (scope == null) {
?? ??? ??? ??? ??? ??? ?throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ?//這個get方法是scope.java中的一個方法，這里用lamda表達(dá)式實(shí)現(xiàn)了生成該bean的工廠
?? ??? ??? ??? ??? ??? ?Object scopedInstance = scope.get(beanName, () -> {
?? ??? ??? ??? ??? ??? ??? ?//Bean創(chuàng)建前的擴(kuò)展電
?? ??? ??? ??? ??? ??? ??? ?beforePrototypeCreation(beanName);
?? ??? ??? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ??? ??? ?//創(chuàng)建Bean
?? ??? ??? ??? ??? ??? ??? ??? ?return createBean(beanName, mbd, args);
?? ??? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ??? ??? ?finally {
?? ??? ??? ??? ??? ??? ??? ??? ?//Bean創(chuàng)建后的擴(kuò)展點(diǎn)
?? ??? ??? ??? ??? ??? ??? ??? ?afterPrototypeCreation(beanName);
?? ??? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ??? ?});
?? ??? ??? ??? ??? ??? ?//將生成的Bean賦值給bean
?? ??? ??? ??? ??? ??? ?bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?catch (IllegalStateException ex) {
?? ??? ??? ??? ??? ??? ?throw new ScopeNotActiveException(beanName, scopeName, ex);
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?catch (BeansException ex) {
?? ??? ??? ??? ?beanCreation.tag("exception", ex.getClass().toString());
?? ??? ??? ??? ?beanCreation.tag("message", String.valueOf(ex.getMessage()));
?? ??? ??? ??? ?cleanupAfterBeanCreationFailure(beanName);
?? ??? ??? ??? ?throw ex;
?? ??? ??? ?}
?? ??? ??? ?finally {
?? ??? ??? ??? ?//標(biāo)記創(chuàng)建bean完成
?? ??? ??? ??? ?beanCreation.end();
?? ??? ??? ?}
?? ??? ?}
? ? ? ? //這段代碼處理的是返回Bean的類型轉(zhuǎn)換。當(dāng)用戶在獲取Bean時指定了目標(biāo)類型，Spring會確保返回的Bean是指定類型或者可以轉(zhuǎn)換為指定類型的實(shí)例
?? ??? ?if (requiredType != null && !requiredType.isInstance(bean)) {
?? ??? ??? ?//檢查Bean是否是指定的類型以及用戶是有指定了類型
?? ??? ??? ?try {
?? ??? ??? ??? ?//如果不是指定的類型，則嘗試進(jìn)行類型轉(zhuǎn)換。這是通過 getTypeConverter().convertIfNecessary(bean, requiredType) 方法完成的，
?? ??? ??? ??? ?// 其中 getTypeConverter() 返回Bean工廠使用的類型轉(zhuǎn)換器，convertIfNecessary 嘗試將Bean轉(zhuǎn)換為目標(biāo)類型。
?? ??? ??? ??? ?T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
?? ??? ??? ??? ?if (convertedBean == null) {
?? ??? ??? ??? ??? ?//如果類型轉(zhuǎn)換成功，返回轉(zhuǎn)換后的Bean。如果轉(zhuǎn)換失敗或者轉(zhuǎn)換后的Bean為null，拋出 BeanNotOfRequiredTypeException 異常。
?? ??? ??? ??? ??? ?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());
?? ??? ??? ?}
?? ??? ?}
?? ??? ?//返回bean
?? ??? ?return (T) bean;
?? ?}
?? ?//創(chuàng)建Bean的方法是一個抽象方法交給子類實(shí)現(xiàn)
? ? ?protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
?? ??? ??? ?throws BeanCreationException;
?? ?//解析和返回給定的 RootBeanDefinition 的Bean類。在Spring中，Bean類是Bean的實(shí)例化和裝配的基礎(chǔ)，因此需要對其進(jìn)行解析。
?? ?//將在Spring配置中指定的Bean的類名解析為Java Class對象的過程
?? ?@Nullable
?? ?protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
?? ??? ??? ?throws CannotLoadBeanClassException {
?? ??? ?try {
?? ??? ??? ?//通過調(diào)用 mbd.hasBeanClass() 來檢查 RootBeanDefinition 是否已經(jīng)有了關(guān)聯(lián)的Bean類
?? ??? ??? ?if (mbd.hasBeanClass()) {
?? ??? ??? ??? ?return mbd.getBeanClass();
?? ??? ??? ?}
?? ??? ??? ?//如果還沒有關(guān)聯(lián)的Bean類，那么就需要解析Bean類。這里有兩種情況需要考慮：如果系統(tǒng)中已經(jīng)啟用了安全管理器，那么就需要使用 AccessController.doPrivileged
?? ??? ??? ?// 來解析Bean類，確保在解析過程中能夠正確地管理權(quán)限；如果沒有啟用安全管理器，那么就直接解析Bean類，這是通過 doResolveBeanClass(mbd, typesToMatch) 實(shí)現(xiàn)的
?? ??? ??? ?if (System.getSecurityManager() != null) {
?? ??? ??? ??? ?return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
?? ??? ??? ??? ??? ??? ?() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
?? ??? ??? ?}
?? ??? ??? ?else {
?? ??? ??? ??? ?return doResolveBeanClass(mbd, typesToMatch);
?? ??? ??? ?}
?? ??? ?}
?? ??? ?catch (PrivilegedActionException pae) {
?? ??? ??? ?ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
?? ??? ??? ?throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
?? ??? ?}
?? ??? ?catch (ClassNotFoundException ex) {
?? ??? ??? ?throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
?? ??? ?}
?? ??? ?catch (LinkageError err) {
?? ??? ??? ?throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
?? ??? ?}
?? ?}
? ? //解析bean類的函數(shù)主體
?? ?@Nullable
?? ?private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
?? ??? ??? ?throws ClassNotFoundException {
? ? ? ? ?//它獲取 Bean 的 ClassLoader，這是用于加載 Bean 類的類加載器。同時，也可能
?? ??? ?ClassLoader beanClassLoader = getBeanClassLoader();
?? ??? ?ClassLoader dynamicLoader = beanClassLoader;
?? ??? ?boolean freshResolve = false;
?? ??? ?if (!ObjectUtils.isEmpty(typesToMatch)) {
?? ??? ??? ?//獲取一個臨時的類加載器（如果存在的話），在特定的情況下（如織入場景）可能會用到
?? ??? ??? ?ClassLoader tempClassLoader = getTempClassLoader();
?? ??? ??? ?if (tempClassLoader != null) {
?? ??? ??? ??? ?dynamicLoader = tempClassLoader;
?? ??? ??? ??? ?freshResolve = true;
?? ??? ??? ??? ?if (tempClassLoader instanceof DecoratingClassLoader) {
?? ??? ??? ??? ??? ?DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
?? ??? ??? ??? ??? ?for (Class<?> typeToMatch : typesToMatch) {
?? ??? ??? ??? ??? ??? ?dcl.excludeClass(typeToMatch.getName());
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ?}
? ? ? ? ? //獲得bean的類名
?? ??? ?String className = mbd.getBeanClassName();
?? ??? ?//如果bean的類名不為空
?? ??? ?if (className != null) {
?? ??? ??? ?//對bean的類名其進(jìn)行評估。評估可能涉及到動態(tài)解析表達(dá)式。如果類名不等于評估的結(jié)果（說明類名被動態(tài)解析了），并且解析結(jié)果是 Class 類型或 String 類型，
?? ??? ??? ?// 那么將返回解析結(jié)果的 Class 對象或重新解析類名字符串為 Class 對象。對于其他類型的評估結(jié)果，會拋出異常
?? ??? ??? ?Object evaluated = evaluateBeanDefinitionString(className, mbd);
?? ??? ??? ?if (!className.equals(evaluated)) {
?? ??? ??? ??? ?// A dynamically resolved expression, supported as of 4.2...
?? ??? ??? ??? ?if (evaluated instanceof Class) {
?? ??? ??? ??? ??? ?return (Class<?>) evaluated;
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else if (evaluated instanceof String) {
?? ??? ??? ??? ??? ?className = (String) evaluated;
?? ??? ??? ??? ??? ?freshResolve = true;
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else {
?? ??? ??? ??? ??? ?throw new IllegalStateException("Invalid class name expression result: " + evaluated);
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?//如果類名被動態(tài)解析了（即，解析結(jié)果是 String 類型的類名，而不是原來的類名），代碼會嘗試用當(dāng)前的類加載器（可能是臨時的類加載器）加載類。如果加載失敗，會再嘗試用 ClassUtils.forName 方法加載類
?? ??? ??? ?if (freshResolve) {
?? ??? ??? ??? ?// When resolving against a temporary class loader, exit early in order
?? ??? ??? ??? ?// to avoid storing the resolved Class in the bean definition.
?? ??? ??? ??? ?if (dynamicLoader != null) {
?? ??? ??? ??? ??? ?try {
?? ??? ??? ??? ??? ??? ?return dynamicLoader.loadClass(className);
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?catch (ClassNotFoundException ex) {
?? ??? ??? ??? ??? ??? ?if (logger.isTraceEnabled()) {
?? ??? ??? ??? ??? ??? ??? ?logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
?? ??? ??? ??? ??? ??? ?}
?? ??? ??? ??? ??? ?}
?? ??? ??? ??? ?}
?? ??? ??? ??? ?return ClassUtils.forName(className, dynamicLoader);
?? ??? ??? ?}
?? ??? ?}
?? ??? ?// Resolve regularly, caching the result in the BeanDefinition...
?? ??? ?//如果類名沒有被動態(tài)解析（即，類名等于評估的結(jié)果），代碼會正常解析類，并將解析結(jié)果（即 Class 對象）緩存到 Bean 定義中
?? ??? ?return mbd.resolveBeanClass(beanClassLoader);
?? ?}
}

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
		@Override
	@SuppressWarnings("unchecked")
	public <T> T createBean(Class<T> beanClass) throws BeansException {
		//這行代碼創(chuàng)建了一個新的 RootBeanDefinition 對象，該對象描述了Bean的定義。這是通過傳入的類（beanClass）作為參數(shù)創(chuàng)建的
		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
		//這行代碼將Bean定義的作用域設(shè)置為原型
		bd.setScope(SCOPE_PROTOTYPE);
		//這行代碼檢查給定的類是否安全地緩存在共享的可擴(kuò)展類加載器上。如果是，則允許緩存該Bean的元數(shù)據(jù)
		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
		return (T) createBean(beanClass.getName(), bd, null);
	}
	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
        //是否開啟了Trace級別的日志
		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		//創(chuàng)建RooteBenaDefinition對象mbdToduse
		RootBeanDefinition mbdToUse = mbd;
		//用來解析類名（這是父類AbstractBeanFactory中實(shí)現(xiàn)的方法）它嘗試解析給定的類名并返回 Class 對象
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			//如果 mbd（Bean 定義）還沒有類對象，并且 mbd 的類名不為 null，則創(chuàng)建一個新的 RootBeanDefinition 對象，并設(shè)置其類
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
        //準(zhǔn)備方法覆蓋
		//這一步調(diào)用 mbdToUse 的 prepareMethodOverrides 方法，用于驗(yàn)證和準(zhǔn)備覆蓋的方法。如果驗(yàn)證失敗，則拋出一個異常
		try {
			//prepareMethodOverrides 是 RootBeanDefinition 的一個方法，主要用于處理和驗(yàn)證 Bean 定義中的方法覆蓋（method overrides）設(shè)置。
			// 這個設(shè)置主要用于在 Spring IoC 容器中覆蓋或者替換 Spring 管理的 Bean 中的某個方法的行為，這樣在后續(xù)創(chuàng)建 Bean 實(shí)例時，就可以根據(jù)這些設(shè)置來確定方法的行為。
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}
		try {
			//在實(shí)例化 Bean 之前，給 BeanPostProcessors 一個機(jī)會返回一個代理實(shí)例而不是目標(biāo) Bean 實(shí)例。如果這個步驟返回的 Bean 不為 null，那么就直接返回這個 Bean。如果在這個步驟出現(xiàn)異常，則拋出一個異常
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}
		try {
			//這里開始創(chuàng)建真正的bean實(shí)例
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		//在Spring框架中，BeanWrapper接口是用于處理Bean屬性的主要接口。BeanWrapper的作用是設(shè)置和獲取屬性值（單個或批量），獲取屬性描述符，以及查詢設(shè)置屬性值的能力。
		//BeanWrapper擴(kuò)展了 PropertyAccessor，這是所有Spring的屬性訪問器實(shí)現(xiàn)的基本接口，包括 BeanWrapper。 BeanWrapper 也提供了分析和管理的方法，以處理嵌套的路徑和類型轉(zhuǎn)換。
		//當(dāng)創(chuàng)建一個新的Bean實(shí)例并對其進(jìn)行填充（例如，從XML配置文件中讀取的屬性值）時，Spring使用 BeanWrapper。同樣，當(dāng)Spring需要讀取或修改現(xiàn)有Bean實(shí)例的屬性時，也會使用 BeanWrapper。
		BeanWrapper instanceWrapper = null;
		//判斷RootbeanDefinition對象的類型
		if (mbd.isSingleton()) {
            //factoryBeanInstanceCache這個集合中，一個bean的名稱對應(yīng)一個BeanWrapper，如果是當(dāng)例模式我們就刪除這對映射關(guān)系
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//表示不是單例模式
		if (instanceWrapper == null) {
			// 使用 createBeanInstance 方法實(shí)例化 Bean。這個過程可能會調(diào)用構(gòu)造函數(shù)或工廠方法，或者在特殊情況下，例如對于 FactoryBean 或者通過 CGLIB 創(chuàng)建的 Bean，可能會使用特定的實(shí)例化策略
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		//由BeanWrapper獲得Bean對象
		Object bean = instanceWrapper.getWrappedInstance();
		//獲得該bean的類型（即對應(yīng)的class對象）
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		//用于在應(yīng)用程序上下文中創(chuàng)建bean時執(zhí)行后處理程序。具體來說，它確保應(yīng)用所有合并的bean定義的后處理程序，并且只在第一次創(chuàng)建bean時執(zhí)行。如果在后處理程序期間發(fā)生異常，則會拋出BeanCreationException
		synchronized (mbd.postProcessingLock) {
			//這段代碼的作用是確保在創(chuàng)建應(yīng)用程序上下文中的bean時，應(yīng)用所有合并的bean定義的后處理程序，并且只在第一次創(chuàng)建bean時執(zhí)行。如果在后處理程序期間發(fā)生異常，則會拋出BeanCreationException
			if (!mbd.postProcessed) {
				try {
					//調(diào)用applyMergedBeanDefinitionPostProcessors方法，該方法用于應(yīng)用所有已注冊的MergedBeanDefinitionPostProcessor對象，
					// 以修改BeanDefinition對象的屬性值
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				//將BeanDefinition對象的postProcessed屬性設(shè)置為true，表示已經(jīng)完成了所有的后處理操作。
				mbd.postProcessed = true;
			}
		}
        //檢查BeanDefinition對象的isSingleton方法是否返回true，檢查是否允許循環(huán)引用，以及檢查當(dāng)前單例對象是否正在創(chuàng)建中
		// 用于檢查是否允許在創(chuàng)建Bean對象時提前曝光一個單例對象
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			//將當(dāng)前對象添加到一個單例工廠
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		//初始化bean實(shí)例
		Object exposedObject = bean;
		try {
			//調(diào)用 populateBean 方法，該方法用于填充 Bean 的屬性值。
			populateBean(beanName, mbd, instanceWrapper);
			//調(diào)用 initializeBean 方法，該方法用于初始化 Bean，并返回一個可公開的 Bean 對象
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}
        //檢查是夠需要提前暴露單例bean，以避免循環(huán)引用問題
		if (earlySingletonExposure) {
			//根據(jù)bean的名稱獲得這個單例bean
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {//如果 Bean 實(shí)例是集合 BeanWrapper 獲得的，則將其替換為提前暴露的單例 Bean 實(shí)例（類型檢查）
					exposedObject = earlySingletonReference;
				}
				//這段代碼的作用是在檢查循環(huán)依賴時，如果某個 Bean 的依賴中存在“原始”版本的 Bean，則拋出異常。具體來說，它會檢查當(dāng)前 Bean 是否存在依賴關(guān)系，
				// 如果存在，則遍歷依賴關(guān)系中的每個 Bean，如果該 Bean 不是僅用于類型檢查，則將其添加到 actualDependentBeans 集合中。如果 actualDependentBeans 
				// 不為空，則拋出 BeanCurrentlyInCreationException 異常，該異常表示當(dāng)前 Bean 正在創(chuàng)建過程中，但其依賴的其他 Bean 已經(jīng)使用了它的“原始”版本，
				// 而不是最終版本。這通常是類型匹配過于“熱切”的結(jié)果，可以通過關(guān)閉 allowEagerInit 標(biāo)志來解決。
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					//遍歷每一依賴的bean
					for (String dependentBean : dependentBeans) {
						//如果一個單例 Bean 只是為了類型檢查而被創(chuàng)建，就從單例緩存中移除該 Bean。
						//在 Spring 容器中，當(dāng)一個 Bean 的依賴被注入時，Spring 會檢查這些依賴的類型是否匹配。如果依賴的類型不匹配，Spring 會拋出異常。
						// 為了避免這種情況，Spring 會在創(chuàng)建 Bean 實(shí)例之前，先創(chuàng)建一個“原型” Bean 實(shí)例，用來檢查依賴的類型是否正確。如果類型匹配，再創(chuàng)
						// 建真正的 Bean 實(shí)例。這個“原型” Bean 實(shí)例就是為了類型檢查而被創(chuàng)建的。
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							// actualDependentBeans.add(dependentBean) 的作用是將dependentBean添加到 
							// `actualDependentBeans`  集合中。在這段代碼中，它的作用是將當(dāng)前 Bean 的依賴中不是僅用于
							// 類型檢查的 Bean 添加到  `actualDependentBeans`  集合中，以便后續(xù)判斷是否存在循環(huán)依賴。
							actualDependentBeans.add(dependentBean);
						}
					}
					//"類型匹配過于熱切" 是指在 Spring 容器中，當(dāng)容器在創(chuàng)建 Bean 的時候，會嘗試去匹配該 Bean 所依賴的其他 Bean 的類型。
					// 如果匹配成功，就會將這些依賴注入到該 Bean 中。但是有時候，容器會過于熱切地去匹配這些依賴，導(dǎo)致匹配出來的 Bean 并不
					// 是最終的 Bean 實(shí)例，而是用于類型檢查的“原型” Bean 實(shí)例。這樣就可能會導(dǎo)致循環(huán)依賴等問題。因此，建議在使用類型匹配時，
					// 要謹(jǐn)慎使用，避免出現(xiàn)這種情況。
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}
		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}
		return exposedObject;
	}
	@Override
	public int getBeanDefinitionCount() {
		return this.beanDefinitionMap.size();
	}
}

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
?? ??? ?implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
?? ??? ?//將bean的名稱以及對應(yīng)的BeanDefinition關(guān)聯(lián)起來的集合
?? ??? ?private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
?? ??? ?public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
?? ??? ??? ?throws BeanDefinitionStoreException {
?? ??? ?Assert.hasText(beanName, "Bean name must not be empty");
?? ??? ?Assert.notNull(beanDefinition, "BeanDefinition must not be null");
? ? ? ? //判斷beanDefinition的類型是不是AbstractBeanDefinition
?? ??? ?if (beanDefinition instanceof AbstractBeanDefinition) {
?? ??? ??? ?try {
?? ??? ??? ??? ?/**
?? ??? ??? ??? ? * validate方法是AbstractBeanDefinition的一個方法，它用于驗(yàn)證bean定義的內(nèi)容是否有效。具體來說，它會檢查如下幾個方面：
?? ??? ??? ??? ? * 1. bean的類名是否已經(jīng)設(shè)置，或者至少factory bean的名稱和工廠方法已經(jīng)設(shè)置
?? ??? ??? ??? ? * 2. 如果bean是單例，那么它不能同時是抽象的和lazy-init的
?? ??? ??? ??? ? * 3. bean的方法覆蓋是否有效
?? ??? ??? ??? ? * 4. 如果bean有父bean，那么父bean必須已經(jīng)存在
?? ??? ??? ??? ? * 5. 其他一些基本的合法性檢查
?? ??? ??? ??? ? */
?? ??? ??? ??? ?((AbstractBeanDefinition) beanDefinition).validate();
?? ??? ??? ?}
?? ??? ??? ?catch (BeanDefinitionValidationException ex) {
?? ??? ??? ??? ?throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
?? ??? ??? ??? ??? ??? ?"Validation of bean definition failed", ex);
?? ??? ??? ?}
?? ??? ?}
? ? ? ? //查看當(dāng)前的bean是否已經(jīng)存在beanDefinition了
?? ??? ?BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
?? ??? ?if (existingDefinition != null) {
?? ??? ??? ?//isAllowBeanDefinitionOverriding方法是DefaultListableBeanFactory類的一個方法，它返回一個布爾值，用來判斷是否允許覆蓋同名的Bean定義。
?? ??? ??? ?//如果isAllowBeanDefinitionOverriding返回true，那么可以用新的Bean定義覆蓋舊的Bean定義。
?? ??? ??? ?//如果返回false，則不允許覆蓋。如果嘗試覆蓋，將拋出BeanDefinitionOverrideException異常。
?? ??? ??? ?if (!isAllowBeanDefinitionOverriding()) {
?? ??? ??? ??? ?throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
?? ??? ??? ?}
?? ??? ??? ?//現(xiàn)在已經(jīng)存在的beanDefinition的role和新的beanDefinition的定義
?? ??? ??? ?else if (existingDefinition.getRole() < beanDefinition.getRole()) {
?? ??? ??? ??? ?// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
?? ??? ??? ??? ?if (logger.isInfoEnabled()) {
?? ??? ??? ??? ??? ?logger.info("Overriding user-defined bean definition for bean '" + beanName +
?? ??? ??? ??? ??? ??? ??? ?"' with a framework-generated bean definition: replacing [" +
?? ??? ??? ??? ??? ??? ??? ?existingDefinition + "] with [" + beanDefinition + "]");
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?else if (!beanDefinition.equals(existingDefinition)) {
?? ??? ??? ??? ?if (logger.isDebugEnabled()) {
?? ??? ??? ??? ??? ?logger.debug("Overriding bean definition for bean '" + beanName +
?? ??? ??? ??? ??? ??? ??? ?"' with a different definition: replacing [" + existingDefinition +
?? ??? ??? ??? ??? ??? ??? ?"] with [" + beanDefinition + "]");
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?else {
?? ??? ??? ??? ?if (logger.isTraceEnabled()) {
?? ??? ??? ??? ??? ?logger.trace("Overriding bean definition for bean '" + beanName +
?? ??? ??? ??? ??? ??? ??? ?"' with an equivalent definition: replacing [" + existingDefinition +
?? ??? ??? ??? ??? ??? ??? ?"] with [" + beanDefinition + "]");
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?//將新的beanDefinition加入到beanDefinitionMap中，替換到原來的定義
?? ??? ??? ?this.beanDefinitionMap.put(beanName, beanDefinition);
?? ??? ?}
?? ??? ?//如果當(dāng)前的集合中不存在指定bean名稱的BeanDefinition
?? ??? ?else {
?? ??? ??? ?//用于檢查當(dāng)前 BeanFactory 是否已經(jīng)開始創(chuàng)建bean
?? ??? ??? ?if (hasBeanCreationStarted()) {
?? ??? ??? ??? ?synchronized (this.beanDefinitionMap) {
?? ??? ??? ??? ??? ?//將新的BeanDefinition添加到map中
?? ??? ??? ??? ??? ?this.beanDefinitionMap.put(beanName, beanDefinition);
?? ??? ??? ??? ??? ?//BeadDefinition的數(shù)量+1
?? ??? ??? ??? ??? ?List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
?? ??? ??? ??? ??? ?//將原來的beanDefinition的名稱都添加到新的集合
?? ??? ??? ??? ??? ?updatedDefinitions.addAll(this.beanDefinitionNames);
?? ??? ??? ??? ??? ?updatedDefinitions.add(beanName);
?? ??? ??? ??? ??? ?this.beanDefinitionNames = updatedDefinitions;
?? ??? ??? ??? ??? ?//在 Spring 中，通常情況下，Bean 的創(chuàng)建和注冊是由 Spring 容器自動完成的。但在某些情況下，你可能需要手動創(chuàng)建和注冊 Bean。比如，
?? ??? ??? ??? ??? ?// 在編程式地使用 Spring 容器時，或者在需要動態(tài)地創(chuàng)建和注冊 Bean 時。
?? ??? ??? ??? ??? ?//
?? ??? ??? ??? ??? ?//當(dāng)你手動注冊了一個單例 Bean 時，Spring 容器會把這個 Bean 的名稱添加到一個特定的列表中，這個列表用于存儲所有手動注冊的單例
?? ??? ??? ??? ??? ?// Bean 的名稱。removeManualSingletonName 方法就是用于從這個列表中移除指定的 Bean 名稱
?? ??? ??? ??? ??? ?removeManualSingletonName(beanName);
?? ??? ??? ??? ??? ?//這樣做的原因主要是考慮到線程安全性和不可變性。在多線程環(huán)境下，如果有多個線程同時讀寫 beanDefinitionNames 列表，那么可能會出現(xiàn)數(shù)據(jù)不一致的情況。
?? ??? ??? ??? ??? ?// 為了避免這種情況，我們在修改列表之前，先創(chuàng)建一個新的列表，然后再進(jìn)行修改。修改完成之后，再將新的列表賦值給 beanDefinitionNames。這樣可以保證
?? ??? ??? ??? ??? ?// 在任何時刻，其他線程看到的 beanDefinitionNames 列表都是一個完整且一致的列表，而不會出現(xiàn)中間狀態(tài)。
?? ??? ??? ??? ?}
?? ??? ??? ?}
?? ??? ??? ?else {
?? ??? ??? ??? ?// Still in startup registration phase
?? ??? ??? ??? ?this.beanDefinitionMap.put(beanName, beanDefinition);
?? ??? ??? ??? ?this.beanDefinitionNames.add(beanName);
?? ??? ??? ??? ?removeManualSingletonName(beanName);
?? ??? ??? ?}
?? ??? ??? ?this.frozenBeanDefinitionNames = null;
?? ??? ?}
? ? ? ? //如果新的beanDefinition是一個單例
?? ??? ?if (existingDefinition != null || containsSingleton(beanName)) {
?? ??? ??? ?//resetBeanDefinition 方法是 Spring DefaultListableBeanFactory 類中的一個方法，
?? ??? ??? ?// 主要功能是清除 Bean 定義緩存，以及所有關(guān)聯(lián)的 Bean 的相關(guān)信息
?? ??? ??? ?resetBeanDefinition(beanName);
?? ??? ?}
?? ??? ?else if (isConfigurationFrozen()) {
?? ??? ??? ?clearByTypeCache();
?? ??? ?}
?? ?}