今天開門見山，直接亮程式碼~

MyTestBean bean = (MyTestBean)bf.getBean("myTestBean")

spring分為7大部分組成，有一個部分叫做:SpringBean；

為了知道這句程式碼實現了什麼樣的功能，看官可以可以開啟你的開發工具，找到下面這張圖的幾個包；

首先開啟AbstractBeanFactory 這個類， 找到 getBean 這個方法:

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

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
//把beanName 前面可能存在的 所有符號 全部取出；
		final String beanName = transformedBeanName(name);
		Object bean;

		/**
 * spring會先檢查快取中或者例項工廠中是否有對應的例項，因為在建立單例bean的時候回存在醫療注入的情況；
  * 而在建立以來的時候為了避免迴圈依賴，spring建立bean的原則是不等bean建立完成就會將建立bean的 objectfactory提前曝光，
 * 也就是將objectFactory加入到快取中，一旦下一個bean建立的時候需要依賴上個bean則直接使用objectfactory； 
 */
		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 + "'");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
 

迴圈依賴是什麼意思呢？  如果存在 A中有B的屬性，B中又有A的屬性，那麼當依賴注入的時候，就會產生A還未完成建立的時候又去建立B，又再次返回建立A；

進入   getSingleton(beanName) 方法 會跳到 DefaultSingletonBeanRegistry 這個類的

再次進入 getSingleton（beanName, true ）這個方法；

進入這個方法之前，先了解一個概念，單例在spring的同一個容器中只會被建立一個，之後獲取bean就可以直接衝單例的快取中獲取了；

下面介紹的就是從快取中獲取bean的情況；

這樣就返回了單例的 singletonObject

看到這裡，你可能不知道 singletonFactory怎麼來的， 進入  singletonFactories 這個 引用去看看：

/** Cache of singleton objects: bean name --> bean instance */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

	/** Set of registered singletons, containing the bean names in registration order */
	private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

因為 singletonFactory實現了 ObjectFactory這個介面； spring全家桶 會根據 beanName去建立 一個singletonFactory；

上面是從緩衝中獲取單例，那麼緩衝中要是不存在已經載入好的單例bean，那就要重頭開始執行載入bean了，spring重寫了getSingleton，

public Object getSingleton （ String beanName, ObjectFactory singletonFactory） {  ......    }

從上面程式碼可以看到，spring依賴注入時，使用了雙重判斷加鎖的單例模式，首先從快取中獲取bean例項，如果為null，對快取map加鎖，然後再從快取中獲取bean，如果繼續為null，就建立一個bean。這樣雙重判斷，能夠避免在加鎖的瞬間，有其他依賴注入引發bean例項的建立，從而造成重複建立的結果。

Spring並沒有使用我們常見的私有構造方法來建立bean，而是通過singletonFactory.getObject()返回具體beanName對應的ObjectFactory來建立bean。

這就是spring獲取bean的一個簡單流程；建立了spring的bean物件，還沒完，還沒有例項化這個bean。 且聽下回分解~