概述
這個方法我們並不陌生，通常我們在程序中都會先獲取到ApplicationContext，之后調用getBean()方法獲取bean，那這個方法是如何獲取的bean呢？下面就來分析一下
getBean()方法
public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); }
doGetBean()方法
這里我先說一下這個方法的調用流程
- 轉換beanName的名稱，因為Bean和FactoryBean不同，獲取bean的方法不同，如果要想獲取FactoryBean，需要在beanName前面加上&符號
- 從singletonObjects中獲取，實例化好的bean都會放到這個容器中
- 如果singletonObjects不存在，就從bean的父bean中尋找
- 如果父bean中也不存，就要執行創建過程了，第一步合並beanDefiniton(因為bean可能繼承了很多的父類，把所有的屬性合並，以字類的屬性優先)
- 判斷bean有沒有依賴的bean，如果有，先創建依賴的bean
- 判斷bean是單例模式還是原型模式，還是以上兩者都不是，不同的模式采用不同的創建方法
- 創建完成
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //1. 如果name不是以&開頭，直接返回name，如果是以&開頭，去掉&，有多少去掉多少，之后返回，並且把name，和去掉&之后的name作為key-value存入一個 //緩存map中 //2. 轉換別名，獲得bean的真名 final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons.//如果拿到單例bean直接返回 Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } // 為什么要調用 getObjectForBeanInstance 方法,判斷當前Bean是不是FactoryBean,如果是,那么要調用getObject方法 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } //如果bean沒有創建，從父容器查找beanName對應的bean，如果存在就直接返回 else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. //這里使用了一個threadlocal包裹這個一個對象，用來處理循環依賴，后面看一下這個是怎么解決循環依賴的 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. //這里的parentBeanFactory是在初始化的時候賦值的，但是這個初始化的過程中調用的是無參構造函數，並沒有 //賦值，還有一個地方就是setParentBeanFactory，這個也可以賦值，但是沒有找到是在哪里調用的 BeanFactory parentBeanFactory = getParentBeanFactory(); //判斷當前類的父類是否為空和在之前從xml中加載bean的時候有沒有把這個name放入到ioc的那個map中 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { //parentBeanFactory就是父容器，從父容器中獲取 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 if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { //將當前的name放入alreadyCreated這個map中 markBeanAsCreated(beanName); } try { //這一步返回的實際上是MergeBeadDefinition，什么意思呢，就是一個bean可以設置parent屬性， //但是這個parent並不是常說的繼承來的parent，而是在定義bean的時候可以設置，那下面的方法其實就是 //把父類中的一些屬性賦值給字類，如果字類中也存在該屬性的值，優先使用字類的，如果字類不存在就是使用父類的 //這里科普個關於BeanDefinition的例子，這個就是AbstractBeanDefinition，這個是所有具體實現的beanDefinition //的抽象父類，然后有幾個具體實現的字類RootBeanDefinition，GenericBeanDefinition,ChildBeanDefinition,有這三個 //實現類，其中第一個不能擁有parent //如果父容器中不存在，就合並beanDefinition final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //判斷mbd是不是抽象的 checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. //這個可能來自於上面根據beanName得到的那個mbd //檢查是否有依賴的bean，如果有，先實例化依賴的bean String[] dependsOn = mbd.getDependsOn(); //當前來看，我的例子這個為null //如果有依賴的bean，解決循環依賴的問題 if (dependsOn != null) { //通過for循環把依賴的map全部是實例化放入到容器中 for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //將依賴的map放入依賴map中 registerDependentBean(dep, beanName); try { //在這里獲取依賴的bean，如果這里存在循環依賴就會有問題 getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. if (mbd.isSingleton()) { //有了beanDefinition，創建bean，這個getSingleton其實就是調用了ObjectFactory中的getObject方法 //這里最重要的是才createBean方法 sharedInstance = getSingleton(beanName, () -> { try { 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; } }); //這里是說看一下上面創建的那個shareInstance是是一個什么類型的bean，如果是factoryBean之類的需要調用 //一下getObject()獲取真正的bean bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } //創建prototype類型的bean 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); } //創建其他類型的bean else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'"); } 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 ScopeNotActiveException(beanName, scopeName, ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } }
以上方法調用的子方法很多，我分析一下createBean()，剩下的一些子方法大家自己看一下
createBean()方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } //這里的mbd就是合並之后的beanDefinition,這里搞了一個副本，之后的操作都是基於副本的 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. //1.解析beanName對應的bean類型，比如com.test.IOCServiceImpl Class<?> resolvedClass = resolveBeanClass(mbd, beanName); // 如果resolvedClass存在，並且mdb的beanClass類型不是Class，並且mdb的beanClass不為空（則代表beanClass存的是Class的name）, if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { // 則使用mdb深拷貝一個新的RootBeanDefinition副本，並且將解析的Class賦值給拷貝的RootBeanDefinition副本的beanClass屬性， // 該拷貝副本取代mdb用於后續的操作 mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { // 2.驗證及准備覆蓋的方法（對override屬性進行標記及驗證） //這里就是為了解決xml中配置的什么lookup-method，這里做的操作就是對於存在override的bean做一個標記 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. // 3.實例化前的處理，給InstantiationAwareBeanPostProcessor一個機會返回代理對象來替代真正的bean實例，達到“短路”效果 //這個就是aop操作的，在切面前編程 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { // 4.如果bean不為空，則會跳過Spring默認的實例化過程， return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { // 5.創建Bean實例（真正創建Bean的方法） Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("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); } }
這個里面有兩個比較重要的方法
-
resolveBeforeInstantiation(beanName, mbdToUse);
-
doCreateBean(beanName, mbdToUse, args);
第一個方法和aop有關，下篇文章在分析，下面分析一下第二個方法
這個方法處理流程
- 實例化bean,但是這個bean是沒有屬性的
- 填充屬性
- 解決循環依賴
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { //從這個緩存中移除並獲取 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //創建bean，有三種方式 instanceWrapper = createBeanInstance(beanName, mbd, args); } //這里的bean是沒有填充屬性的，是一個空的bean final Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. // 這里又遇到后置處理了，此處的后置處理是用於處理已“合並的 BeanDefinition” 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. /** * earlySingletonExposure 是一個重要的變量，這里要說明一下。該變量用於表示是否提前暴露 * 單例 bean，用於解決循環依賴。earlySingletonExposure 由三個條件綜合而成，如下： * 條件1：mbd.isSingleton() - 表示 bean 是否是單例類型 * 條件2：allowCircularReferences - 是否允許循環依賴 * 條件3：isSingletonCurrentlyInCreation(beanName) - 當前 bean 是否處於創建的狀態中 * * earlySingletonExposure = 條件1 && 條件2 && 條件3 * = 單例 && 是否允許循環依賴 && 是否存於創建狀態中。 */ boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } // 添加工廠對象到 singletonFactories 緩存中，在第一步中getSingleton，有從這個緩存singletonFactories獲取 //工廠，之后創建bean addSingletonFactory(beanName, // 獲取早期 bean 的引用，如果 bean 中的方法被 AOP 切點所匹配到，此時 AOP 相關邏輯會介入 () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 向 bean 實例中填充屬性，populateBean 方法也是一個很重要的方法，后面會專門寫文章分析 populateBean(beanName, mbd, instanceWrapper); /* * 進行余下的初始化工作，詳細如下： * 1. 判斷 bean 是否實現了 BeanNameAware、BeanFactoryAware、 * BeanClassLoaderAware 等接口，並執行接口方法 * 2. 應用 bean 初始化前置操作 * 3. 如果 bean 實現了 InitializingBean 接口，則執行 afterPropertiesSet * 方法。如果用戶配置了 init-method，則調用相關方法執行自定義初始化邏輯 * 4. 應用 bean 初始化后置操作 * * 另外，AOP 相關邏輯也會在該方法中織入切面邏輯，此時的 exposedObject 就變成了 * 一個代理對象了 */ exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } //處理循環依賴 if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { //注冊bean registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
進入createBeanInstance()方法
/** 在上面分注釋中，factory method, constructor autowiring, or simple instantiation，這個寫的很清楚 * 就是可以采用三種方式實例化一個bean * 創建 bean 實例，並將實例包裹在 BeanWrapper 實現類對象中返回。createBeanInstance * 中包含三種創建 bean 實例的方式： * 1. 通過工廠方法創建 bean 實例 * 2. 通過構造方法自動注入（autowire by constructor）的方式創建 bean 實例 * 3. 通過無參構造方法方法創建 bean 實例 * * 若 bean 的配置信息中配置了 lookup-method 和 replace-method，則會使用 CGLIB * 增強 bean 實例。關於這個方法，后面會專門寫一篇文章介紹，這里先說這么多。 */ protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // Make sure bean class is actually resolved at this point. 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()); } /* * 當多次構建同一個 bean 時，可以使用此處的快捷路徑，即無需再次推斷應該使用哪種方式構造實例， * 以提高效率。比如在多次構建同一個 prototype 類型的 bean 時，就可以走此處的捷徑。 * 這里的 resolved 和 mbd.constructorArgumentsResolved 將會在 bean 第一次實例 * 化的過程中被設置，在后面的源碼中會分析到，先繼續往下看。 */ //RootBeanDefinition，在這個玩意中有一個構造方法給這個玩意賦值，之后就可以使用這個函數式接口實例化 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } //這里使用的是工廠方法創建 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // Shortcut when re-creating the same bean... boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } //這里使用的是自動注入構造方法創建bean if (resolved) { // 通過“構造方法自動注入”的方式構造 bean 對象 if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { // 通過“默認構造方法”的方式構造 bean 對象 return instantiateBean(beanName, mbd); } } // Candidate constructors for autowiring? Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { //bean初始化 return autowireConstructor(beanName, mbd, ctors, args); } // Preferred constructors for default construction? ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); } // No special handling: simply use no-arg constructor. //使用無參構造函數初始化bean return instantiateBean(beanName, mbd); }
總結
總的來說創建bean的過程代碼寫的很清晰，邏輯的過程頁很容易明白，這里其實有兩個問題沒有解決，一個就是在創建單例模式的bean的時候，循環依賴是如何解決的，第二個問題就是aop在這個里面是如何織入的，之后會寫文章分析上面的兩個問題
參考文章