[TOC] <br/> <br/>  > `getBean()`創建單例bean實例 * `getBean`調用`getSingleton(beanName, ObjectFactory)`，匿名工廠類中的`getObject()`方法調用了`creatBean()`。 * 對于已實例化好的單例`bean`，`getBean(String)`方法并不會再一次去創建，而是從緩存中獲取。如果緩存中沒有則根據`bean`的配置信息去創建這個`bean`。 ``` public T doGetBean(...) { // ... if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { try { //調用creatBean方法 return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } //... ``` <br/> > ### `getSingleton(String, ObjectFactory)`方法 ``` public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "'beanName' must not be null"); synchronized (this.singletonObjects) { // 從緩存中獲取單例 bean，若不為空，則直接返回，不用再初始化 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 + "'"); } /* * 將 beanName 添加到 singletonsCurrentlyInCreation 集合中， * 用于表明 beanName 對應的 bean 正在創建中 */ beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<Exception>(); } try { // 通過 getObject 方法調用 createBean 方法創建 bean 實例 singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { 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; } // 將 beanName 從 singletonsCurrentlyInCreation 移除 afterSingletonCreation(beanName); } if (newSingleton) { /* * 將 <beanName, singletonObject> 鍵值對添加到 singletonObjects 集合中， * 并從其他集合（比如 earlySingletonObjects）中移除 singletonObject 記錄 */ addSingleton(beanName, singletonObject); } } return (singletonObject != NULL_OBJECT ? singletonObject : null); } } ``` <br/> > ### `createBean `方法 ``` 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<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } try { // 處理 lookup-method 和 replace-method 配置，Spring 將這兩個配置統稱為 override method mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // 在 bean 初始化前應用后置處理，如果后置處理返回的 bean 不為空，則直接返回 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } // 調用 doCreateBean 創建 bean Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isDebugEnabled()) { logger.debug("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } ``` <br/> > ### `doCreateBean `方法 ``` protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException { // BeanWrapper 包裝bean實例 //通過 BeanWrapper 的實現類可以方便的設置/獲取 bean 實例的屬性 BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { // 從緩存中獲取 BeanWrapper，并清理相關記錄 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { /* * 創建 bean 實例，并將實例包裹在 BeanWrapper 實現類對象中返回。createBeanInstance * 中包含三種創建 bean 實例的方式： * 1. 通過工廠方法創建 bean 實例 * 2. 通過構造方法自動注入（autowire by constructor）的方式創建 bean 實例 * 3. 通過無參構造方法方法創建 bean 實例 * * 若 bean 的配置信息中配置了 lookup-method 和 replace-method，則會使用 CGLIB * 增強 bean 實例。 */ instanceWrapper = createBeanInstance(beanName, mbd, args); } // 此處的 bean 可以認為是一個原始的 bean 實例，暫未填充屬性 final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null); Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null); mbd.resolvedTargetType = beanType; // 這里又遇到后置處理了，此處的后置處理是用于處理已“合并的 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; } } 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"); } // 添加工廠對象到 singletonFactories 緩存中 addSingletonFactory(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { // 獲取早期 bean 的引用，如果 bean 中的方法被 AOP 切點所匹配到，此時 AOP 相關邏輯會介入 return getEarlyBeanReference(beanName, mbd, bean); } }); } Object exposedObject = bean; try { // 向 bean 實例中填充屬性，populateBean 方法也是一個很重要的方法，后面會專門寫文章分析 populateBean(beanName, mbd, instanceWrapper); if (exposedObject != null) { /* * 進行余下的初始化工作，詳細如下： * 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) { // 若 initializeBean 方法未改變 exposedObject 的引用，則此處的條件為 true。 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."); } } } } try { // 注冊銷毀邏輯 registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; } ``` <br/> <br/> *** > ### 參考 #### [Spring-IOC-容器源碼分析-創建單例-bean](http://www.tianxiaobo.com/2018/06/04/Spring-IOC-%E5%AE%B9%E5%99%A8%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90-%E5%88%9B%E5%BB%BA%E5%8D%95%E4%BE%8B-bean/)