Spring IOC循環依賴源碼解析

目錄

什麼是循環依賴？

Bean註冊

Bean實例化

springIOC循環依賴總結

驗證

---

什麼是循環依賴？

所謂循環依賴就是A依賴B的同時B又依賴A，二者互相依賴，形成環路。試想，SpringIOC在初始化容器的時候，先實例化BeanA，發現BeanA依賴於BeanB，於是先去實例化BeanB，發現BeanB又依賴於BeanA，這就造成了循環依賴，如果程序不處理這種情況，就會陷入死循環，無限執行下去，直到程序崩潰。

我們今天要解決的問題就是摸清spring在初始化容器的時候是怎麼解決循環依賴這個問題的。這裏將以annotation註解注入的方式分析SpringIOC初始化整個過程，然後對循環依賴進行分析。本文篇幅很長，耐心看完，相信還是有所收穫的。

引入依賴：

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>4.3.11.RELEASE</version>
</dependency>

新建測試類：

@Component
public class AnnotationLeader {
    @Autowired
    private LeaderDepender leaderDepender;

    public AnnotationLeader() {
        System.out.println("Leader started........");
    }

    public void output() {
        System.out.println("my id is :" + leaderDepender.getId());
    }
}

@Component
public class LeaderDepender {
    private String id ;
    @Autowired
    private AnnotationLeader annotationLeader;

    public LeaderDepender() {
        this.id = "123456";
        System.out.println("Depender started........");
    }

    public String getId() {
        return id;
    }
}

public class AnnotationAppStartTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("com.cf.spring.code");
        AnnotationLeader leader = context.getBean(AnnotationLeader.class);
        leader.output();
    }
}

Bean註冊

開始之前看下springIOC容器類圖，對類的關係有個大致瞭解，在閱讀源碼的過程中，不熟悉的類多點進去看一看，降低暈車的嚴重程度。

進入容器啓動構造方法：new AnnotationConfigApplicationContext("com.cf.spring.code");

	public AnnotationConfigApplicationContext(String... basePackages) {
        // 註冊bean掃描器和bean讀取器
		this();
        // 這一步很關鍵，掃描包路徑下所有的class文件，解析成BeanDefinition並註冊BeanDefinition
		scan(basePackages);
		refresh();
	}
    public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

與此同時，子類執行構造方法之前會執行父類GenericApplicationContext的構造方法

public GenericApplicationContext() {
    // 初始化bean工廠
    this.beanFactory = new DefaultListableBeanFactory();
}

回過頭來看scan(basePackages)：

	public void scan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		this.scanner.scan(basePackages);
	}

public int scan(String... basePackages) {
    // 獲取已註冊bean的數量
    int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
    // 重點，往下看
    doScan(basePackages);

    // Register annotation config processors, if necessary.
    if (this.includeAnnotationConfig) {
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

    return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}

doScan在ClassPathBeanDefinitionScanner中

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
            // 定義容器存儲要返回的beanDefinition包裝類
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
            // 可能有多個包掃描路徑，遍歷要掃描的路徑
		for (String basePackage : basePackages) {
                // 在這裏得到了BeanDefinition，足以說明此方法的重要性，下面方法先忽略，先跟進去看看
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

	public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
		try {
                // 組裝包掃描路徑，將包名轉換成路徑（最終格式：classpath*：com/cf/spring/code/**/*.class）
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
                // 根據掃描路徑得到資源對象數組
			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
                // 遍歷資源對象數組，根據每個資源對象獲取beanDefinition
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
                                    // MetadataReader這個類裏面包含了類的元數據和註解的元數據信息，可以點進去類裏面看看
						MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                                    // 是否爲候選組件，判斷是否滿足bean注入條件，如果有@Conditional註解，則跳過。判斷是否有@Component、@Repository、@Service、@Controller標註
						if (isCandidateComponent(metadataReader)) {
                                    // 根據matadateReader構造BeanDefinition
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
                                    // 添加到BeanDefinition集合中，用於返回數據
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

現在我們回到doScan這裏

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
            // 定義容器存儲要返回的beanDefinition包裝類
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
            // 可能有多個包掃描路徑，遍歷要掃描的路徑
		for (String basePackage : basePackages) {
                // 在這裏得到了BeanDefinition，足以說明此方法的重要性，下面方法先忽略，先跟進去看看
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
                // 這兩步爲BeanDefinition綁定scope，不詳細說
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
                // 查看註解的value是否指定bean的名稱，在沒有指定beanName的情況下，以類名首字母小寫作爲beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                // 下面兩步判斷處理Autowired、initMethod、destroyMethod、lazy、Dependency on...這些配置的
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
                // 再檢查下這個bean是否需要被註冊
				if (checkCandidate(beanName, candidate)) {
                    // BeanDefinitionHolder裏面就幾個關鍵屬性： beanDefinition、beanName、aliases（別名，即可以根據別名找到BeanDefinition）
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                            // 添加到集合
					beanDefinitions.add(definitionHolder);
                            // 重點來了，註冊bean
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

重點跟進這個registerBeanDefinition方法

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
            // 繼續跟進
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}

	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
            // 看這裏，註冊BeanDefinition
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// 如果有別名，爲bean註冊別名
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

這裏調用的registerBeanDefinition其實是DefaultListableBeanFactory的方法，這個類很關鍵，他爲spring做了很多事情，話不多說，我們細看

	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}
        // 定義容器中已存在的舊的Bean
		BeanDefinition oldBeanDefinition;
        // Bean註冊後就是存放在beanDefinitionMap在，先從這裏面取，看下是否已存在
		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
		if (oldBeanDefinition != null) {
            // 如果不允許覆蓋
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + oldBeanDefinition + "] bound.");
			}
			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (this.logger.isWarnEnabled()) {
					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							oldBeanDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(oldBeanDefinition)) {
				if (this.logger.isInfoEnabled()) {
					this.logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (this.logger.isDebugEnabled()) {
					this.logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
            // 如果允許覆蓋的話，最終就是要覆蓋
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
            // 判斷是否有別的bean開始初始化了；注意，這裏的bean都還沒有初始化，只是註冊BeanDefinition
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// 正常流程應該是走到這個分支，將BeanDefinition放入這個map中存起來
				this.beanDefinitionMap.put(beanName, beanDefinition);
                // 這個ArrayList，所以spring會按照加載bean的順序保存beanname
				this.beanDefinitionNames.add(beanName);
                // spring會在後面手動註冊一些bean，如“environment”等
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
	}

Bean實例化

這一步已經到達了一個分水嶺，BeanDefinition已經成功註冊到容器中。這個時候我們回到AnnotationConfigApplicationContext的構造方法

	public AnnotationConfigApplicationContext(String... basePackages) {
        // 註冊bean掃描器和bean讀取器
		this();
        // 這一步很關鍵，掃描包路徑下所有的class文件，解析成BeanDefinition並註冊BeanDefinition
		scan(basePackages);
        // 就只有這個方法了，我們進去看看
		refresh();
	}

	public void refresh() throws BeansException, IllegalStateException {
		// 先來個鎖，不然容器還沒refresh，你又啓動個容器，那不得炸了，要知道是可以啓動多個容器的
		synchronized (this.startupShutdownMonitor) {
			// 記錄下容器啓動時間，標記爲“已啓動”
			prepareRefresh();

			// 這一步針對不同方式注入採取不同實現
			// 如果是xml方式，是在這一步初始化beanfactory，解析xml配置文件得到bean定義，
			// 掃描@component,@service,@repository，完成bean註冊
			// 如果爲annotation方式，在執行refresh之前就已經完成了BeanFactory的初始化
			// 和Bean容器註冊，此時裏面的邏輯是非常簡單的，我們進去看看
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 設置beanfactory的類加載器
			prepareBeanFactory(beanFactory);

			try {
				// Bean如果實現了BeanFactoryPostProcessor，容器在初始化以後會調用postProcessBeanFactory方法，並且子類可以對這步進行擴展
				postProcessBeanFactory(beanFactory);
    
				// 調用BeanFactoryPostProcessor實現類的postProcessBeanFactory回調
				invokeBeanFactoryPostProcessors(beanFactory);

				// 註冊BeanPostProcessor實現類
				registerBeanPostProcessors(beanFactory);

				// 初始化MessageSource，國際化
				initMessageSource();

				// 初始化事件廣播器
				initApplicationEventMulticaster();

				// 模版方法，子類可以在這一步初始化一些bean
				onRefresh();

				// 註冊監聽器（實現ApplicationListener）
				registerListeners();

				// 實例化所有非懶加載的singleton benas
				finishBeanFactoryInitialization(beanFactory);

				// 初始化完成廣播事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

進入obtainFreshBeanFactory()

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 跟進去看看
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

這裏說一下，AnnotationConfigApplicationContext繼承自GenericApplicationContext，而xml方式繼承自AbstractRefreshableApplicationContext。所以這裏我們找到GenericApplicationContext的refreshBeanFactory()

	protected final void refreshBeanFactory() throws IllegalStateException {
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
	}

看看這裏面多簡單，裏面啥也沒幹，set了個序列化id就返回了。當然如果是xml配置方式注入的話，這裏面就複雜多了，這個看看以後有空補充吧。

回到refresh()中，考慮到篇幅問題，中間過程就不詳細說了，我們直接跳到finishBeanFactoryInitialization(beanFactory)這個重頭戲，這裏負責初始化所有的singleton beans.

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化ConversionService的bean
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}

		// 初始化 LoadTimeWeaverAware類型的beans 屬於Aspectj的內容，直接過
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// 這個時候不希望再出現bean的加載、註冊、解析
		beanFactory.freezeConfiguration();

		// 重點，開始初始化，往下看
		beanFactory.preInstantiateSingletons();
	}

這裏又回到了DefaultListableBeanFactory中

	public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// 存儲beanName
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

		// 觸發所有非懶加載的singleton beans初始化
		for (String beanName : beanNames) {
			//合併父bean中配置
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//非抽象、非懶加載 的singletons
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 處理Bean Factory
				if (isFactoryBean(beanName)) {
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					// 判斷Bean Factory是否爲SmartFactoryBean的實現，跳過
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean<?>) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						// 初始化Bean
						getBean(beanName);
					}
				}
				else {
					// 對於普通的Bean，正常流程是走到這個分支，調用getBean進行初始化，跟進去
					getBean(beanName);
				}
			}
		}

		// SmartInitializingSingleton實現的回調，跳過
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction<Object>() {
						@Override
						public Object run() {
							smartSingleton.afterSingletonsInstantiated();
							return null;
						}
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

跟進去看到doGetBean

	// getBean這個方法我們經常用來獲取Bean實例，如果已經初始化直接從容器中返回
	public Object getBean(String name) throws BeansException {
		// 繼續往下
		return doGetBean(name, null, null, false);
	}

	
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
		// 處理別名和FactoryBean，得到正確的BeanName
		final String beanName = transformedBeanName(name);
		// 這個就是返回的bean
		Object bean;

		// 檢查下早期singleton緩存中是否已經存在這個bean，也就是這個bean是不是已經創建過了,如果不爲空，返回這個bean實例
		// 後面講ioc循環依賴會用到
		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直接返回sharedInstance，Factory Bean返回它創建的實例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 如果此bean的scope爲prototype，並且已經創建過了
			// 拋出異常，這時多半是陷入了循環引用，而spring並不能處理prototype類型的循環引用
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 檢查 bean definition 在容器中是否存在
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// 沒有的話，去父容器中找
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// 返回父容器結果
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

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

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

				// 初始化depends-on中定義的依賴
				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 + "'");
						}
						// 註冊依賴關係
						registerDependentBean(dep, beanName);
						getBean(dep);
					}
				}

				// 如果scope爲singleton，創建singleton的實例
				if (mbd.isSingleton()) {
					// spring處理循環依賴的一個步驟，後面講
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							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.
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 如果scope爲prototype，創建prototype的實例
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						// 創建prototype實例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				// 如果非scope也非prototype，委託給他的實現類
				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, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								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;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			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;
	}

沒錯，接下來我們就是要研究createBean方法了

	protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
			throws BeanCreationException;

又是抽象方法，這個方法的實現在AbstractAutowireCapableBeanFactory中，這個類可以處理註解和xml兩種方式混合使用的場景

	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		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);
		}

		// 準備方法複寫，如果類中有定義lookup-method和replaced-method
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			// 讓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);
		}
		// 這裏纔是重點，創建bean實例的地方
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

到這裏爲止，bean註冊已經完成，但還沒有完成初始化。在整個分析過程中，我們還沒有談及到任何有關IOC循環依賴的問題，那麼接下來請注意，前方高能，請坐穩扶好。

進入到doCreateBean中

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

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 如果是factory Bean則從緩存中移除
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 如果不是factory Bean， 實例化bean，這裏很關鍵，重點分析
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 獲取bean實例
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		// 類型
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;
		// 這裏建議還是跳過吧
		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 解決循環依賴的重點，待會兒細說
		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");
			}
			// 將bean實例添加到singletonFactories緩存，並從earlySingletonObjects中移除
			// 暴露早期的對象引用（這個時候bean實例還沒有初始化完全）
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 這一步非常關鍵，負責裝配屬性，給屬性設值
			// 也就是在這之前，bean只是完成實例化，但屬性還沒有賦值
			// spring 解決循環依賴最巧妙的地方就是把bean初始化的過程分成了兩步
			// bean實例化和屬性賦值
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				// 處理bean初始化完成後的各種回調
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		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<String>(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.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

這裏有幾個比較重要的方法：createBeanInstance（創建bean實例）、addSingletonFactory（暴露早期對象引用）、populateBean（依賴注入），裏面一些代碼也是比較複雜的，這裏我們挑重點部分分析就好。

首先來看一下創建實例：createBeanInstance

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		// 確保這個時候class已經完成加載
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		// 檢查一下類的訪問權限
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}
        
		if (mbd.getFactoryMethodName() != null)  {
			// 採用工廠方法實例化
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
		// 是否第一次創建，主要用於scope爲prototype的情況下，
		// 在第二次創建的時候，可以從第一次實例化知道實例化的方式：構造函數依賴注入 || 無參構造函數
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				// 構造函數依賴注入				
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 調用無參構造函數實例化
				return instantiateBean(beanName, mbd);
			}
		}

		// 需要判斷是否採用有參構造函數
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			// 構造函數依賴注入
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 正常情況下，是走到這裏，調用無參構造函數實例化
		return instantiateBean(beanName, mbd);
	}

來看下這個無參構造函數實例化：

	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			final BeanFactory parent = this;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
					@Override
					public Object run() {
						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
					}
				}, getAccessControlContext());
			}
			else {
				// 直接看這裏，具體實例化的實現，走
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			}
			// 包裝一層，返回這個
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

我們直接進入到instantiate裏面，這個方法在SimpleInstantiationStrategy這個類中：

	public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
		// 如果這個類不存在方法覆寫，使用java反射實例化，否則使用CGLIB
		if (bd.getMethodOverrides().isEmpty()) {
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
								@Override
								public Constructor<?> run() throws Exception {
									return clazz.getDeclaredConstructor((Class[]) null);
								}
							});
						}
						else {
							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			// 直接看這裏，使用構造方法實例化
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// 存在方法覆寫，必需使用CGLIB實現實例化，因爲jdk沒有提供override相應實例化支持
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

去這個實例化的工具類裏面看下instantiateClass方法

	public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
		Assert.notNull(ctor, "Constructor must not be null");
		try {
			ReflectionUtils.makeAccessible(ctor);
			// 就是這裏了，最終實例化的操作，調用構造器的newInstance實例化
			return ctor.newInstance(args);
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
		}
	}

到這裏，bean實例化總算是完成了，我們看下暴露早期對象引用的過程

暴露早期對象引用（addSingletonFactory）：

			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					// 這裏返回的就是早期bean的引用
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
	// 看看這裏做了些什麼
	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		// singletonObjects：存放實例化完全的bean實例
		// 鎖起來，這個時候你肯定不能往singletonObjects裏塞東西了
		synchronized (this.singletonObjects) {
			if (!this.singletonObjects.containsKey(beanName)) {
				// singletonFactories：singleton bean工廠緩存
				// 把獲取bean實例的ObjectFactory放進這個緩存
				this.singletonFactories.put(beanName, singletonFactory);
				// earlySingletonObjects：存放早期singleton beans 實例
				// 把bean從這個緩存中移除
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}

在這裏面我們看到了spring ioc的三級緩存

	/** Cache of singleton objects: bean name --> bean instance */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
	/** 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);

• singletonObjects（一級緩存）：存放實例化完全的singleton bean實例

• earlySingletonObjects（二級緩存）：存放提前曝光的實例對象（尚未填充屬性）

• singletonFactories（三級緩存）：存放singleton bean工廠對象

到這一步，已經得到了屬性未賦值的bean實例，並且將bean實例對象工廠放入三級緩存singletonFactories中。我們接着看populateBean

屬性注入（populateBean）：

	protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
		// bean實例所有屬性
		PropertyValues pvs = mbd.getPropertyValues();

		if (bw == null) {
			if (!pvs.isEmpty()) {
				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;
		}

		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// Add property values based on autowire by name if applicable.
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				// 通過名字裝配，如果是bean依賴，初始化依賴的bean並且記錄依賴關係
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// Add property values based on autowire by type if applicable.
			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) {
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						// 這裏有個非常有用的BeanPostProcessor：AutowiredAnnotationBeanPostProcessor
						// 對使用@Autowired、@Value註解的依賴進行注入
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
        // 最後設置bean屬性值
		applyPropertyValues(beanName, mbd, bw, pvs);
	}

至此，屬性賦值完畢，bean初始化已經完成。現在我們分析一下循環依賴的過程，回到剛開始創建bean實例的doGetBean方法中。

//AbstractBeanFactory：235行

	protected <T> T doGetBean(
		 ......

		// 檢查下早期singleton緩存中是否已經存在這個bean，也就是這個bean是不是已經創建過了,如果不爲空，返回這個bean實例
		// 後面講ioc循環依賴會用到
		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直接返回sharedInstance，Factory Bean返回它創建的實例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

				 ......

				// 如果scope爲singleton，創建singleton的實例
				if (mbd.isSingleton()) {
					// spring處理循環依賴的一個步驟，後面講
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							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.
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
			   ......
	}

這裏有兩個getSingleton，一個是 getSingleton(beanName)，一個是getSingleton(beanName, new ObjectFactory<Object>())，先看第一個getSingleton(beanName)

	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}

	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 先到一級緩存中獲取初始化完全的bean實例
		Object singletonObject = this.singletonObjects.get(beanName);
		// 一級緩存中沒有
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				// 到二級緩存中獲取未初始化完全的bean實例(屬性未賦值)
				singletonObject = this.earlySingletonObjects.get(beanName);
				// 二級緩存中也沒有
				if (singletonObject == null && allowEarlyReference) {
  					// 那就只能到三級緩存中獲取bean實例工廠對象了
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						// 從bean工廠中獲取bean實例
						singletonObject = singletonFactory.getObject();
						// 把bean實例放入二級緩存中
						this.earlySingletonObjects.put(beanName, singletonObject);
						// 二級緩存中有了，singletonFactories中就沒必要存在了，所以移除掉
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}

如果第一步getSingleton拿不到bean實例說明該對象還沒有實例化，就需要創建bean實例，這個時候就調用了getSingleton(beanName, new ObjectFactory<Object>())

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
	@Override
	public Object getObject() throws BeansException {
		try {
			return createBean(beanName, mbd, args);
		}
		......
	}
});

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' must not be null");
		// 這裏要singletonObjects進行操作，先鎖起來
		synchronized (this.singletonObjects) {
			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<Exception>();
				}
				try {
					// 主要就是這一步，調用singletonFactory.getObject獲取bean實例
					// 本質上就是調用外層的createBean方法創建bean實例
					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) {
					// 解決循環依賴的步驟，就是在這一步把初始化完整（屬性已賦值）的bean實例添加到一級緩存中，我們跟進去看看這個方法
					addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

在這一步裏，得到了實例化完整的bean實例，並調用addSingleton把bean實例put到singletonObjects中，來看看addSingleton

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 將bean實例放入到一級緩存中
			this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
			// 將bean實例工廠對象從三級緩存中移除
			this.singletonFactories.remove(beanName);
			// 將ben實例從二級緩存中移除
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

springIOC循環依賴總結

springIOC解決循環依賴的核心在於兩點：

• 把bean實例初始化分成兩個部分：創建bean實例和屬性賦值；這個是必要前提。
• 三級緩存：singletonObjects、earlySingletonObjects、singletonFactories

假設有A、B兩個對象循環依賴，先實例化A對象。

• 1.執行new AnnotationConfigApplicationContext（）構造方法，掃描包路徑，調用DefaultListableBeanFactory.registerBeanDefinition完成bean註冊
• 2.調用AnnotationConfigApplicationContext.refresh()，調用getBean，getBean是個空殼，真正獲取實例的方法是doGetBean，調用doGetBean獲取beanA實例
• 3.在doGetBean中執行Object sharedInstance = getSingleton(beanName)，此時緩存中是沒有beanA實例的，於是調用創建bean實例的方法sharedInstance = getSingleton(beanName, new ObjectFactory<Object>())。

// doGetBean

	protected <T> T doGetBean(
		 ......
		// 檢查下早期singleton緩存中是否已經存在這個bean，也就是這個bean是不是已經創建過了,如果不爲空，返回這個bean實例
		// 後面講ioc循環依賴會用到
		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直接返回sharedInstance，Factory Bean返回它創建的實例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
				 ......

				// 如果scope爲singleton，創建singleton的實例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							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.
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
			   ......
	}

• 4.調用createBean，在doCreateBean中獲取beanA實例（屬性未賦值），在instanceWrapper = createBeanInstance(beanName, mbd, args)這一步就得到了beanA實例

// doCreateBean

		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);// 獲取bean實例
		}

• 5.暴露beanA早期對象引用，在這一步把屬性未賦值的beanA實例工廠對象，放入了springIOC的三級緩存singletonFactories中

// doCreateBean

			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});

• 6.給beanA屬性賦值，即執行populateBean(beanName, mbd, instanceWrapper);

// doCreateBean

		try {
			populateBean(beanName, mbd, instanceWrapper);// 屬性注入
			if (exposedObject != null) {
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}

• 7.beanA屬性賦值的過程中，發現beanA依賴beanB，要先初始化beanB，於是調用BeanFactory.getBean.getBean，getBean會調用doGetBean，再執行getSingleton(beanName)，發現一、二、三級緩存中都沒有beanB實例，執行createBean方法，調用doCreateBean

// doGetBean

	protected <T> T doGetBean(
		 ......
		// 檢查下早期singleton緩存中是否已經存在這個bean，也就是這個bean是不是已經創建過了,如果不爲空，返回這個bean實例
		// 後面講ioc循環依賴會用到
		Object sharedInstance = getSingleton(beanName);
	
				 ......

				// 如果scope爲singleton，創建singleton的實例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
								// 真正執行Bean實例化的方法，先別急後面重點說
								return createBean(beanName, mbd, args);
							}
							......
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
			   ......
	}

• 8.獲取beanB實例（屬性未賦值），調用addSingletonFactory暴露beanB早期對象引用，把屬性未賦值的beanB實例工廠對象，放入了springIOC的三級緩存singletonFactories中，此時singletonFactories中已經緩存了beanA和beanB的工廠對象

// doCreateBean

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
		......
		if (instanceWrapper == null) {
			// 如果不是factory Bean， 實例化bean，這裏很關鍵，重點分析
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 獲取bean實例
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		......

		// 解決循環依賴的重點，待會兒細說
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			......
			// 將bean實例添加到singletonFactories緩存，並從earlySingletonObjects中移除
			// 暴露早期的對象引用（這個時候bean實例還沒有初始化完全）
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}
		......
	}

• 9.給beanB進行屬性賦值，發現beanB依賴beanA，執行populateBean進行屬性賦值，裏面最終會BeanFactory.getBean去獲取beanA實例

// doCreateBean

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

		Object exposedObject = bean;
		try {
			// 這一步非常關鍵，負責裝配屬性，給屬性設值
			// 也就是在這之前，bean只是完成實例化，但屬性還沒有賦值
			// spring 解決循環依賴最巧妙的地方就是把bean初始化的過程分成了兩步
			// bean實例化和屬性賦值
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				// 處理bean初始化完成後的各種回調
				exposedObject = initializeBean(beanName, exposedObject, mbd);
			}
		}
		......
	}

• 10.getBean會調用doGetBean，執行getSingleton。
• 嘗試從一級緩存singletonObjects中獲取初始化完全的beanA實例，發現沒有。
• 再從二級緩存earlySingletonObjects中獲取屬性未賦值的beanA實例，也沒有。
• 最終在三級緩存singletonFactories拿到了beanA實例(屬性未賦值)，將beanA實例放入二級緩存earlySingletonObjects中
• 這個時候beanB注入beanA屬性成功，beanB初始化完成。

// doGetBean

	protected <T> T doGetBean(
		 ......
		// 檢查下早期singleton緩存中是否已經存在這個bean，也就是這個bean是不是已經創建過了,如果不爲空，返回這個bean實例
		// 後面講ioc循環依賴會用到
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			......
			}
			// 普通bean直接返回sharedInstance，Factory Bean返回它創建的實例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		......
	}

• 11.到上一步爲止，已經通過createBean方法完成了beanB的初始化，現在回到實例化beanB時調用的getSingleton(beanName, new ObjectFactory<Object>() )。在beanB的實例化完成後，會執行addSingleton把beanB實例放入一級緩存singletonObjects中，並從二級和三級緩存中移除。

// doGetBean

	protected <T> T doGetBean(
				......
				// 如果scope爲singleton，創建singleton的實例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
								// 真正執行Bean實例化的方法，先別急後面重點說
								return createBean(beanName, mbd, args);
							}
						.......
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
			   ......
	}

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
				......
				try {
					// 主要就是這一步，調用singletonFactory.getObject獲取bean實例
					// 本質上就是調用外層的createBean方法創建bean實例
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				......
				if (newSingleton) {
					// 解決循環依賴的步驟，就是在這一步把初始化完整（屬性已賦值）的bean實例添加到一級緩存中，我們跟進去看看這個方法
					addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

• 12.同樣的，此時beanB初始化已完成。beanA也拿到了beanB實例，屬性依賴注入成功，beanA初始化完成，同樣會執行addSingleton把beanA實例放入一級緩存singletonObjects中。至此beanA和beanB都已實例化完全。

驗證

還有最後一個疑問，在分析springIOC解決循環依賴的過程中，我們說在執行屬性注入方法populateBean的時候會調BeanFactory.getBean獲取依賴的bean屬性。那麼真的是這樣麼？我們來驗證一下：

本文例子中是使用@Autowired進行屬性注入，前面我們說過AutowiredAnnotationBeanPostProcessor，它是專門用來給使用@Autowired、@Value註解的依賴進行注入
// populateBean

	protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
		......
		if (hasInstAwareBpps || needsDepCheck) {
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						// 這裏有個非常有用的BeanPostProcessor：AutowiredAnnotationBeanPostProcessor
						// 對使用@Autowired、@Value註解的依賴進行注入
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
		......
	}

我們可以在populateBean方法的InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp

這一行打個斷點，加上過濾條件，根進下面這一行，一個個點進去看看

pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

 

一路跟蹤下去，會先調用beanFactory.resolveDependency

// AutowiredAnnotationBeanPostProcessor:585行

		protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
				// ......
				try {
					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				}
				catch (BeansException ex) {
				// ......
		}
	}

debug進去，發現又回到了DefaultListableBeanFactory這個類，執行doResolveDependency
// DefaultListableBeanFactory

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

		......
		else {
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				// 就是這裏了，解析依賴
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

繼續跟進，在doResolveDependency中會調用descriptor.resolveCandidate
// DefaultListableBeanFactory

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

			......
			return (instanceCandidate instanceof Class ?
					// 就是這裏了，解析候選bean
					descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

再debug進descriptor.resolveCandidate
// DependencyDescriptor

	public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
			throws BeansException {
		// 最終又回到了getBean
		return beanFactory.getBean(beanName, requiredType);
	}

看到了什麼？沒錯，最終還是調的getBean去實例化依賴bean屬性。好了，驗證完畢，沒毛病。
這是@Autowire方式的依賴注入，感興趣的朋友也可以試下別的依賴注入方式。