spring application 之 BeanFactory

org.springframework.core.AliasRegistry

給Bean取別名，能夠用多個名稱對應同一個Bean
默認實現:org.springframework.core.SimpleAliasRegistry
這個有個小技巧:
	/** Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
咱們知道一個Bean的名稱能夠有多個別名，這裏把key看成別名，value看成bean的名稱

org.springframework.beans.factory.support.BeanDefinitionRegistry

繼承自:AliasRegistry
獲取BeanDefinition，註冊BeanDefinition
默認實現:org.springframework.beans.factory.support.SimpleBeanDefinitionRegistry
裏面就一個Map:private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(64);

org.springframework.beans.factory.config.SingletonBeanRegistry

老接口：註冊單例Bean的
默認實現:org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
管理單例Bean的依賴，建立，銷燬

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

//直接註冊單例
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException;

//建立完畢後，緩存到Map
protected void addSingleton(String beanName, Object singletonObject);

//解決單例循環依賴的問題，建立過程當中會將還未徹底初始化的Bean放入ObjectFactory中
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory);

//獲取單例Bean,解決循環依賴
protected Object getSingleton(String beanName, boolean allowEarlyReference);

//建立單例Bean時，會將Bean包裝成ObjectFactory，調用該類進行獲取
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory);

org.springframework.beans.factory.support.FactoryBeanRegistrySupport

解決FatoryBean的問題

org.springframework.beans.factory.BeanFactory

獲取Bean

org.springframework.beans.factory.HierarchicalBeanFactory

父BeanFactory

org.springframework.beans.factory.config.ConfigurableBeanFactory

對BeanFactory進行配置
默認支持兩種做用域:單例，原型 
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
設置EL表達式，解析屬性值  #{....}
void setConversionService(@Nullable ConversionService conversionService);
轉換器
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
屬性解析器
void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
自定義屬性解析，與上面的屬性解析器是同一個東西

void setTypeConverter(TypeConverter typeConverter);
與ConversionService同一個東西

void addEmbeddedValueResolver(StringValueResolver valueResolver);
字符屬性處理器，對字符進行加工

void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
Bean的後置處理器，在建立實例後

org.springframework.beans.factory.support.AbstractBeanFactory

主要是對ConfigurableBeanFactory的實現

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		//轉換beanName去掉前面的&,而且解決Bean的別名問題
		final String beanName = transformedBeanName(name);
		Object bean;

		// 是否單例模式
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			//是獲取FacotryBean,仍是獲取FacotryBean中的Bean
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 原型模式，不容許循環依賴，緣由是沒有緩該Bean
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 從父BeanFactory中獲取
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			//是否只進行類型檢查，而不獲取實例
			if (!typeCheckOnly) {
				//標記已被建立
				markBeanAsCreated(beanName);
			}

			try {
				//檢查是否抽像Bean
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				//獲取該Bean所依賴的beanName,先初始化依賴Bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//經過DependOn設置的依賴，不容許循環依賴
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				 if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//調用AbstractAutowireCapableBeanFactory類建立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;
						}
					});
					//上面說過了
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//原型模式
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						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 {
			//先獲取自定義的TypeConverter,沒有就獲取系統默認的
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

org.springframework.beans.factory.config.AutowireCapableBeanFactory

固名思義：裝配可用的Bean 包含建立，前置處理，後置處理，依賴Bean的解決

AbstractAutowireCapableBeanFactory.AbstractAutowireCapableBeanFactory

建立Bean的實現類

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

		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// 是否須要lookup replacMethod
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// 是否能夠經過後置處理器直接建立Bean
			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);
			if (logger.isDebugEnabled()) {
				logger.debug("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);
		}
	}

建立過程以下：不貼代碼了

1 可否經過後置處理器建立Bean,執行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation方法，若是能夠建立，執行後置初始化方法BeanPostProcessor.postProcessAfterInitialization
2 第一步若是返回不爲空的Bean,結束建立過程。不然進入流程3。
3 BeanDefinition中是否有instanceSupplier，若是有經過該函數建立Bean。並返回Bean的包裝類BeanWrapper，進入流程8。不然進入流程4。
4 BeanDifinition中是否含有facotryMethod。若是有，經過工廠方法建立，該方法支持參數,instantiateUsingFactoryMethod(beanName, mbd, args)，進入流程8。若是無，進入流程5。
5 獲取Bean的構造器，經過SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors,這裏沒有也關係，有的話就用這些指定的構造器。若是構造器不爲空，或者BeanDifinition須要經過構造器注入，或者建立Bean傳遞的參數不空，則進入流程6，有參建立實例，不然進行流程7，無參建立實例。
6 配置合適的構造器與參數，若是含有MethodOverride（LookupOverrideMethodInterceptor，ReplaceOverrideMethodInterceptor）。則採用cglib建立實例，由於須要代理，不然直接建立對象。
7 若是含有MethodOverride（LookupOverrideMethodInterceptor，ReplaceOverrideMethodInterceptor）。則採用cglib建立實例，由於須要代理，不然直接建立對象。
8 合併BeanDinition，若是須要。MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition。進入流程9。
9 set注入，循環依賴解決。暴露一個已經建立好的對象，未設置屬性與執行初始化。這裏若是有SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference(exposedObject, beanName);能夠進一步加工。進入流程10。
10 執行後置處理器:InstantiationAwareBeanPostProcessor..postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)，進入流程11。
11 若是是byName或byType的注入方式。經過PropertyDescripter獲取Bean，將這些屬性設置到BeanDifintion的PropertyValues中。進入流程12。
12 執行後置處理器,InstantiationAwareBeanPostProcessor.postProcessPropertyValues。該處理器主要解決屬性注入的問題。
13 設置屬性，進入流程14。
14 注入BeanNameAware,BeanClassLoaderAware,BeanFactoryAware。進入流程15。
15 執行後置處理器，BeanPostProcessor.postProcessBeforeInitialization(result, beanName);postDestruct()就是在這裏處理的。進入流程16。
16 執行初始化方法。若是有實現InitializingBean接口，就執行afterPropertiesSet（）方法。進入流程17。
17 執行後置處理器,BeanPostProcessor.postProcessAfterInitialization。進入流程18
18 註冊銷燬Bean的方法，包括destroy,close,shutdown方法，只會註冊一個，優先級依次下降。只有單例模式會註冊，其它須要從scope中註冊。結束流程。

org.springframework.beans.factory.ListableBeanFactory

BeanFactory的補充接口，都是一些獲取Bean的擴展方法。

org.springframework.beans.factory.config.ConfigurableListableBeanFactory

輔助接口

org.springframework.beans.factory.support.DefaultListableBeanFactory

BeanFactory的最終實現類，核心方法 resolveDependency,Bean裏面的屬性注入，就是靠該方法來生成具體的Bean的。

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		//支持jdk8 Optional
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		//支持ObjectFactory,ObjectProvider
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
		//支持懶加載
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			//獲取具體的Bean的實現方法
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}


@Nullable
	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

			Class<?> type = descriptor.getDependencyType();
			//搞定@Value 註解
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			if (value != null) {
				if (value instanceof String) {
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				return (descriptor.getField() != null ?
						converter.convertIfNecessary(value, type, descriptor.getField()) :
						converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
			}
			//搞定屬性是數組，Map,List等類型的注入
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}
			//存在多個符合要求的類型的解決
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			if (matchingBeans.size() > 1) {
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(type, matchingBeans);
					}
					else {
						// In case of an optional Collection/Map, silently ignore a non-unique case:
						// possibly it was meant to be an empty collection of multiple regular beans
						// (before 4.3 in particular when we didn't even look for collection beans).
						return null;
					}
				}
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			}
			else {
				// We have exactly one match.
				Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			if (!ClassUtils.isAssignableValue(type, result)) {
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			return result;
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}