1. 程式人生 > >GetBean原始碼全面解讀

GetBean原始碼全面解讀

前言

在上篇文章刨坑的過程中,順便研究了一波spring原始碼,初始看的也是頭暈,後面逐漸捋好了思路。個人感覺spring還是個大工程的,這篇文章解讀的肯定也有自己理解不到位的部分,希望各位看官能多討論討論。最後會附上一副getBean方法的流程圖,希望能開啟大家看這部分原始碼的思路。(本文基於spring 5.1.2版本)


GetBean原始碼部分

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //會包括解析別名等操作
        final String beanName = transformedBeanName(name);
        Object bean;

        // 先檢查單例列表中是否已經註冊了這個bean
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            // 檢查bean是否併發被建立
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // 檢查是否在父類工廠中,邏輯和這個差不多,這裡省略....

           //標記bean正在被建立
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }
            try {
                //合併父類中的方法及屬性,下面會細講                      
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                //檢查這個bean是否為抽象類
                checkMergedBeanDefinition(mbd, beanName, args);

                // 這裡是為了保證獲取的bean的依賴都需要先生成
                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);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex){
                            throw ex;
                        }
                    }
                }

                // 建立單例的bean,看下方的createBean方法
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

                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);
                }

                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, () -> {
                            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;
            }
        }

        // 檢查需要的型別和實際傳參型別是否一致. 這裡省略....
        return (T) bean;
    }

整個操作大概是以下幾步:

  1. 獲取實際的beanName,其中會處理帶&號字首的beanName,並解析別名。
  2. 檢查單例列表中是否存在該beanName的bean,若存在則無需走下面的建立bean的流程。
  3. 若單例列表中並不存在此bean,則檢查是否有併發建立。這裡的判斷只針對scope為prototype型別的bean。
  4. 檢查bean是否存在於父類工廠中,若存在,則走父類工廠的getBean流程。向上委託,保證容器中只會存在一個同名的bean。
  5. 標記bean正在被建立。
  6. 如果有父類,這裡會遞迴合併父類的方法以及屬性。並會用自己重寫的方法覆蓋其父類的方法。合併完成並檢查這個bean的是否是抽象類。
  7. 如果該bean上有註解@DependsOn,或者配置檔案
  8. 分單例和原型以及其他scope型別來建立bean。
  9. 檢查需要的型別和生成的bean型別是否一致。
  10. 返回建立好的bean。

getSingleton原始碼部分(beanName,allowEarlyReference)

  1. 這裡的singletonObjects是一個快取了beanName和bean的Map,若存在,直接返回。
  2. 不存在,則檢查是否這個bean是否正在建立的過程中,先檢查earlySingletonObjects這個容器,這個容器裡面放著的是已經構造完成但是沒有注入屬性的物件,若存在,也會直接返回。
  3. 嘗試著從singletonFactories中獲取,然後呼叫getObject方法去獲取物件。並將獲取到的物件放到earlySingletonObjects容器中,然後從singletonFactories容器中移除。

這裡這麼設計是為了解決迴圈依賴的問題。若A依賴B,B依賴C,C又依賴A,這樣三個bean就形成了一個環(這裡只是針對set方法注入的bean,構造器注入還是會有迴圈依賴的問題而丟擲異常的),spring會將建立的bean例項提前暴露在快取中,一旦下一個bean建立的時候需要依賴上個bean,則直接使用ObjectFactory來獲取bean。

這裡舉個生活中的例子闡述下:就拿建一個小區房來說,建房子是一個很複雜的工序,但是咱們只要把架子搭好,告訴大家這塊地是用來建這個房子的就行。至於其他裝修,傢俬等等東西都可以後面再進行補充。咱們不能搭架子的時候去放傢俱吧,這樣整個都會亂套,也不符合常理。(這裡房子的框架是咱們程式中的一個物件A,傢俱是另一個物件B,A依賴B,B依賴A)

迴圈依賴

相關的邏輯有用到以下程式碼段:

每次singleton bean創造之前都會呼叫的方法,在singletonsCurrentlyInCreation容器中加入這個bean的beanName,標記這個bean正在建立中,供後期生成ObjectFactory。這裡有個inCreationCheckExclusions容器,在這裡我理解為屬於該容器的bean必須要初始化完成才允許被獲取。也就是說,新增進該容器後bean便不會允許早期的迴圈依賴了。

上面的程式碼片段的呼叫在doCreateBean原始碼中(排在bean物件建立之後和屬性注入之前),可以觀察到要執行addSingletonFactory方法需要滿足三個條件:

  • 這個bean是單例的,
  • 允許迴圈依賴,
  • 這個bean正在被建立的過程中。

在滿足這三個條件的情況下,會在singletonFactories容器中快取一個生成該bean的工廠,將其提前暴露出去。這裡關注下getEarlyBeanReference(beanName, mbd, bean)這個方法,實際上ObjectFactory中getObject方法呼叫的也是這個方法。


getMergedBeanDefinition原始碼部分

看這部分之前,首先得明白BeanDefinition是用來幹什麼的,這個類會在整個原始碼解析過程中出現無數次。Spring把BeanDefinition定義成IOC容器的內部資料結構,實際上它也就是POJO物件在IOC容器中的抽象,通過這個物件,IOC容器能很方便的對Bean進行管理,包括利用它進行屬性的注入等等...

protected RootBeanDefinition getMergedBeanDefinition(
            String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
            throws BeanDefinitionStoreException {

        synchronized (this.mergedBeanDefinitions) {
            RootBeanDefinition mbd = null;

            // 重新去獲取一次,有可能該BeanDefinition已經生成
            if (containingBd == null) {
                mbd = this.mergedBeanDefinitions.get(beanName);
            }

            if (mbd == null) {
                if (bd.getParentName() == null) {
                    // 沒有父類則深拷貝一個RootBeanDefinition
                    if (bd instanceof RootBeanDefinition) {
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                    }
                    else {
                        mbd = new RootBeanDefinition(bd);
                    }
                }
                else {
                    // 有父類則需要先獲取父類的BeanDefinition,流程和獲取子類的BeanDefinition一致
                    BeanDefinition pbd;
                    try {
                        String parentBeanName = transformedBeanName(bd.getParentName());
                        if (!beanName.equals(parentBeanName)) {
                            pbd = getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            BeanFactory parent = getParentBeanFactory();
                            if (parent instanceof ConfigurableBeanFactory) {
                                pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                            }
                            else {
                                throw new NoSuchBeanDefinitionException(parentBeanName,
                                        "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
                                        "': cannot be resolved without an AbstractBeanFactory parent");
                            }
                        }
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
                                "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
                    }
                    //這裡進行深拷貝,並將子類重寫的方法和屬性進行覆蓋
                    mbd = new RootBeanDefinition(pbd);
                    mbd.overrideFrom(bd);
                }

                // 若前面沒配置scope型別,這裡設定為單例範圍
                if (!StringUtils.hasLength(mbd.getScope())) {
                    mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
                }

                // 這裡對內部類做了一些處理,若包含它的bean不是單例的,則該bean也將不會是單例的
                if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                    mbd.setScope(containingBd.getScope());
                }

                // 將生產的BeanDefinition 快取起來
                if (containingBd == null && isCacheBeanMetadata()) {
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }

            return mbd;
        }
    }
  1. 在mergedBeanDefinitions同步的情況下再次讀取快取,防止該BeanDefinition已經被合併過了。
  2. 檢查是否有父類,若有父類,則必須遞迴去合併BeanDefinition。
  3. 將子類重寫後的方法覆蓋到定義的BeanDefinition中。
  4. 設定scope型別。
  5. 將生成的BeanDefinition快取起來。

registerDependentBean原始碼部分

這一部分應該還是很容易理解的,這裡面出現了兩個Map,一個是dependentBeanMap,它主要用來裝載鍵為beanName值為dependentBeanName的容器,另一個dependenciesForBeanMap是用來裝載鍵為dependentBeanName值為beanName的容器,這樣可以方便我們觀察一個類需要組裝哪些依賴,然後這個類同時是哪些類的依賴。


getSingleton原始碼部分(beanName,singletonFactory)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized (this.singletonObjects) {
//先去singletonObjects容器中去獲取,能獲取到就直接返回了
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
//呼叫destroySingletons方法singletonsCurrentlyInDestruction屬性才會變成true
                if (this.singletonsCurrentlyInDestruction) {
                    throw new Exception("xx"));
                }
//這裡會將beanName快取到singletonsCurrentlyInCreation集合中
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<>();
                }
                try {
        //這裡會觸發下面的createBean方法
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // 如果是與此同時被建立了,則直接獲取,如果能獲取到值不為null,則正常返回。
                    //(注意這裡捕獲異常正常返回的話就不會走下面的addSingleton方法了。)
                    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) {
//新增到singletonObjects和registeredSingletons快取中,並從singletonFactories和earlySingletonObjects中移除
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }
  1. 直接去singletonObjects中獲取,獲取到了便直接返回。
  2. 獲取不到,先將beanName快取到singletonsCurrentlyInCreation集合中,作為標記表示該bean正在被建立的過程中。
  3. 觸發createBean方法去建立bean,這裡可以去看一下ObjectFactory這個介面工廠,這裡是對getObject方法的一個回撥(AbstractAutowireCapableBeanFactory中的createBean方法)。
  4. 建立bean的過程中在不出異常的情況下便會進行下圖的操作後並返回,也就操作了幾個容器的快取而已。

createBean原始碼部分

這一塊不是很複雜,複雜的地方在doCreateBean這個方法中。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        RootBeanDefinition mbdToUse = mbd;

        // 要保證RootBeanDefinition的beanClass是存在的
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 這一塊沒什麼研究,註解意思是(檢查所有帶有override的方法是否都是存在的)
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
        }

        try {
            //這一塊我猜測大概是看咱們自己有提供例項化的方法不,若有,則不會走下面的doCreateBean方法。
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
        }

        try {
            //建立bean的真正方法
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            }
            return beanInstance;
        }
        catch (Exception e){
           throw e;
        }
    }

doCreateBean原始碼部分

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,真正構建時有分兩種情況,jdk反射和cglib動態代理
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            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.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
//進行屬性的注入,呼叫bean的set方法進行欄位的初始化
            populateBean(beanName, mbd, instanceWrapper);
//進行一些初始化方法的呼叫,比如afterPropertiesSet等等。
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
//在出現迴圈依賴後,從earlySingletonObjects中獲取的bean物件和initializeBean後
//的不一致,證明被後置處理器處理過了,前後bean不一致,需要丟擲異常
                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 " +
                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // 註冊bean的銷燬方法
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }

doCreateBean大概有以下步驟:

  1. 呼叫createBeanInstance方法初始化bean例項,這裡不包括屬性的注入。
  2. 呼叫合併bean的後置處理器修改這個bean的BeanDefinition的一些定義。即呼叫MergedBeanDefinitionPostProcessor的實現類的postProcessMergedBeanDefinition方法對BeanDefinition進行一些額外的處理。
  3. 為早期的迴圈依賴做準備,將包裝了bean的工廠方法塞到singletonFactories中。
  4. 呼叫populateBean方法進行一些屬性的注入。
  5. 執行initializeBean方法進行一些初始化方法的呼叫,例如:afterPropertiesSet方法的呼叫。與此同時,其後置處理器有可能對指定的bean進行增強。
  6. 如果出現了bean的增強,然後又有依賴它的類先生成,則需丟擲異常。例如:物件A被增強了,得到A+物件,而此時物件B有依賴物件A,迴圈依賴時通過singletonFactories獲取到的物件卻是增強前的A物件,這時就會出現問題。如果不丟擲異常,spring容器快取的是A+物件,但是B引用的卻是A,這樣就會出現不可預測的問題。

instantiateBean原始碼

這裡是createBeanInstance方法中最終呼叫的方法,這裡有三個流程:

  1. 進行物件的構造,這裡關注下CglibSubclassingInstantiationStrategy這個策略類,有繼承SimpleInstantiationStrategy類,呼叫其instantiate可以呼叫物件的構造器進行物件的初始化,在BeanDefinition屬性MethodOverrides不存在時,可以用jdk的反射進行獲取物件,否則則必須使用cglib動態代理。(這裡的MethodOverrides的存在需要物件中某個方法用@Lookup註解修飾,或者XML定義中有 lookup-method屬性,這一塊的詳情可以參考詳情;)
  2. 用BeanWrapperImpl對生成的物件進行包裝,並激活註冊預設編輯器的屬性。
  3. 註冊預設的編輯器,然後將ConversionService這個類的引用設定到BeanWrapper物件上。ConversionService是用來進行型別轉換的,裡面的屬性converters用一個map維護著各種型別的轉換器。

populateBean原始碼部分

下面關注幾個重點程式碼,省略了一些程式碼,可以自己去翻閱下:

    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        ......
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // 這裡是根據bean名稱進行依賴注入的
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // 這裡是根據bean的型別進行依賴注入的
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        ......
        if (pvs != null) {
//實際上注入屬性值的方法,這裡是populateBean方法的重點
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

這裡註釋下applyPropertyValues的部分原始碼:

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        MutablePropertyValues mpvs = null;
        List<PropertyValue> original;

        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                // 這裡可以迅速返回。當這個PropertyValues物件中的值都是處理過後便可以觸發。狀態值會在下面幾行程式碼設定。
                try {
                    bw.setPropertyValues(mpvs);
                    return;
                }
                catch (BeansException ex) {
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
                }
            }
            original = mpvs.getPropertyValueList();
        }
        else {
            original = Arrays.asList(pvs.getPropertyValues());
        }

        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

        // 這裡是個深拷貝,解析所有引用的值。
        List<PropertyValue> deepCopy = new ArrayList<>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            if (pv.isConverted()) {
                deepCopy.add(pv);
            }
            else {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
//這裡的resolveValueIfNecessary是一個需要關注的方法,有興趣的小夥伴可以點進去看看,
//裡面封裝了針對各種型別的屬性的解析,例如List,Map,Set等等型別。
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                //為了避免每次建立都去轉換屬性
                if (resolvedValue == originalValue) {
//這裡的觸發條件必須為該屬性得是有寫許可權的,並且裡面不能帶有“.”和“[”這個符號,這裡我的理解是
//teacher.name以及student[1].name這樣的propertyName便不能觸發這個條件
                    if (convertible) {
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
//這一塊的條件比上一個多了幾個,源值必須是string型別,且不能是動態的,並且不能是集合和陣列中的任意一個。
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
//條件在這裡觸發後就不會開啟快捷返回的開關了
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
//設定converted狀態值,供其組裝屬性時快捷返回。
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }

        // 將我們深拷貝出來的值設定到包裝類BeanWrapperImpl包裝的物件上
        try {
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }

setPropertyValues方法的原始碼最終呼叫的是AbstractNestablePropertyAccessor類的setPropertyValue方法,在這裡BeanWrapperImpl是它的實現類,從名字上看也能猜出來這個類是個處理巢狀屬性的訪問器。

    public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
        AbstractNestablePropertyAccessor nestedPa;
        try {
                  //這裡可以解析巢狀的屬性
            nestedPa = getPropertyAccessorForPropertyPath(propertyName);
        }
        catch (NotReadablePropertyException ex) {
            throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
                    "Nested property in path '" + propertyName + "' does not exist", ex);
        }
        //這裡獲取到了最終解析到的屬性名
        PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
       //給最終解析到的屬性名賦值操作
        nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
    }

上面有個getPropertyAccessorForPropertyPath方法,點進去會發現他會有個解析“.”和“[]”的方法getNestedPropertySeparatorIndex,它的作用我舉個例子來說明一下:一個班級有多個學生,我想設定某個學生的名字,班級是個Class物件,裡面有屬性:private Student[] students這裡我想修改下student[2]的name屬性,我就必須先用getStudent方法取出 Student[] 陣列,然後再在 Student[] 陣列中找到索引為2的Student,最後修改Student身上的name屬性。(這一塊不是很理解的可以參考下BeanWrapper 原始碼分析


GetBean流程圖


End