文章目錄

• DefaultListableBeanFactory的繼承結構
• BeanFactory
• AliasRegistry
• BeanDefinitionRegistry
• SimpleAliasRegistry
• SingletonBeanRegistry
• DefaultSingletonBeanRegistry
• 單例類的獲取過程與迴圈依賴的實現原理
• FactoryBeanRegistrySupport
• ListableBeanFactory
• HierarchicalBeanFactory
• ConfigurableBeanFactory
• AutowireCapableBeanFactory
• ConfigurableListableBeanFactory
• AbstractBeanFactory的核心實現
• AbstractBeanFactory內部屬性定義
• AbstractBeanFactory的核心實現方法
• doGetBean
• AbstractAutowireCapableBeanFactory核心實現
• AbstractAutowireCapableBeanFactory內部屬性
• AbstractAutowireCapableBeanFactory核心方法
• createBean
• doCreateBean
• populateBean
• DefaultListableBeanFactory核心實現
• DefaultListableBeanFactory內部屬性定義
• DefaultListableBeanFactory核心實現方法
• doGetBeanNamesForType
• preInstantiateSingletons
• doResolveDependency

DefaultListableBeanFactory的繼承結構

 DefaultListableBeanFactory是介面ConfigurableListableBeanFactory和BeanDefinitionRegistry的預設實現，可以理解為Spring容器中預設的物件工廠的實現，是一個比較全面的物件工廠。工廠中的Bean都是基於元資料定義的 bean 和通過post-processors擴充套件的bean。它的典型作用就是註冊所有的bean通過讀取bean的配置檔案，這樣就可以通過bean的命名方便快速訪問bean,通過本地快取表。DefaultListableBeanFactory的繼承結構如下圖：
 下面逐個看看上層介面和跟類都提供了哪些方式和實現。

BeanFactory

BeanFactory定義的介面如下：

 /*Spring物件工廠的最頂層介面，最基礎的物件容器檢視*/
public interface BeanFactory {

	 /*區分FactoryBean例項和FactoryBean建立的例項*/
	String FACTORY_BEAN_PREFIX = "&";

	  /*獲取一個物件例項，單例物件返回都是物件的引用*/
	Object getBean(String name) throws BeansException;

	 /*獲取一個物件例項,requiredType是一個介面，或者例項類的父類*/
	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
	
    /*獲取一個物件例項,args是建立例項具體引數*/
	Object getBean(String name, Object... args) throws BeansException;
	
   /*獲取一個物件例項,requiredType是一個介面，或者例項類的父類*/
	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	
	/*判斷物件工廠中是否有指定名稱name的物件*/
	boolean containsBean(String name);

	/*判斷物件工廠中名稱name的物件是否是單例的*/
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
   
   /*判斷物件工廠中名稱name的物件是否是prototype型別的*/
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

   /*判斷物件工廠中名稱name的例項是否typeToMatch型別匹配*/
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

 	/*判斷物件工廠中名稱name例項的型別*/
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
 
   /*判斷物件工廠中名稱name的別稱*/
    String[] getAliases(String name);
}

AliasRegistry

 AliasRegistry是管理別稱的通用介面，作為BeanDefinitionRegistry的頂層介面

public interface AliasRegistry {
	void registerAlias(String name, String alias);
	void removeAlias(String alias);
	boolean isAlias(String name);
	String[] getAliases(String name);
}

BeanDefinitionRegistry

 BeanDefinition的註冊介面定義如下：

public interface BeanDefinitionRegistry extends AliasRegistry {
	
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
	boolean containsBeanDefinition(String beanName);
	String[] getBeanDefinitionNames();
	int getBeanDefinitionCount();
	boolean isBeanNameInUse(String beanName);
}

SimpleAliasRegistry

SimpleAliasRegistry是AliasRegistry的簡單實現

public class SimpleAliasRegistry implements AliasRegistry {

	/* 規範名和別稱的對映 */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

    /* 註冊別稱 */
	@Override
	public void registerAlias(String name, String alias) {
		Assert.hasText(name, "'name' must not be empty");
		Assert.hasText(alias, "'alias' must not be empty");
		synchronized (this.aliasMap) {
			if (alias.equals(name)) {
				this.aliasMap.remove(alias);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
				}
			}
			else {
				String registeredName = this.aliasMap.get(alias);
				if (registeredName != null) {
					if (registeredName.equals(name)) {
						// An existing alias - no need to re-register
						return;
					}
					if (!allowAliasOverriding()) {
						throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
								name + "': It is already registered for name '" + registeredName + "'.");
					}
					if (logger.isInfoEnabled()) {
						logger.info("Overriding alias '" + alias + "' definition for registered name '" +
								registeredName + "' with new target name '" + name + "'");
					}
				}
				
				/*檢測別稱中是否有環*/
				checkForAliasCircle(name, alias);
				
				/*放入快取*/
				this.aliasMap.put(alias, name);
				if (logger.isDebugEnabled()) {
					logger.debug("Alias definition '" + alias + "' registered for name '" + name + "'");
				}
			}
		}
	}
	
	protected boolean allowAliasOverriding() {
		return true;
	}

   /*遞迴判斷是否有名稱為name的別稱alias*/
	public boolean hasAlias(String name, String alias) {
		for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
			String registeredName = entry.getValue();
			if (registeredName.equals(name)) {
				String registeredAlias = entry.getKey();
				return (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias));
			}
		}
		return false;
	}

	@Override
	public void removeAlias(String alias) {
		synchronized (this.aliasMap) {
			String name = this.aliasMap.remove(alias);
			if (name == null) {
				throw new IllegalStateException("No alias '" + alias + "' registered");
			}
		}
	}

	@Override
	public boolean isAlias(String name) {
		return this.aliasMap.containsKey(name);
	}

	@Override
	public String[] getAliases(String name) {
		List<String> result = new ArrayList<>();
		synchronized (this.aliasMap) {
			retrieveAliases(name, result);
		}
		return StringUtils.toStringArray(result);
	}

	private void retrieveAliases(String name, List<String> result) {
		this.aliasMap.forEach((alias, registeredName) -> {
			if (registeredName.equals(name)) {
				result.add(alias);
				retrieveAliases(alias, result);
			}
		});
	}
	
   /*解析別稱*/
	public void resolveAliases(StringValueResolver valueResolver) {
		Assert.notNull(valueResolver, "StringValueResolver must not be null");
		synchronized (this.aliasMap) {
			Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
			aliasCopy.forEach((alias, registeredName) -> {
				String resolvedAlias = valueResolver.resolveStringValue(alias);
				String resolvedName = valueResolver.resolveStringValue(registeredName);
				if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
					this.aliasMap.remove(alias);
				}
				else if (!resolvedAlias.equals(alias)) {
					String existingName = this.aliasMap.get(resolvedAlias);
					if (existingName != null) {
						if (existingName.equals(resolvedName)) {
							// Pointing to existing alias - just remove placeholder
							this.aliasMap.remove(alias);
							return;
						}
						throw new IllegalStateException(
								"Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias +
								"') for name '" + resolvedName + "': It is already registered for name '" +
								registeredName + "'.");
					}
					checkForAliasCircle(resolvedName, resolvedAlias);
					this.aliasMap.remove(alias);
					this.aliasMap.put(resolvedAlias, resolvedName);
				}
				else if (!registeredName.equals(resolvedName)) {
					this.aliasMap.put(alias, resolvedName);
				}
			});
		}
	}
	
   /*解析別稱中是否有環*/
   protected void checkForAliasCircle(String name, String alias) {
		if (hasAlias(alias, name)) {
			throw new IllegalStateException("Cannot register alias '" + alias +
					"' for name '" + name + "': Circular reference - '" +
					name + "' is a direct or indirect alias for '" + alias + "' already");
		}
	}
	
	public String canonicalName(String name) {
		String canonicalName = name;
		// Handle aliasing...
		String resolvedName;
		do {
			resolvedName = this.aliasMap.get(canonicalName);
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}

}

SingletonBeanRegistry

單例bean的註冊介面定義如下：

public interface SingletonBeanRegistry {

	void registerSingleton(String beanName, Object singletonObject);
	
	@Nullable
	Object getSingleton(String beanName);

	boolean containsSingleton(String beanName);

	String[] getSingletonNames();

	int getSingletonCount();

	Object getSingletonMutex();

}

DefaultSingletonBeanRegistry

Spring單例類註冊的預設實現，這個類很重要。首先看下這個類的屬性定義如下：

    /** 單例物件快取*/
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** 單例工程快取 */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** 提前暴露的物件快取*/
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

	/** 已經註冊的單例物件集合，按照註冊順序排序 */
	private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

	/** 併發下建立的單例物件 */
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** 建立檢測中排除掉的bean集合 */
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** 被抑制異常的列表，可用於關聯相關原因 */
	@Nullable
	private Set<Exception> suppressedExceptions;

	/*是否併發銷燬bean的標誌*/
	private boolean singletonsCurrentlyInDestruction = false;

	/** 可廢棄的bean集合 */
	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

	/*名稱為name的bean持有的beans列表*/
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

	/*名稱為name的bean與依賴的beans的對映關係*/
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

	/*名稱為name的bean與被依賴的beans的對映關係*/
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

單例類的獲取過程與迴圈依賴的實現原理

 獲取單例物件的執行流程如下：
 首先從單例物件快取中獲取物件，如果獲取不到或者單例物件正在被併發建立，那麼嘗試從提前暴露的單例物件快取中獲取物件，如果還是獲取不到，再從單例物件工廠中獲取物件，並放入提前暴露的物件快取中。原始碼如下：

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

 另外，還提供了從單例物件工廠ObjectFactory中獲取例項的方法如下：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
		// 首先重試直接從物件工廠中直接獲取例項，如果獲取不到，以同步的方式直接從singletonFactory獲取例項
			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;
					}
				}
				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 beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
//物件建立結束後做快取清理
protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}

FactoryBeanRegistrySupport

 FactoryBeanRegistrySupport的主要作用是：對於實現了FactoryBean介面的單例類，提供了獲取單例類例項和獲取FactoryBean例項的方法。核心實現如下：

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

	/**  實現了FactoryBean的bean的快取 */
	private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);

    /**  從快取中獲取FactoryBean例項 */
	@Nullable
	protected Object getCachedObjectForFactoryBean(String beanName) {
		return this.factoryBeanObjectCache.get(beanName);
	}

   /*從FactoryBean例項中獲取物件例項*/
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
	  
	   /* FactoryBean是單例的 */
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
			   /**  從快取中獲取FactoryBean例項 */
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
				   /**  通過FactoryBean例項獲取單例物件 */
					object = doGetObjectFromFactoryBean(factory, beanName);
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							if (isSingletonCurrentlyInCreation(beanName)) {
								return object;
							}
							beforeSingletonCreation(beanName);
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
							finally {
								afterSingletonCreation(beanName);
							}
						}
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

	private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
			throws BeanCreationException {
		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
			//實現了FactoryBean介面，getObject()返回例項物件
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}
		if (object == null) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(
						beanName, "FactoryBean which is currently in creation returned null from getObject");
			}
			object = new NullBean();
		}
		return object;
	}
}

ListableBeanFactory

 ListableBeanFactory提供根據各種條件獲取bean的配置清單:

public interface ListableBeanFactory extends BeanFactory {

    /*判斷是否有Bean的定義*/
	boolean containsBeanDefinition(String beanName);
   
   /*返回Bean的定義的計數*/
	int getBeanDefinitionCount();

   /*返回Bean的定義的名稱集合*/
	String[] getBeanDefinitionNames();
	
    /*返回可解析型別的Bean的定義的名稱集合*/
	String[] getBeanNamesForType(ResolvableType type);

	String[] getBeanNamesForType(@Nullable Class<?> type);

	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
	
   /*返回指定type的bean對映*/
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;
			
    /*返回指定註解型別annotationType的bean名稱*/
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

   /*返回指定註解型別annotationType的bean例項*/
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

   /*返回指定bean名稱和註解型別annotationType的註解/
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

}

HierarchicalBeanFactory

 HierarchicalBeanFactory主要提供獲取父級BeanFactory:

public interface HierarchicalBeanFactory extends BeanFactory {

    /*返回BeanFactory的父級BeanFactory*/
	@Nullable
	BeanFactory getParentBeanFactory();

	boolean containsLocalBean(String name);

}

ConfigurableBeanFactory

 ConfigurableBeanFactory提供配置BeanFactory的各種方法:

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

   String SCOPE_SINGLETON = "singleton";

   String SCOPE_PROTOTYPE = "prototype";
   
   /*配置父級BeanFactory*/
   void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
   
   /*配置的類載入器，預設為執行緒上下文類載入*/
   void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
   
   /*獲取類載入器*/
   @Nullable
   ClassLoader getBeanClassLoader();
   
   /*型別匹配的時候設定臨時載入器，預設為空，簡單的使用標準類載入器*/
   void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
   
   /*獲取臨時類載入器*/
   @Nullable
   ClassLoader getTempClassLoader();

   /*設定是否快取BeanMeta*/
   void setCacheBeanMetadata(boolean cacheBeanMetadata);

   boolean isCacheBeanMetadata();
   
   /*設定BeanExpressionResolver*/
   void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

   /*獲取BeanExpressionResolver*/
   @Nullable
   BeanExpressionResolver getBeanExpressionResolver();
   
   /*設定ConversionService，屬性轉換*/
   void setConversionService(@Nullable ConversionService conversionService);

   @Nullable
   ConversionService getConversionService();
   
   /*新增PropertyEditorRegistrar*/
   void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

   void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

   void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

   void setTypeConverter(TypeConverter typeConverter);

   TypeConverter getTypeConverter();

   void addEmbeddedValueResolver(StringValueResolver valueResolver);

   boolean hasEmbeddedValueResolver();

   @Nullable
   String resolveEmbeddedValue(String value);
   
   /*新增BeanPostProcessor*/
   void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

   int getBeanPostProcessorCount();

   void registerScope(String scopeName, Scope scope);

   String[] getRegisteredScopeNames();

   @Nullable
   Scope getRegisteredScope(String scopeName);

   AccessControlContext getAccessControlContext();

   void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

   void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

   void resolveAliases(StringValueResolver valueResolver);

   BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

   /*判斷是否是FactoryBean例項*/
   boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

   void setCurrentlyInCreation(String beanName, boolean inCreation);

   boolean isCurrentlyInCreation(String beanName);

   /*註冊依賴的Bean例項*/
   void registerDependentBean(String beanName, String dependentBeanName);

   String[] getDependentBeans(String beanName);

   String[] getDependenciesForBean(String beanName);

   void destroyBean(String beanName, Object beanInstance);
   
   void destroyScopedBean(String beanName);

   void destroySingletons();

}

AutowireCapableBeanFactory

 AutowireCapableBeanFactory提供建立bean,自動注入，初始化以及應用bean的後處理器。

public interface AutowireCapableBeanFactory extends BeanFactory {
	
	/*物件注入方式0，1，2，3，4*/
	int AUTOWIRE_NO = 0;

	int AUTOWIRE_BY_NAME = 1;
	
	int AUTOWIRE_BY_TYPE = 2;

	int AUTOWIRE_CONSTRUCTOR = 3;

	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;
	
	/*建立例項*/
	<T> T createBean(Class<T> beanClass) throws BeansException;
	
	/*自動注入Bean*/
	void autowireBean(Object existingBean) throws BeansException;
	
	/*配置bean */
	Object configureBean(Object existingBean, String beanName) throws BeansException;

	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
	
	/*自動注入bean屬性*/
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;
	
	/*通過autowireBeanProperties方法應用PropertyValues*/
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

	Object initializeBean(Object existingBean, String beanName) throws BeansException;

	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;
	
	/*初始化bean後應用BeanPostProcessors*/
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

	void destroyBean(Object existingBean);

	/*解析需要型別requiredType的bean*/
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

	/*解析依賴的bean*/
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}

ConfigurableListableBeanFactory

 BeanFactory配置清單，指定忽略型別和介面等。

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
	/*忽略依賴型別*/
	void ignoreDependencyType(Class<?> type);
	
	/*忽略依賴介面*/
	void ignoreDependencyInterface(Class<?> ifc);
	
	/*註冊可解析的依賴*/
	void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException;

	/*獲取BeanDefinition根據beanName*/
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/*獲取beanName的迭代器*/
	Iterator<String> getBeanNamesIterator();

	/*清除Metadata快取*/
	void clearMetadataCache();
	
	/*冰凍不被修改bean definitions*/
	void freezeConfiguration();

	/*bean definitions是否被冰凍住*/
	boolean isConfigurationFrozen();

	/*初始化所有非懶載入的bean*/
	void preInstantiateSingletons() throws BeansException;
}

AbstractBeanFactory的核心實現

AbstractBeanFactory內部屬性定義

	/*父級BeanFactory*/
	@Nullable
	private BeanFactory parentBeanFactory;

	/*Bean的類載入器*/
	@Nullable
	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

	/*Bean的臨時類載入器*/
	@Nullable
	private ClassLoader tempClassLoader;

	/*是否快取meta data資料標誌 */
	private boolean cacheBeanMetadata = true;

	/*bean definition中的表示式的解析策略*/
	@Nullable
	private BeanExpressionResolver beanExpressionResolver;

	/*屬性轉換，使用PropertyEditors替換*/
	@Nullable
	private ConversionService conversionService;

	/*應用到物件工廠中的屬性轉換器註冊*/
	private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);

	/*應用到物件工廠中的屬性轉換器*/
	private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);

	/*型別轉換器，重寫預設PropertyEditor機制*/
	@Nullable
	private TypeConverter typeConverter;

	/*字串解析，應用於註解屬性值*/
	private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<>();

	/*應用於建立bean的BeanPostProcessors*/
	private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();

	/*標誌InstantiationAwareBeanPostProcessors是否已被註冊*/
	private boolean hasInstantiationAwareBeanPostProcessors;
	
	/*標誌DestructionAwareBeanPostProcessors是否已被註冊*/
	private boolean hasDestructionAwareBeanPostProcessors;

	/*Scope對映*/
	private final Map<String, Scope> scopes = new LinkedHashMap<>(8);

	@Nullable
	private SecurityContextProvider securityContextProvider;

	/*合併的RootBeanDefinition與名稱對映*/
	private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

	/*最後一次建立的bean集合*/
	private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

	/*正在建立的bean的名稱*/
	private final ThreadLocal<Object> prototypesCurrentlyInCreation =
			new NamedThreadLocal<>("Prototype beans currently in creation");

AbstractBeanFactory的核心實現方法

 AbstractBeanFactory從BeanFactory獲取例項的核心實現如下：

doGetBean

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
			throws BeansException {

		return doGetBean(name, requiredType, args, false);
	}

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		
		/*獲取原始beanName，首先去除&符號開頭，然後從別稱快取map中get到原始beanName*/
		final String beanName = transformedBeanName(name);
		Object bean;
		
		/*首先嚐試從單例物件工廠中獲取例項*/
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			......
			/* 獲取例項*/
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			/*獲取父級BeanFactory*/ 
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					
					/*遞迴從父級BeanFactory獲取例項*/ 
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				/*檢測建立的Bean沒有沒有被併發依賴*/
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						/*註冊依賴的Bean*/
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				/*根據RootBeanDefinition建立Bean*/
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						/*建立Prototype型別的Bean*/
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					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 {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(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) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		/*檢測需要的型別是否與建立的例項型別匹配*/
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
		    ......
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}
	
/* 獲取例項*/
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
			}
		}

		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}
		/* 首先嚐試從FactoryBean快取中獲取例項，如果獲取不到，從FactoryBean獲取例項*/
		Object object = null;
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

/*如果是子的BeanDefinition，需要合併父BeanDefinition的資訊*/
protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
				if (bd.getParentName() == null) {
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					BeanDefinition pbd;
					try {
						String parentBeanName = transformedBeanName(bd.getParentName());
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
										"': cannot be resolved without an AbstractBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}

				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}
			return mbd;
		}
	}

####### isTypeMatch
 最複雜方法原始碼分析isTypeMatch:

 /*判斷物件工廠中名稱name的例項是否型別匹配*/
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
		String beanName = transformedBeanName(name);

		/*檢測手動註冊的單例類*/
		Object beanInstance = getSingleton(beanName, false);
		if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
			if (beanInstance instanceof FactoryBean) {
				if (!BeanFactoryUtils.isFactoryDereference(name)) {
					
					/*返回建立FactoryBean建立的例項的型別*/
					Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
					return (type != null && typeToMatch.isAssignableFrom(type));
				}
				else {
					return typeToMatch.isInstance(beanInstance);
				}
			}
			else if (!BeanFactoryUtils.isFactoryDereference(name)) {
				if (typeToMatch.isInstance(beanInstance)) {
					return true;
				}
				else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {
					
					/*RootBeanDefinition獲取*/
					RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
					Class<?> targetType = mbd.getTargetType();
					if (targetType != null && targetType != ClassUtils.getUserClass(beanInstance) &&
							typeToMatch.isAssignableFrom(targetType)) {
						
						/*檢測原始類也匹配，確定暴露給代理*/
						Class<?> classToMatch = typeToMatch.resolve();
						return (classToMatch == null || classToMatch.isInstance(beanInstance));
					}
				}
			}
			return false;
		}
		else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
			/*沒有例項註冊*/
			return false;
		}

		
		/*沒有找到單例例項*/
		BeanFactory parentBeanFactory = getParentBeanFactory();
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			
			/*沒有找到單例例項，委託父類工程*/
			return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch);
		}

		/*取出RootBeanDefinition*/
		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

		Class<?> classToMatch = typeToMatch.resolve();
		if (classToMatch == null) {
			classToMatch = FactoryBean.class;
		}
		Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ?
				new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch});
		
		/*檢測bean definition的裝飾類*/
		BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
		if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {
			RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
			Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
			if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {
				return typeToMatch.isAssignableFrom(targetClass);
			}
		}

		Class<?> beanType = predictBeanType(beanName, mbd, typesToMatch);
		if (beanType == null) {
			return false;
		}

		/*檢測bean是否在處理FactoryBean*/
		if (FactoryBean.class.isAssignableFrom(beanType)) {
			if (!BeanFactoryUtils.isFactoryDereference(name) && beanInstance == null) {
				beanType = getTypeForFactoryBean(beanName, mbd);
				if (beanType == null) {
					return false;
				}
			}
		}
		else if (BeanFactoryUtils.isFactoryDereference(name)) {
			beanType = predictBeanType(beanName, mbd, FactoryBean.class);
			if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) {
				return false;
			}
		}

		ResolvableType resolvableType = mbd.targetType;
		if (resolvableType == null) {
			resolvableType = mbd.factoryMethodReturnType;
		}
		if (resolvableType != null && resolvableType.resolve() == beanType) {
			return typeToMatch.isAssignableFrom(resolvableType);
		}
		return typeToMatch.isAssignableFrom(beanType);
	}

AbstractAutowireCapableBeanFactory核心實現

 AbstractAutowireCapableBeanFactory實現了預設的bean建立方法，擁有所有被RootBeanDefinition具體化的能力。屬性如下：

AbstractAutowireCapableBeanFactory內部屬性

	/*建立例項的初始化策略，預設使用CGLIB建立例項*/
	private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

	/*方法引數的解析策略*/
	@Nullable
	private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

	/*是否允許迴圈引用，預設 true*/
	private boolean allowCircularReferences = true;

	private boolean allowRawInjectionDespiteWrapping = false;

	 /*忽略的依賴檢測和注入的資料型別*/
	private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();

	 /*忽略的依賴檢測和注入的介面型別*/
	private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();

	 /*併發建立例項的名稱*/
	private final NamedThreadLocal<String> currentlyCreatedBean = new NamedThreadLocal<>("Currently created bean");

	/*FactoryBean的包裝類快取 */
	private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>(16);

	/*PropertyDescriptor快取*/
	private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
			new ConcurrentHashMap<>(256);

AbstractAutowireCapableBeanFactory核心方法

建立例項，廣播例項，呼叫post-processors核心方法如下：

createBean

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		
		/*獲取RootBeanDefinition*/
		RootBeanDefinition mbdToUse = mbd;

        /*解析bean的Class類*/
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		/*準備方法重寫*/
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			
			/*初始化前對BeanPostProcessors進行處理，返回的是一個代理而不是目標物件*/
			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 {
		    /*建立例項*/
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

/*應用初始化前的post-processors，解析對於特殊的bean是否有 before-instantiation*/
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

/*對初始化前的bean進行InstantiationAwareBeanPostProcessor處理*/
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
				if (result != null) {
					return result;
				}
			}
		}
		return null;
	}


 /*對初始化後的bean進行BeanPostProcessor處理*/
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
			
		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

 具體建立bean的核心實現如下:

doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
		  
		   /*建立例項*/
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		
		/*獲取例項和Class型別*/
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					
					/*使用post-processors修改合併的bean定義*/
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		/*檢測是否有提前暴露單例類*/
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		/*初始化類*/ 
		Object exposedObject = bean;
		try {
			
			/*廣播初始化的類*/ 
			populateBean(beanName, mbd, instanceWrapper);
			/*初始化類*/ 
			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);
			}
		}

		if (earlySingletonExposure) {
		
		   /*根據提前暴露的單例類的引用獲取單例類例項*/
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						
						   /*將依賴的單例類加入到列表中*/
							actualDependentBeans.add(dependentBean);
						}
					}
					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 " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		try {
			
			/*如果有需要，註冊拋棄的bean*/ 
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

populateBean

執行廣播bean的初始化實現如下：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		/*給InstantiationAwareBeanPostProcessors介面修改bean的狀態*/
		/*在屬性被設定之前，在欄位注入的時候回被用到*/
		boolean continueWithPropertyPopulation = true;

		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		if (!continueWithPropertyPopulation) {
			return;
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			
			/*獲取屬性的注入型別*/
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			/*依據名稱注入屬性*/
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			/*依據型別注入屬性*/
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

DefaultListableBeanFactory核心實現

DefaultListableBeanFactory內部屬性定義

	/* DefaultListableBeanFactory引用的快取 */
	private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
			new ConcurrentHashMap<>(8);

	/* DefaultListableBeanFactory的序列化id */
	@Nullable
	private String serializationId;

	/*標誌是否允許不同的定義有相同的名稱 */
	private boolean allowBeanDefinitionOverriding = true;

	/*是否允許懶載入beans*/
	private boolean allowEagerClassLoading = true;

	/*可選擇的依賴排序順序*/
	@Nullable
	private Comparator<Object> dependencyComparator;

	/*用來檢測bean definition 能否被自動注入的解析器*/
	private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

	/*依賴型別和對應的自動注入的值的對映*/
	private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

	/*BeanDefinition快取*/
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

	/*依賴型別和單例，非單例bean的對映*/
	private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

	/*依賴型別和單例bean的對映*/
	private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

	/*按照註冊順序的bean definition名稱集合*/
	private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

	/*手動註冊的單例類名稱，按照註冊順序排序*/
	private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

	/*固定配置了的bean definition名稱快取陣列*/
	@Nullable
	private volatile String[] frozenBeanDefinitionNames;

	/*標誌bean definition元資料能否快取為所有的bean*/
	private volatile boolean configurationFrozen = false;

DefaultListableBeanFactory核心實現方法

doGetBeanNamesForType

 根據給出的型別獲取已經註冊的bean名稱，判斷bean definition或者getObjectType方法返回的值是否是FactoryBean例項。

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
		List<String> result = new ArrayList<>();

		/*檢測所有的beans*/
		for (String beanName : this.beanDefinitionNames) {
			
			/*判斷bean名稱是否是別稱*/
			if (!isAlias(beanName)) {
				try {
					RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
					
					/*判斷bean定義是否是完整*/
					if (!mbd.isAbstract() && (allowEagerInit ||
							(mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
									!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
					
						boolean isFactoryBean = isFactoryBean(beanName, mbd);
						BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
						boolean matchFound =
								(allowEagerInit || !isFactoryBean ||
										(dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
								(includeNonSingletons ||
										(dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
								isTypeMatch(beanName, type);
						if (!matchFound && isFactoryBean) {
							
							beanName = FACTORY_BEAN_PREFIX + beanName;
							matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
						}
						if (matchFound) {
							result.add(beanName);
						}
					}
				}
				catch (CannotLoadBeanClassException ex) {
					if (allowEagerInit) {
						throw ex;
					}
					
					if (logger.isDebugEnabled()) {
						logger.debug("Ignoring bean class loading failure for bean '" + beanName + "'", ex);
					}
					onSuppressedException(ex);
				}
				catch (BeanDefinitionStoreException ex) {
					if (allowEagerInit) {
						throw ex;
					}
					
					if (logger.isDebugEnabled()) {
						logger.debug("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex);
					}
					onSuppressedException(ex);
				}
			}
		}

		for (String beanName : this.manualSingletonNames) {
			try {
				
				/*判斷是否是FactoryBean建立的例項*/
				if (isFactoryBean(beanName)) {
					if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
						result.add(beanName);
						continue;
					}
					
					beanName = FACTORY_BEAN_PREFIX + beanName;
				}
			
				/*匹配原始的bean型別*/
				if (isTypeMatch(beanName, type)) {
					result.add(beanName);
				}
			}
			catch (NoSuchBeanDefinitionException ex) {
				
				......
				
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to check manually registered singleton with name '" + beanName + "'", ex);
				}
			}
		}
		return StringUtils.toStringArray(result);
	}

preInstantiateSingletons

 預初始化單例類

public void preInstantiateSingletons() throws BeansException {
		
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		/*觸發初始化所有非懶載入bean*/ 
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		/*在回撥應用所有的beans的時候，觸發post-initialization*/
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

相關推薦

Spring中Bean容器DefaultListableBeanFactory核心實現原始碼分析

文章目錄 DefaultListableBeanFactory的繼承結構 BeanFactory AliasRegistry BeanDefinitionRegistry

ScheduledThreadPoolExecutor中定時週期任務的實現原始碼分析

ScheduledThreadPoolExecutor是一個定時任務執行緒池，相比於ThreadPoolExecutor最大的不同在於其阻塞佇列的實現 首先看一下其構造方法： 1 public ScheduledThreadPoolExecutor(int corePoolSize, 2

Spring中IOC容器對數組，集合的相關bean的裝配

art prop emp pri val 對數 try ioc容器 blog <bean id="department" class="com.pojo.Department"> <property name="name" val

Spring 中 bean 註冊的原始碼解析

前言 所謂 bean 的註冊，就是把在配置檔案中配置的 <bean> 節點載入配記憶體中，供後續使用。 bean的註冊主要分為兩個階段，一個是準備階段，就是對配置檔案進行解析，把配置檔案載入到記憶體中，以 Document 的形式存放；第二個階段是對 Document 進行操作，獲取其中的節

Spring中Bean多種實現切換方案

一個公共工程中的Spring配置檔案，可能會被多個工程引用。因為每個工程可能只需要公共工程中的一部分Bean，所以這些工程的Spring容器啟動時，需要區分開哪些Bean要創建出來。另一種場景是：想通過Properties檔案中的配置開關，就將Spring配置檔案中Bea

Spring中bean的例項化方式與IOC容器總結

提到spring，第一印象就是DI與IOC，雖然有概念上的解釋，但是要理解這些概念還是需要動手進行試驗。如果要深入瞭解spring的原來，那麼最先了解得就應該是spring容器。Spring提供了兩種型別的IOC容器實現：      1.beanFactory: IOC 容器

Spring中Bean的生命周期

spring bean生命周期 Spring 容器中的 Bean 是有生命周期的，Spring 允許在 Bean 在初始化完成後以及 Bean 銷毀前執行特定的操作，常用的設定方式有以下三種： （1）通過 <bean> 元素的 init-method/destroy-

Spring中Bean的配置方式之FactoryBean

alt mage -1 bsp image 技術分享 logs 指向 urn 　　Spring 中有兩種類型的 Bean, 一種是普通Bean, 另一種是工廠Bean, 即FactoryBean. 　　工廠 Bean 跟普通Bean不同, 其返回的對象不是指定類的一個實例,

半夜思考之查漏補缺 , Spring 中 Bean 之間的依賴問題

為什麽 gte 每次 自己的 ont 打獵 不同 pro 自己 每次看書都會發現自己的不足 . 當一個 singten 的 Bean 依賴一個 prototype 的 Bean 時 , 如果不加註意 , 會發生一些奇怪的事情 , prototype 變為了 s

Spring中bean的作用範圍

pre 方法 context () 釋放資源 應用 生命 產生 ron singleton作用域： 　　Spring的scope的默認值是singleton 　　Spring 只會為每一個bean創建一個實例,並保持bean的引用. <bean id="bean的i

Spring中Bean的五個作用域

就會 clas web應用 import 銷毀 cstring tor 默認 global 當通過spring容器創建一個Bean實例時，不僅可以完成Bean實例的實例化，還可以為Bean指定特定的作用域。Spring支持如下5種作用域： singleton：單例模式，

spring 中bean生命周期

encoding 學習 tostring true ice ava initial oid pan 從頭開始學習spring(一) 傳統編程中，依賴關系比較多的情況下，導致維護成本直線上升，spring 采用Ioc對bean進行管理，減少了開發人員的工作量 正確理解spri

spring源碼--容器的基本實現

init turn try consumer ica not www ask queue 在工作中見得非常多的容器使用是：<beans xmlns="http://www.springframework.org/schema/beans" xml

spring中Bean創建

AI nbsp ini csdn div 進行 BE 資源 href Spring中bean的加載過程： 　　1.獲取配置文件資源 　　2.對獲取的xml資源進行一定的處理檢驗 　　3.處理包裝資源 　　4.解析處理包裝過後的資源 　　5.加載提取bean並註冊(添加到be

Spring中Bean的生命周期討論

work cxf hello sys tex 操作 classpath system under 1、代碼和配置文件準備 1.1、測試類（user.java） 1 public class User { 2 private int id; 3 pri

Spring中Bean的理解以及@Bean的作用

是把 ring con 通過 自動配置 面向對象 ava 符號 反射 一、Bean是啥 1、Java面向對象，對象有方法和屬性，那麽就需要對象實例來調用方法和屬性（即實例化）； 2、凡是有方法或屬性的類都需要實例化，這樣才能具象化去使用這些方法和屬性； 3、規律：凡是子類及

Spring中bean標簽的屬性和值：

lazy-init 獲取 bean 當前 宋體 指定 red pro style Spring中bean標簽的屬性和值： <bean name="user" class="com.pojo.User" init-method="intMethod" dest

知識儲備：Spring中Bean的生命週期（基於註解版）

一：前言 在Spring專案中，通常配置Spring都是使用XML的形式進行配置，配置bean是通過<bean></bean>標籤將bean加入IOC容器中，但在Spring註解版中，可以通過Java程式碼進行配置，即建立一個java類在其類頭上標註@Configurat

Spring中bean標籤的屬性和值：

Spring中bean標籤的屬性和值： <bean name="user" class="com.pojo.User" init-method="intMethod" destroy-method="destoryMethod" lazy-init="false" scope="sing

【Spring筆記三】Spring中Bean（XML方式裝配）

       我們可以把 Spring 看作一個大型的工廠，而 Spring 容器中的 Bean 就是該工廠的產品。要想使用這個工廠生產和管理Bean，就需要在配置檔案中告訴它需要哪些 Be