繼續(xù)搞棺榔，兄弟瓶堕，先別走~~

上一節(jié)講到 doCreateBean()方法，上碼：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        // 先從緩存取
        if (mbd.isSingleton()) {        
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        // 緩存取不到症歇，創(chuàng)建
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    // 將 @Autowired等標記的屬性解析出來捞烟，后續(xù)用
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException("……");
                }
                mbd.postProcessed = true;
            }
        }

        // 是否可以提前暴露使用
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("……");
            }
            // 將bean放入緩存中
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        Object exposedObject = bean;
        try {
            // 注入屬性
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化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();
            }
        }

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

        // 銷毀bean一些東西
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException();
        }
        return exposedObject;
    }

點開

Object earlySingletonReference = getSingleton(beanName, false);

可以看到

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 一級緩存，存的是完成初始化好的bean
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    // 二級緩存当船，存的是尚未填充屬性的bean對象
    singletonObject = this.earlySingletonObjects.get(beanName);
    if (singletonObject == null && allowEarlyReference) {
        synchronized (this.singletonObjects) {
          singletonObject = this.singletonObjects.get(beanName);
          if (singletonObject == null) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null) {
               // 三級緩存
               ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
               if (singletonFactory != null) {
                   singletonObject = singletonFactory.getObject();
                   this.earlySingletonObjects.put(beanName, singletonObject);
                   this.singletonFactories.remove(beanName);
                }
             }
          }
    }
}
}
   return singletonObject;
}

這個就是spring的三級緩存取bean了。

講了半天默辨，好像還是沒觸及bean的實例化德频，別哭缩幸，站起來繼續(xù)搞钞护！回到doCreateBean() 方法课梳，看createBeanInstance()的實現細節(jié)，關鍵代碼：

// 獲取bean的class
Class<?> beanClass = resolveBeanClass(mbd, beanName);

return instantiateBean(beanName, mbd);

進入 instantiateBean(beanName, mbd)，看到關鍵代碼：

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);

進入 這個instantiate(mbd, beanName, this)氧猬，看到以下兩行代碼：

return BeanUtils.instantiateClass(constructorToUse);

return instantiateWithMethodInjection(bd, beanName, owner);

先看前者，點擊進去：

try {
    ReflectionUtils.makeAccessible(ctor);
    if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
    return KotlinDelegate.instantiateClass(ctor, args);
    }
    else {
        Class<?>[] parameterTypes = ctor.getParameterTypes();
        Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
        Object[] argsWithDefaultValues = new Object[args.length];
        for (int i = 0 ; i < args.length; i++) {
        if (args[i] == null) {
            Class<?> parameterType = parameterTypes[i];
            argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
        }
        else {
            argsWithDefaultValues[i] = args[i];
        }
    }
    return ctor.newInstance(argsWithDefaultValues);
    }
}

就是根據構造函數以及參數new一個對象丛晦。

再來看后者 instantiateWithMethodInjection，核心代碼

Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
if (ctor == null) {
    instance = BeanUtils.instantiateClass(subclass);
}
else {
    try {
        Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
        instance = enhancedSubclassConstructor.newInstance(args);
}

這就是實例化的地方，聽說使用cglib瘸爽，可以查查它的資料

以上是new出一個bean的實例，bean的加載還未完成享言，因為還有一些屬性需要注入譬胎《嗫罚回到doCreateBean()方法，填充屬性語句：

populateBean(beanName, mbd, instanceWrapper);

點進去，關鍵代碼：

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
        autowireByName(beanName, mbd, bw, newPvs);
    }
    if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }
            pvs = newPvs;
}

// 將依賴實際注入
applyPropertyValues(beanName, mbd, bw, pvs);

一者是根據名稱注入，一者是根據類型注入拍鲤，注入后，pvs持有這些注入的屬性信息景鼠，然后applyPropertyValues 注入屬性鲫构，點擊該方法昂秃，進去，核心代碼：

bw.setPropertyValues(new MutablePropertyValues(deepCopy));

點進去，一路追蹤到：

for (PropertyValue pv : propertyValues) {
    try {
        setPropertyValue(pv);
    }
}

這就是屬性注入了，屬性注入后，bean就可以使用了驾讲，后面還有一些個性化設置颅停，這里不涉足了纸肉。

收工~~