Spring Ioc 之 Bean的加載（一）

時間  2019-11-12
標籤 spring ioc bean 加載 欄目 Spring 简体版
原文   原文鏈接

前言

在以前的文章中，咱們分析了Spring的Ioc的初始化過程，實際上就是把beanName和BeanDefinition註冊到DefaultListableBeanFactory的map中。
在完成 bean 的註冊以後，refresh()還調用了不少後處理器的方法，其中有一個方法 finishBeanFactoryInitialization()，註釋上面寫着 Instantiateall remaining(non-lazy-init)singletons，意味着非延遲加載的類，將在這一步實例化，完成類的加載。
而咱們使用到 context.getBean("beanName")方法，若是對應的 bean 是非延遲加載的，那麼直接就能拿出來進行使用，而延遲加載的 bean 就須要上面的步驟進行類的加載，加載完以後才能進行使用。java

咱們接着分析一下Ioc的bean實例化過程：緩存

1、getBean

當咱們顯示或者隱式地調用 BeanFactory#getBean(String name) 方法時，則會觸發加載 Bean 階段。代碼以下：session

// AbstractBeanFactory.java

@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

內部調用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly) 方法，其接受四個方法參數：多線程

  • name ：要獲取 Bean 的名字app

  • requiredType ：要獲取 bean 的類型ide

  • args ：建立 Bean 時傳遞的參數。這個參數僅限於建立 Bean 時使用。post

  • typeCheckOnly ：是否爲類型檢查。ui

2、doGetBean

//真正實現向IOC容器獲取Bean的功能，也是觸發依賴注入功能的地方
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//根據指定的名稱獲取被管理Bean的名稱，剝離指定名稱中對容器的相關依賴
		// 若是指定的是別名，將別名轉換爲規範的Bean名稱
<1>		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 從緩存中獲取已被建立過的單例Bean
<2>		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 + "'");
				}
			}

			//注意：BeanFactory是管理容器中Bean的工廠
			//     FactoryBean是建立建立對象的工廠Bean，二者之間有區別

			//獲取給定Bean的實例對象，該對象要麼是 bean 實例自己，要麼就是 FactoryBean 建立的 Bean 對象
			//（爲何要再次獲取呢，由於上面獲取的sharedInstance不必定是完整的）
<3>			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 由於 Spring 只解決單例模式下的循環依賴，在原型模式下若是存在循環依賴則會拋出異常。
<4>			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
			//能在當前的BeanFactory中獲取的所須要的Bean，若是不能則委託當前容器
			//的父級容器去查找，若是仍是找不到則沿着容器的繼承體系向父級容器查找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				//解析指定Bean名稱的原始名稱
				String nameToLookup = originalBeanName(name);
				// 若爲 AbstractBeanFactory 類型，委託父類處理
				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);
				}
			}

			// 建立的Bean是否須要進行類型驗證，通常不須要
<5>			if (!typeCheckOnly) {
				//向容器標記指定的Bean已經被建立
				markBeanAsCreated(beanName);
			}

			try {
				//從容器中獲取 beanName 相應的 GenericBeanDefinition 對象，並將其轉換爲 RootBeanDefinition 對象
				// 主要解決Bean繼承時子類合併父類公共屬性問題
<6>				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 檢查給定的合併的 BeanDefinition (是否爲抽象類)
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 處理所依賴的 bean @DependsOn()
				// 獲取當前Bean全部依賴Bean的名稱
<7>				String[] dependsOn = mbd.getDependsOn();
				//若是有依賴
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//校驗該依賴是否已經註冊過給當前 Bean
						if (isDependent(beanName, dep)) {
							//已註冊，拋出異常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//沒有，則先註冊依賴的bean
						registerDependentBean(dep, beanName);
						//遞歸調用getBean()，先生成依賴的bean
						getBean(dep);
					}
				}

				// Create bean instance.
				//建立單例Bean
<8>				if (mbd.isSingleton()) {
					//這裏使用了一個匿名內部類，建立Bean實例對象，而且註冊給所依賴的對象
					sharedInstance = getSingleton(beanName, () -> {
						try {
							//建立一個指定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.
							//顯式地從容器單例模式Bean緩存中清除實例對象
							destroySingleton(beanName);
							throw ex;
						}
					});
					//獲取給定Bean的實例對象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				//建立多例Bean
				else if (mbd.isPrototype()) {
					//原型模式(Prototype)是每次都會建立一個新的對象
					Object prototypeInstance = null;
					try {
						//加載前置處理，默認的功能是註冊當前建立的原型對象
						beforePrototypeCreation(beanName);
						//建立指定Bean對象實例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						//加載後置處理，默認的功能告訴IOC容器指定Bean的原型對象再也不建立
						afterPrototypeCreation(beanName);
					}
					//獲取給定Bean的實例對象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				//要建立的Bean既不是Singleton也不是Prototype
				//如：request、session、application等生命週期
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					//Bean定義資源中沒有配置生命週期範圍，則Bean定義不合法
					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的實例對象
						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;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		//對建立的Bean實例對象進行類型檢查
<9>		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) {
				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;
	}

代碼很長，須要一些耐心，下面咱們來逐步分析這段代碼：this

  • <1>處：具體分析，見2.1獲取原始beanNameprototype

  • <2>處: 具體分析，見2.2從緩存中獲取單例bean

  • <3>處: 具體分析，見2.3獲取最終的bean實例對象

  • <4>處: 具體分析，見2.4原型模式依賴檢查

  • <5>處: 具體分析，見2.5標記bean爲已建立或即將建立

  • <6>處: 具體分析，見2.6獲取BeanDefinition

  • <7>處: 具體分析，見2.7bean依賴處理

  • <8>處: 具體分析，見2.8不一樣做用域bean的實例化

  • <9>處: 具體分析，見2.9類型轉換

2.一、獲取原始beanName

代碼以下：

final String beanName = transformedBeanName(name);

繼續深刻，代碼以下：

protected String transformedBeanName(String name) {
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}

BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修飾符

//對FactoryBean的轉義定義，由於若是使用bean的名字檢索FactoryBean獲得的對象是工廠生成的對象，
	//若是須要獲得工廠自己，須要轉義
	String FACTORY_BEAN_PREFIX = "&";

public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		String beanName = name;
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		return beanName;
	}

ps: 若是一個factoryBean的名稱爲「student」，獲取factoryBean建立的Bean時，使用getBean("student")，獲取factoryBean自己時，使用getBean("&student")
接着深刻，最終代碼以下：

/** Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


//循環處理，從aliasMap中根據aliasName獲取真實beanName，直到獲取到的真實beanName爲null
	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;
	}

主要是一個循環獲取 beanName 的過程，例如，別名 A 指向名稱爲 B 的 bean 則返回 B，若 別名 A 指向別名 B，別名 B 指向名稱爲 C 的 bean，則返回 C

2.二、從緩存中獲取單例bean

Spring 對單例模式的 bean 只會建立一次。後續，若是再獲取該 Bean ，則是直接從單例緩存中獲取，該過程就體如今 #getSingleton(String beanName) 方法中。代碼以下：

/** Cache of singleton objects: bean name --> bean instance */
	//單例bean的緩存
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	//單例對象工廠緩存
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	//預加載單例bean緩存
	//存放的 bean 不必定是完整的
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

//對於單例模式的Bean整個IOC容器中只建立一次，不須要重複建立
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//從單例緩存中獲取單例bean
		Object singletonObject = this.singletonObjects.get(beanName);
		//若是緩存中沒有 而且 該bean正在建立
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				// earlySingletonObjects 中沒有，且容許提早建立
				if (singletonObject == null && allowEarlyReference) {
					//從緩存中獲取 ObjectFactory
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						//從單例工廠中獲取bean
						singletonObject = singletonFactory.getObject();
						//存入early
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

這段代碼很簡單，流程以下：

  • 第一步，從singletonObjects中獲取Bean對象

  • 第二步，若是獲取不到且Bean正在建立中，從earlySingletonObjects獲取Bean對象

  • 第三步，若是獲取不到且容許提早建立,從singletonFactories獲取FactoryBean

  • 第四步，若是不爲null，則經過FactoryBean.getObject()獲取Bean，而後將其加入到 earlySingletonObjects ，而且從 singletonFactories 刪除，二者是互斥的，主要用來解決循環依賴的問題

  • 總結就是：從這三個Map依次去取，取不到就取下一個Map

2.2.一、isSingletonCurrentlyInCreation

在上面的代碼中又一個重要的方法isSingletonCurrentlyInCreation(beanName)，代碼以下：

private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	
public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

這個方法是用來判斷當前Bean是否在建立中，看到是個Map，咱們能夠猜想，應該有一個地方在建立Bean的時候，會把正在建立的BeanName給put到這個Map中。具體咱們以後將。

2.2.二、getObjectForBeanInstance

當咱們從getSingleton(beanName)拿到bean對象後，會接着調用getObjectForBeanInstance()方法，來獲取最終的Bean實例。

  • 爲何這裏要再獲取一次Bean呢，以前明明都拿到了呀？

  • 由於咱們從緩存中獲取的 bean 是最原始的 Bean ，並不必定是咱們最終想要的 Bean

  • 怎麼辦呢？調用 #getObjectForBeanInstance(...) 方法，進行處理，該方法的定義爲獲取給定 Bean 實例的對象，該對象要麼是 bean 實例自己，要麼就是 FactoryBean 建立的 Bean 對象。

看代碼：

//獲取給定Bean的實例對象，主要是完成FactoryBean的相關處理
	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		//容器已經獲得了Bean實例對象，這個實例對象多是一個普通的Bean，
		//也多是一個工廠Bean，若是是一個工廠Bean，則使用它建立一個Bean實例對象，
		//若是調用自己就想得到一個容器的引用，則指定返回這個工廠Bean實例對象

		//若爲工廠類引用（name 以 & 開頭） 且 Bean實例也不是 FactoryBean
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			//拋出異常
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		
		//若是類型不是FactoryBean，直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		//若 BeanDefinition 爲 null，則從緩存中加載 Bean 對象
		if (mbd == null) {
			//從Bean工廠緩存中獲取給定名稱的Bean實例對象
			object = getCachedObjectForFactoryBean(beanName);
		}

		// 若 object 依然爲空，則能夠確認，beanInstance 必定是 FactoryBean 。從而，使用 FactoryBean 得到 Bean 對象
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			// 檢測是否認義 beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
				//從容器中獲取指定名稱的Bean定義，若是繼承基類，則合併基類相關屬性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			//若是從容器獲得Bean定義信息，而且Bean定義信息不是虛構的，
			//則讓工廠Bean生產Bean實例對象
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//調用FactoryBeanRegistrySupport類的getObjectFromFactoryBean方法，
			//實現工廠Bean生產Bean對象實例的過程
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

首先看下這個方法的流程：

  • 一、類型檢查，判斷是不是FactoryBean

  • 二、對非 FactoryBean 不作處理

  • 三、對 bean 進行轉換

  • 四、處理 FactoryBean 類型：委託給 getObjectFromFactoryBean 方法進行處理。

咱們直接看第3步，走到這裏，說明這個bean必定是FactoryBean類型的，再從Ioc容器中獲取該beanName對應的BeanDefinition，若是不爲null，且不是abstract，則調用getObjectFromFactoryBean方法獲取bean實例

從這裏能夠看出， getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法，分紅兩種狀況：

  • 第一種，當該實例對象爲非 FactoryBean 類型，直接返回給定的 Bean 實例對象 beanInstance 。

  • 第二種，當該實例對象爲FactoryBean 類型，從 FactoryBean ( beanInstance ) 中，獲取 Bean 實例對象。

2.2.三、getObjectFromFactoryBean

咱們接着看第二種狀況：

//Bean工廠生產Bean實例對象
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		//爲單例模式且緩存中存在
		if (factory.isSingleton() && containsSingleton(beanName)) {
			//多線程同步，以防止數據不一致
1.1			synchronized (getSingletonMutex()) {
				//從緩存中獲取指定的 factoryBean
1.2				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					// 爲空，則從 FactoryBean 中獲取對象
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
1.3						if (shouldPostProcess) {
							try {
								// 對從 FactoryBean 獲取的對象進行後處理
								// 生成的對象將暴露給 bean 引用
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						//將生產的實例對象添加到Bean工廠緩存中
1.4						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
				return object;
			}
		}
		// 爲空，則從 FactoryBean 中獲取對象
2		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;
		}
	}

  • 一、判斷是否爲單例而且緩存中存在 若是存在，則順着1.1往下走，不存在，則走2的流程

  • 1.一、sync加鎖，鎖住的是singletonObjects，和其餘單例鎖同樣，保證全局惟一

  • 1.二、從緩存factoryBeanObjectCache中獲取Bean實例 若是獲取不到，則調用doGetObjectFromFactoryBean()方法獲取，實際最後調用的是factory.getObject()方法

  • 1.三、若是須要後續處理( shouldPostProcess = true )，則進行下一步處理 postProcessObjectFromFactoryBean() 方法，對從 FactoryBean 處獲取的 Bean 實例對象進行後置處理。其默認實現是直接返回 object 對象，不作任何處理。代碼以下：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
		return object;
	}

可是子類能夠重寫，例如應用後處理器等。

  • 1.四、加入到 factoryBeanObjectCache 緩存中
  • 二、若是緩存中不存在，一樣調用doGetObjectFromFactoryBean()獲取bean實例

總結：
到這裏，doGetBean()方法的2.2從緩存中獲取單例bean和2.3獲取最終的bean實例對象咱們已經分析完了，下篇文章咱們接着分析後面的步驟。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程