上午去繳了上次沒帶駕駛證的扣分罰款，最近在圖書館沒事就看曾國藩家書，曾國藩說人要明強(qiáng)。光強(qiáng)沒有用，你要明強(qiáng)。也就是說要強(qiáng)的有道理。曾國藩又說，做學(xué)問不能做死學(xué)問，做學(xué)問其實(shí)很重要的事就是能懂得孝悌，把家持好，能做事。能做事很重要，學(xué)問再高，不能做事，也是無用。相反即使沒什么學(xué)問，寫不出來，但是能做事，事事做的條理，家庭安排的和睦，家族事宜能夠有積極的貢獻(xiàn)，再到更大的方面，都能做好，這才是學(xué)問的意義。看了一下，上一篇文章已經(jīng)是2號(hào)的了，這個(gè)月已經(jīng)9號(hào)了，1/3了，可是這重頭的Bean加載還沒有什么大的進(jìn)展，這樣怎么能行，家里的事情還要辦，很多事情還沒弄好，這可不行呀。

想要人生有所突破，下一番苦工是不可能省略的。一半努力一半隨心所欲，是不可能成就的。

“須是策勵(lì)此心，勇猛奮發(fā)，撥出心肝與他去做！如兩邊擂起戰(zhàn)鼓，莫問前頭如何，只認(rèn)卷將去！如此，方做得工夫。若半上落下，半沉半浮，濟(jì)得甚事！” 朱熹 .《朱子語錄》

我們繼續(xù)上節(jié)的內(nèi)容，這節(jié)主要是bean的加載。

我們從ServerMain的方法中的getBean("")作為入口來看：

public Object getBean(String name) throws BeansException {return this.doGetBean(name, (Class)null, (Object[])null, false);}

繼續(xù)調(diào)用，都在AbstractBeanFactory中進(jìn)行，下邊這段就是恐怖的bean加載了。我們可以翻到最后看下返回了Bean，當(dāng)然bean是范性的，先拋開中間的過程不說，這里返回的就是實(shí)實(shí)在在的我們需要的Bean了，似乎一切都在這個(gè)方法里，沒錯(cuò)所有的“恩怨”都在這里。

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {final String beanName = this.transformedBeanName(name);Object sharedInstance = this.getSingleton(beanName);Object bean;if (sharedInstance != null && args == null) {if (this.logger.isDebugEnabled()) {if (this.isSingletonCurrentlyInCreation(beanName)) {this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");} else {this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");}}bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);} else {if (this.isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}BeanFactory parentBeanFactory = this.getParentBeanFactory();if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {String nameToLookup = this.originalBeanName(name);if (args != null) {return parentBeanFactory.getBean(nameToLookup, args);}return parentBeanFactory.getBean(nameToLookup, requiredType);}if (!typeCheckOnly) {this.markBeanAsCreated(beanName);}try {final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);this.checkMergedBeanDefinition(mbd, beanName, args);String[] dependsOn = mbd.getDependsOn();String[] var11;if (dependsOn != null) {var11 = dependsOn;int var12 = dependsOn.length;for(int var13 = 0; var13 < var12; ++var13) {String dependsOnBean = var11[var13];if (this.isDependent(beanName, dependsOnBean)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");}this.registerDependentBean(dependsOnBean, beanName);this.getBean(dependsOnBean);}}if (mbd.isSingleton()) {sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {public Object getObject() throws BeansException {try {return AbstractBeanFactory.this.createBean(beanName, mbd, args);} catch (BeansException var2) {AbstractBeanFactory.this.destroySingleton(beanName);throw var2;}}});bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);} else if (mbd.isPrototype()) {var11 = null;Object prototypeInstance;try {this.beforePrototypeCreation(beanName);prototypeInstance = this.createBean(beanName, mbd, args);} finally {this.afterPrototypeCreation(beanName);}bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);} else {String scopeName = mbd.getScope();Scope scope = (Scope)this.scopes.get(scopeName);if (scope == null) {throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");}try {Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {public Object getObject() throws BeansException {AbstractBeanFactory.this.beforePrototypeCreation(beanName);Object var1;try {var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);} finally {AbstractBeanFactory.this.afterPrototypeCreation(beanName);}return var1;}});bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);} catch (IllegalStateException var21) {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", var21);}}} catch (BeansException var23) {this.cleanupAfterBeanCreationFailure(beanName);throw var23;}}if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {try {return this.getTypeConverter().convertIfNecessary(bean, requiredType);} catch (TypeMismatchException var22) {if (this.logger.isDebugEnabled()) {this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);}throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}} else {return bean;}}

好，下邊我們就開始這場江湖的血雨腥風(fēng)。

首先第一句就是：

final String beanName = this.transformedBeanName(name);

這句做的事情，好像不知道所云，因?yàn)閎eanName不是作為參數(shù)傳進(jìn)來了嗎，還要再轉(zhuǎn)換是什么意思，稍微想一下就知道了，我們獲取bean的時(shí)候傳過來的name參數(shù)，有可能是別名。

如果是別名這里就需要轉(zhuǎn)換一下了，因?yàn)槲覀冃枰嬲拿Q。

翻看下代碼：

protected String transformedBeanName(String name) {return this.canonicalName(BeanFactoryUtils.transformedBeanName(name));}

括號(hào)里邊的部分的代碼如下：

public static String transformedBeanName(String name) {Assert.notNull(name, "'name' must not be null");String beanName;for(beanName = name; beanName.startsWith("&"); beanName = beanName.substring("&".length())) {}return beanName;}

如果name是以&開頭的，那么去除開頭的&符號(hào)。繼續(xù)：

public String canonicalName(String name) {String canonicalName = name;String resolvedName;do {resolvedName = (String)this.aliasMap.get(canonicalName);if (resolvedName != null) {canonicalName = resolvedName;}} while(resolvedName != null);return canonicalName;}

這里很容易看出來，就是根據(jù)名稱去別名map中獲取有沒有對(duì)應(yīng)的名稱。目的就是獲取別名對(duì)應(yīng)的真實(shí)Bean名稱。

接下來這句getSingleton就涉及到偉大的又扯淡的各種面試都會(huì)問到的循環(huán)依賴問題了，其實(shí)不復(fù)雜，但是沒認(rèn)真研究過代碼。關(guān)于循環(huán)依賴的問題，可以看下個(gè)章節(jié)。這里重點(diǎn)還是創(chuàng)建Bean這個(gè)主題。

我們繼續(xù)上邊的doCreateBean(name, requiredType, args[], typeCheckOnly)的代碼。轉(zhuǎn)換完名字之后，緊接的一句是getSingleton(beanName).

@Override@Nullablepublic Object getSingleton(String beanName) {return getSingleton(beanName, true);}/*** Return the (raw) singleton object registered under the given name.* <p>Checks already instantiated singletons and also allows for an early* reference to a currently created singleton (resolving a circular reference).* @param beanName the name of the bean to look for* @param allowEarlyReference whether early references should be created or not* @return the registered singleton object, or {@code null} if none found*/@Nullableprotected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {singletonObject = singletonFactory.getObject();this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject;}

這里我們觀察注釋，能夠了解一部分：返回已這個(gè)beanName注冊(cè)的實(shí)例。并且檢查已經(jīng)初始化的實(shí)例，允許當(dāng)前創(chuàng)建的實(shí)例有一個(gè)早期的引用（用來解決循環(huán)依賴問題）。

我們深入代碼來看一下：

首先從singletonObjects.get(beanName)從緩存里獲取一下，看有沒有，如果有直接返回。如果沒有，并且當(dāng)前beanName正在創(chuàng)建，那么加鎖后邊的這部分代碼：

判斷beanName是否在earlySingletonObjects列表中，如果不在并且允許早期引用，那么就獲取beanName對(duì)應(yīng)的ObjectFactory。然后調(diào)用ObjectFactory.getObject()返回實(shí)例。并將該實(shí)例添加到earlySingletonObjects中。這里確實(shí)就是解決循環(huán)引用的核心了，解決循環(huán)依賴的核心就是這里的這個(gè)singletonFactories.get(beanName)獲取singletonFactory，然后調(diào)用getOjbect返回實(shí)例。說的通俗一點(diǎn)兒就是可能對(duì)象還沒有創(chuàng)建，但是能夠創(chuàng)建這個(gè)對(duì)象的ObjectFactroy會(huì)提前放入緩存中，這樣，當(dāng)后續(xù)創(chuàng)建過程中，需要引用一個(gè)之前還沒有創(chuàng)建完的bean時(shí)，就會(huì)調(diào)用這里的ObjectFactory.getObject()返回一個(gè)實(shí)例對(duì)象。

這個(gè)部分我們?cè)谙乱黄獙ｉT將循環(huán)依賴的文章里詳細(xì)闡述。在這里，這個(gè)getSingleton在整體流程上，最核心的是從緩存中嘗試獲取bean。

我們繼續(xù)看下代碼，我們用粗體標(biāo)示了一個(gè)方法：getObjectForBeanInstance(scopedInstance, name, beanName, mdb)。我們看到，后續(xù)的幾種情況里，無論是singleton/prototype/還是其他實(shí)例模式，得到bean之后，做的事情都是這個(gè)getObjectForBeanInstance方法，我們來跟進(jìn)看下：

/** 獲取給定bean實(shí)例的對(duì)象，要么bean實(shí)例本身，要么當(dāng)它是一個(gè)FactroyBean時(shí)，它創(chuàng)建出來的對(duì)象**/protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {// 如果指定的name是&開頭即工廠相關(guān)的，但又不是FactoryBean類型，則拋出異常，類型驗(yàn)證不通過if (BeanFactoryUtils.isFactoryDereference(name)) {if (beanInstance instanceof NullBean) {return beanInstance;}if (!(beanInstance instanceof FactoryBean)) {throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());}} // 現(xiàn)在我們有個(gè)這個(gè)bean實(shí)例，但是這個(gè)bean實(shí)例可能是普通bean也可能是FactoryBean，如果是FactoryBean，那么我們使用它來獲取工廠實(shí)例，如果調(diào)用者需要的是
FactoryBean本身，那么beanName參數(shù)需要帶"&"if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}// 到這里就明確是一個(gè)FactoryBean，因?yàn)槿绻皇巧线呉呀?jīng)返回了Object object = null;if (mbd == null) {object = getCachedObjectForFactoryBean(beanName);}if (object == null) {// Return bean instance from factory.FactoryBean<?> factory = (FactoryBean<?>) beanInstance;// Caches object obtained from FactoryBean if it is a singleton.if (mbd == null && containsBeanDefinition(beanName)) {mbd = getMergedLocalBeanDefinition(beanName);}boolean synthetic = (mbd != null && mbd.isSynthetic());object = getObjectFromFactoryBean(factory, beanName, !synthetic);}return object;}

1:判斷是否是FactoryBean，判斷依據(jù)是 beanName是否是"&"開頭的。如果是&開頭，則表示是獲取FactoryBean本身，如果不是&開頭，則是獲取FactroyBean的方法返回的Bean。如果是&開頭，但是本身并不是FactoryBean類型，則拋出異常。

2:如果本身不是FactoryBean類型或者beanName不是以“&”開頭的，那么直接返回Bean本身。

3:判斷BeanDefinitions中是否存在該beanName。這里做的事情其實(shí)是將我們解析時(shí)候生成的GenericBeanDefinition轉(zhuǎn)換成RootBeanDefinition.細(xì)節(jié)這里就不說了。

4:最后委托給getObjectFromFactoryBean(factory, beanName, !synthetic)方法類獲取真正的實(shí)例。

我們繼續(xù)往下看：

/** 獲得從給定的FactoryBean獲取出來的對(duì)象*/protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {if (factory.isSingleton() && containsSingleton(beanName)) {synchronized (getSingletonMutex()) {Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {object = doGetObjectFromFactoryBean(factory, beanName);// Only post-process and store if not put there already during getObject() call above// (e.g. because of circular reference processing triggered by custom getBean calls)Object alreadyThere = this.factoryBeanObjectCache.get(beanName);if (alreadyThere != null) {object = alreadyThere;}else {if (shouldPostProcess) {if (isSingletonCurrentlyInCreation(beanName)) {// Temporarily return non-post-processed object, not storing it yet..return object;}beforeSingletonCreation(beanName);try {object = postProcessObjectFromFactoryBean(object, beanName);}catch (Throwable ex) {throw new BeanCreationException(beanName,"Post-processing of FactoryBean's singleton object failed", ex);}finally {afterSingletonCreation(beanName);}}if (containsSingleton(beanName)) {this.factoryBeanObjectCache.put(beanName, object);}}}return object;}}else {Object object = doGetObjectFromFactoryBean(factory, beanName);if (shouldPostProcess) {try {object = postProcessObjectFromFactoryBean(object, beanName);}catch (Throwable ex) {throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);}}return object;}}

核心其實(shí)就是這句doGetObjectFromFactoryBean(factory, beanName)。里邊的if里是判斷是否是單例，而里邊的內(nèi)容跟else的區(qū)別就是如果是單例，那么就嘗試從緩存中獲取，如果緩存中沒有才調(diào)用到doGetObjectFactoryBean(factory, beanName)。還有里邊的beforeSingletonCreation和afterSingletonCreation則都是保證創(chuàng)建過程中，不會(huì)重復(fù)創(chuàng)建實(shí)例，是為了保證單例性。

好了，我們還是繼續(xù)一層一層的往下看吧。

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)throws BeanCreationException {Object object;try {if (System.getSecurityManager() != null) {AccessControlContext acc = getAccessControlContext();try {object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);}catch (PrivilegedActionException pae) {throw pae.getException();}}else {object = factory.getObject();}}catch (FactoryBeanNotInitializedException ex) {throw new BeanCurrentlyInCreationException(beanName, ex.toString());}catch (Throwable ex) {throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);}// Do not accept a null value for a FactoryBean that's not fully// initialized yet: Many FactoryBeans just return null then.if (object == null) {if (isSingletonCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");}object = new NullBean();}return object;}

終于到了最后獲取對(duì)象的地方了，這里getObject()的調(diào)用為整個(gè)通過FactoryBean獲取實(shí)例的解析過程畫上美麗的句號(hào)。

承接上文，我們對(duì)緩存中獲取bean和FactoryBean方式獲取Bean進(jìn)行了闡述。對(duì)getBean("")方法進(jìn)行了闡述。這一篇我們先深入單例的創(chuàng)建來詳細(xì)說一下spring循環(huán)依賴問題的解決。

我們從doGetBean方法繼續(xù)，我們主要看下singleton這一部分：

// Create bean instance.if (mbd.isSingleton()) {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;}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}

我們繼續(xù)getSingleton(beanName, singletonFactory)。

/*** 返回beanName注冊(cè)過的單例對(duì)象，如果沒有，那么創(chuàng)建并注冊(cè)該beanName的實(shí)例*/public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(beanName, "Bean name must not be null");synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName); // 1if (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); // 2boolean newSingleton = false;boolean recordSuppressedExceptions = (this.suppressedExceptions == null);if (recordSuppressedExceptions) {this.suppressedExceptions = new LinkedHashSet<>();}try {singletonObject = singletonFactory.getObject(); // 3newSingleton = 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); // 4}if (newSingleton) {addSingleton(beanName, singletonObject);}}return singletonObject;}}

這里其實(shí)最核心的就是singletonFactory.getObject()。我們梳理下步驟：

1:嘗試從緩存獲取beanName對(duì)應(yīng)的bean

2:如果沒有，調(diào)用beforeSingletonCreation(beanName)，將beanName放入singletonCurrentlyInCreation列表。

3:通過調(diào)用參數(shù)傳入的FactoryBean的getObject方法，獲取實(shí)例化bean

4:加載完成后，處理之后的方法調(diào)用。這里做的事情跟beforeSingletonCreation正好相反，把beanName從singletonCurrentlyInCreation中刪除

5:緩存生成的object。并刪除生成過程中的相關(guān)狀態(tài)。

/*** Add the given singleton object to the singleton cache of this factory.* <p>To be called for eager registration of singletons.* @param beanName the name of the bean* @param singletonObject the singleton object*/protected void addSingleton(String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put(beanName, singletonObject); // 放入緩存this.singletonFactories.remove(beanName);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}

6:返回bean，這個(gè)bean就是上邊getSingleton(beanName, singletonFactory)的這個(gè)參數(shù)，在doGetBean中定義的方法。

sharedInstance = getSingleton(beanName, () -> { // 這里是jdk8引入的函數(shù)是寫法，這里其實(shí)就是ObjectFactroy的一個(gè)匿名類實(shí)現(xiàn)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;}});

接下來就是創(chuàng)建bean的代碼了。

我們來詳細(xì)看下這個(gè)createBean(beanName, mdb, args)

/*** Central method of this class: creates a bean instance,* populates the bean instance, applies post-processors, etc.* @see #doCreateBean*/@Overrideprotected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {if (logger.isTraceEnabled()) {logger.trace("Creating instance of bean '" + beanName + "'");}RootBeanDefinition mbdToUse = mbd;// Make sure bean class is actually resolv1ed 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.Class<?> resolvedClass = resolveBeanClass(mbd, beanName);if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {mbdToUse = new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.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.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);}try {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);}}

1:根據(jù)mdb獲取beanName對(duì)應(yīng)的class。

2:對(duì)override屬性進(jìn)行處理

3:應(yīng)用初始化前的處理器

4:創(chuàng)建bean

我們來詳細(xì)看下override 的處理

/*** Validate and prepare the method overrides defined for this bean.* Checks for existence of a method with the specified name.* @throws BeanDefinitionValidationException in case of validation failure*/public void prepareMethodOverrides() throws BeanDefinitionValidationException {// Check that lookup methods exists.if (hasMethodOverrides()) {Set<MethodOverride> overrides = getMethodOverrides().getOverrides();synchronized (overrides) {for (MethodOverride mo : overrides) {prepareMethodOverride(mo);}}}}/*** Validate and prepare the given method override.* Checks for existence of a method with the specified name,* marking it as not overloaded if none found.* @param mo the MethodOverride object to validate* @throws BeanDefinitionValidationException in case of validation failure*/protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());if (count == 0) {throw new BeanDefinitionValidationException("Invalid method override: no method with name '" + mo.getMethodName() +"' on class [" + getBeanClassName() + "]");}else if (count == 1) {// Mark override as not overloaded, to avoid the overhead of arg type checking.mo.setOverloaded(false);}}

這里我們要理解下lookup-method和override-method的問題。這兩個(gè)配置我們?cè)诮馕鰔ml的時(shí)候說過但沒有太詳細(xì)介紹，這兩個(gè)的作用lookup-method。（這里不太明白還，暫時(shí)放這里，后續(xù)bean生成的時(shí)候看下到底代碼如何實(shí)現(xiàn)的，再過來看）

轉(zhuǎn)載于:https://www.cnblogs.com/aquariusm/p/11156741.html

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)

總結(jié)

以上是生活随笔為你收集整理的spring源码阅读(1/4) - Bean生成的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。