Spring原始碼解析之bean的建立
閱讀須知
- Spring原始碼版本:4.3.8
- 文章中使用/* */註釋的方法會做深入分析
正文
之前我們都是在圍繞
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
這句程式碼來分析Spring在初始化過程中都做了哪些工作,其中bean建立的部分我們並沒有做深入分析,這篇文章我們就來分析一下Spring在建立bean的過程中都做了哪些工作,圍繞這句程式碼來分析:
A a = applicationContext .getBean(A.class);
getBean這個方法有多種過載的形式,但最終都會呼叫doGetBean方法來建立bean,我們就以這個方法作為入口來分析:
AbstractBeanFactory:
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
/* 嘗試從快取中獲取單例bean */
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference" );
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
/* 如果是工廠型別的bean,要呼叫相關工廠方法獲取bean */
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 原型模式的迴圈依賴無法解決,丟擲異常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = getParentBeanFactory();
// 檢查當前BeanFactory中是否包含當前待建立的bean的BeanDefinition,如果不存在,則遞迴嘗試從父級的BeanFactory載入
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
String nameToLookup = originalBeanName(name);
if (args != null) {
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
/* 如果建立bean不是為了型別檢查,則要標記當前bean已經被建立或者即將被建立以便於BeanFactory可以優化重複建立的bean的快取 */
markBeanAsCreated(beanName);
}
try {
/* 合併父BeanDefinition */
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn(); // 依賴的bean
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 + "'");
}
// 將依賴的關係放入快取,以便於當前bean銷燬時先銷燬依賴的bean
registerDependentBean(dep, beanName);
getBean(dep); // 建立依賴的bean
}
}
if (mbd.isSingleton()) {
/* 嘗試從快取中載入單例bean */
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
/* 建立bean */
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
/* 同樣的工廠型別的bean的處理 */
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
// 原型模式bean建立前置處理,預設情況下記錄當前bean正在建立
beforePrototypeCreation(beanName);
/* 建立bean */
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 原型模式bean建立後置處理,預設情況下移除當前bean正在建立的記錄,也就是當前bean已經建立完成
afterPrototypeCreation(beanName);
}
/* 同樣的工廠型別的bean的處理 */
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else { // 其他scope型別的處理
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, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName); // 前置處理
try {
return createBean(beanName, mbd, args); /* 建立bean */
}
finally {
afterPrototypeCreation(beanName); // 後置處理
}
}
});
/* 同樣的工廠型別的bean的處理 */
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;
}
}
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
// 如果需要,使用型別轉換器裝換型別
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
DefaultSingletonBeanRegistry:
public Object getSingleton(String beanName) {
/* 嘗試從快取中獲取,true為允許提前依賴 */
return getSingleton(beanName, true);
}
DefaultSingletonBeanRegistry:
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName); // 首先嚐試從快取中獲取單例bean
// 如果快取中為空並且bean正在建立中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
/* 從提前載入的bean的快取集合中獲取 */
singletonObject = this.earlySingletonObjects.get(beanName);
// 如果為空並且允許提前依賴
if (singletonObject == null && allowEarlyReference) {
// 從快取中獲取bean的工廠
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 如果工廠不為空則呼叫工廠方法載入bean
singletonObject = singletonFactory.getObject();
// 記錄到提前載入的bean的快取中
this.earlySingletonObjects.put(beanName, singletonObject);
// 已經呼叫工廠載入bean,將工廠從快取中移除,無需再次載入
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
AbstractBeanFactory:
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
// 如果beanName以&符開頭(代表要獲取FactoryBean本身)但型別不是FactoryBean丟擲異常
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 如果bean不是FactoryBean或者要獲取FactoryBean本身而不是要獲取工廠方法返回的例項則直接返回bean例項
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
// 過了上兩步的判斷到這裡可以確定當前bean一定是FactoryBean
Object object = null;
if (mbd == null) {
// 嘗試從快取中獲取FactoryBean
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
/* 合併父BeanDefinition */
mbd = getMergedLocalBeanDefinition(beanName);
}
// 是否是使用者自定義的而不是應用程式本身定義的
boolean synthetic = (mbd != null && mbd.isSynthetic());
/* 從FactoryBean中載入bean */
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
AbstractBeanFactory:
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// 如果已經合併過,直接返回
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
AbstractBeanFactory:
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
AbstractBeanFactory:
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
if (containingBd == null) {
// 鎖定全域性快取後雙重檢查是否已經合併過,避免重複合併
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null) {
if (bd.getParentName() == null) {
// 如果沒有父BeanDefinition,直接轉換成RootBeanDefinition返回
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
mbd = new RootBeanDefinition(bd);
}
}
else {
BeanDefinition pbd;
try {
// 轉換父beanName,主要處理FactoryBean的&符合alias別名
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
/* 遞迴合併父BeanDefinition */
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
// 如果當前bean和父bean的name相同,則嘗試用父BeanFactory遞迴合併
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); // 深複製父BeanDefinition,將屬性copy一遍
}
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON); // 設定預設scope
}
// 如果當前bean是內部bean並且scope為預設的單例,則要將scope設定為外部bean相同
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
if (containingBd == null && isCacheBeanMetadata()) {
// 放入快取代表已經合併過
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}
}
AbstractBeanFactory:
public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
String beanName = transformedBeanName(name); // 轉換beanName
// 如果當前BeanFactory中不包含當前BeanDefinition,則嘗試從父BeanFactory中遞迴合併
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
}
// 遞迴合併父BeanDefinition
return getMergedLocalBeanDefinition(beanName);
}
FactoryBeanRegistrySupport:
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) { // 單例
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName); // 嘗試從快取中獲取FactoryBean
if (object == null) {
/* 從FactoryBean中載入bean */
object = doGetObjectFromFactoryBean(factory, beanName);
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
// 這裡再次嘗試從快取中獲取是因為自定義的bean呼叫處理迴圈依賴時可能已經放入快取
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
/* BeanPostProcessor的呼叫 */
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT)); // 將FactoryBean放入快取
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else { // 非單例
/* 從FactoryBean中載入bean */
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
/* BeanPostProcessor的呼叫 */
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
FactoryBeanRegistrySupport:
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(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
// 呼叫getObject方法獲取bean
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject(); // 呼叫getObject方法獲取bean
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}
方法的內容很明確,就是呼叫getObject方法來獲取bean。下面就是BeanPostProcessor的呼叫,關於BeanPostProcessor,我們在之前的文章說描述過它的作用,筆者也會在後續的文章中介紹它的典型應用,AOP和事務等。
AbstractAutowireCapableBeanFactory:
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
/* 呼叫BeanPostProcessor */
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
AbstractAutowireCapableBeanFactory:
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
我們在之前的文章中講述過BeanPostProcessor的註冊,而這裡就會將這些註冊的BeanPostProcessor取出遍歷呼叫它們的postProcessAfterInitialization方法。現在我們回到載入bean的主流程中去:
AbstractBeanFactory:
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
if (!this.alreadyCreated.contains(beanName)) {
// 在建立bean期間有可能有一些元資料的變化,這裡清除合併快取讓BeanDefinition可以重新合併
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);
}
}
}
}
我們在標籤解析的文章中分析BeanDefinition的註冊時,曾經看到過Spring用hasBeanCreationStarted方法來判斷bean的建立是否已經開始,而判斷的依據alreadyCreated集合就是在這裡放置元素的。下面是單例bean的載入:
DefaultSingletonBeanRegistry:
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName); // 嘗試從快取中獲取
if (singletonObject == null) {
// 如果bean正在銷燬丟擲異常
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 + "'");
}
/* 單例bean建立前置處理 */
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
/* 呼叫getObject方法獲取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;
}
/* 單例bean建立後置處理 */
afterSingletonCreation(beanName);
}
if (newSingleton) {
/* 新增到快取中 */
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
DefaultSingletonBeanRegistry:
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
預設的前置處理就是將beanName放入了singletonsCurrentlyInCreation集合中,代表bean正在建立中,而這個集合就是Spring解決迴圈依賴的關鍵,後面我們會說到。預設的後置處理就是將beanName從這個集合中移除掉,代表bean已經建立完成:
DefaultSingletonBeanRegistry:
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
DefaultSingletonBeanRegistry:
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 寫入單例bean快取
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
this.singletonFactories.remove(beanName); // 工廠快取移除掉,bean建立完成工廠就沒用了
this.earlySingletonObjects.remove(beanName); // 提前建立的bean的標記移除掉
this.registeredSingletons.add(beanName); // 將beanName放入已經註冊的單例bean的快取
}
}
新增快取就是對各個相關的快取的處理。下面我們來分析getObject方法獲取bean的過程,這裡的ObjectFactory引數是在呼叫時new的一個匿名內部類,而它的getObject方法中呼叫了createBean方法,我們來分析這個方法:
AbstractAutowireCapableBeanFactory:
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 鎖定class,根據設定的class屬性或者className來解析class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd); // 克隆BeanDefinition
mbdToUse.setBeanClass(resolvedClass);
}
try {
/* 驗證以及準備覆蓋的方法 */
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
/* 給BeanPostProcessors一個機會返回一個代理來替代目標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);
}
/* 建立bean */
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
AbstractBeanDefinition:
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
MethodOverrides methodOverrides = getMethodOverrides();
if (!methodOverrides.isEmpty()) {
Set<MethodOverride> overrides = methodOverrides.getOverrides();
synchronized (overrides) {
for (MethodOverride mo : overrides) {
/* 準備方法覆蓋 */
prepareMethodOverride(mo);
}
}
}
}
AbstractBeanDefinition:
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) {
// 如果方法數量為1說明不存在過載方法,將方法過載設定false來避免型別檢查的開銷
mo.setOverloaded(false);
}
}
關於MethodOverride,我們在Spring標籤解析的文章中分析lookup-method和replace-method兩個配置的解析時,發現這兩個配置的載入其實就是將配置統一存放在BeanDefinition的methodOverrides屬性中,關於MethodOverride的應用我們後面會詳細介紹,這裡提前判斷的方法是否存在和方法的數量,確定是否有過載方法,如果沒有過載方法後面就不需要做引數的匹配了。
AbstractAutowireCapableBeanFactory:
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 解析class,包括從工廠中獲取目標bean的class的處理
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
/* bean例項化前BeanPostProcessor的呼叫,在這裡當前bean可能會被代理替代 */
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
/* 如果在上一步處理過後bean不為null,則在這裡應用BeanPostProcessor的後置處理 */
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
AbstractAutowireCapableBeanFactory:
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法的呼叫
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
BeanPostProcessor的後置處理我們在上文中分析FactoryBean的處理時已經提到過,這裡不再重複。
AbstractAutowireCapableBeanFactory:
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
/* 建立bean例項 */
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 允許MergedBeanDefinitionPostProcessor修改合併的BeanDefinition
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 解決迴圈依賴,是否提前曝光,單例並且允許迴圈依賴並且bean正在建立中
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");
}
/* 解決迴圈依賴,在bean初始化完成之前將建立bean的工廠加入到快取中 */
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
// 應用SmartInstantiationAwareBeanPostProcessor,獲取被提前訪問的bean的引用,通常用於處理迴圈依賴
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
/* 對bean進行填充,將各個屬性值注入,屬性值的注入可能依賴其他bean,則會遞迴初始化依賴的bean */
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
/* 呼叫初始化方法 */
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);
// 如果earlySingletonReference不為空,說明檢測到迴圈依賴
if (earlySingletonReference != null) {
// 相等說明bean沒有被改變過,也就是沒有被代理
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) {
// 判斷依賴的bean是否建立完成
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// 不為空表示當前bean建立後依賴的bean並沒有全部建立完成,丟擲異常
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 {
/* 註冊DisposableBean */
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
這裡提到了Spring的迴圈依賴,簡單說明一下,首先Spring只能解決單例bean的迴圈依賴,非單例的迴圈依賴會丟擲異常。對於單例bean的迴圈依賴,只能解決setter方式的注入依賴,解決的方式上面提到過,就是通過提前暴露一個單例工廠從而使其他bean能引用到該bean。構造方法方式的迴圈依賴無法解決同樣會丟擲異常。
AbstractAutowireCapableBeanFactory:
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// 解析class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// bean的class訪問修飾符和非public方法訪問許可權的判斷
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());
}
if (mbd.getFactoryMethodName() != null) {
// 如果工廠方法不為空則使用工廠方法來初始化bean,下文會講解構造方法例項化bean的方式,使用工廠方法例項化bean的方式和構造方法例項化bean的方式非常類似,不再單獨闡述
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 如果引數為空則判斷是否解析過構造方法或者工廠方法,並設定解析標記
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果已經解析過則使用解析過的構造方法進行初始化
if (resolved) {
if (autowireNecessary) {
/* 建構函式自動注入 */
return autowireConstructor(beanName, mbd, null, null);
}
else {
/* 使用預設無參構造方法進行初始化 */
return instantiateBean(beanName, mbd);
}
}
/* 根據引數匹配構造方法 */
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
/* 建構函式自動注入 */
return autowireConstructor(beanName, mbd, ctors, args);
}
/* 使用預設無參構造方法進行初始化 */
return instantiateBean(beanName, mbd);
}
AbstractAutowireCapableBeanFactory:
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs) {
/* 構造方法自動注入 */
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
ConstructorResolver:
public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
Constructor<?>[] chosenCtors, final Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
// 初始化BeanWrapper,主要為其織入PropertyEditor屬性編輯器
this.beanFactory.initBeanWrapper(bw);
Constructor<?> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
if (explicitArgs != null) {
// 如果傳入了引數列表,則使用傳入的引數進行匹配
argsToUse = explicitArgs;
}
else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// 嘗