@Data
public class SuperUser implements Serializable {
    private String address;
    public SuperUser(String address) {
        this.address = address;
    }
    public SuperUser() {
    }
}
@Data
@ToString(callSuper = true)
public class User extends SuperUser {
    private String name;
    private Integer age;
    public User() {
    }
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
}

基于GenericBeanDefinition注冊有層次的Bean

public class GenericBeanDefinitionDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //父BeanDefinition
        GenericBeanDefinition rootBeanDefinition = new GenericBeanDefinition();
        rootBeanDefinition.setBeanClass(SuperUser.class);
        //設置參數(shù)
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        propertyValues.addPropertyValue("address", "地址");
        rootBeanDefinition.setPropertyValues(propertyValues);
        //子BeanDefinition
        GenericBeanDefinition childBeanDefinition = new GenericBeanDefinition();
        childBeanDefinition.setBeanClass(User.class);
        //設置構造參數(shù)
        ConstructorArgumentValues argumentValues = new ConstructorArgumentValues();
        argumentValues.addIndexedArgumentValue(0, "我就是我");
        argumentValues.addIndexedArgumentValue(1, 18);
        childBeanDefinition.setConstructorArgumentValues(argumentValues);
        childBeanDefinition.setParentName("superUser");
        //類型相同時 以子類為主
        childBeanDefinition.setPrimary(true);
        context.registerBeanDefinition("superUser", rootBeanDefinition);
        context.registerBeanDefinition("user", childBeanDefinition);
        context.refresh();
        User user = context.getBean("user", User.class);
        System.out.println(user);
        SuperUser superUser = context.getBean("superUser", SuperUser.class);
        System.out.println(superUser);
        context.close();
    }
}

在分析源碼時我們要有側重點，這里會將不太相關的邏輯一帶而過。

AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		//將name解析為beanName，如果傳入的是alias，根據(jù)aliasMap進行轉換，我們在前面介紹過了
		final String beanName = transformedBeanName(name);
		Object bean;
		// 如果是單例Bean
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			//省略日志輸出
			// 這里的邏輯是根據(jù)beanName判斷是否為FactoryBea,并采用相應方式去處理
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		//如果不是單例對象
		else {
			// 對原型對象進行驗證，如果當前beanName已經在創(chuàng)建中了 拋出異常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			// 獲取父BeanFactory，前面我們介紹過了 BeanFactory允許有層級，可已存在父BeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//如果存在父BeanFactory 去父BeanFactory中查找bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				//省略去父BeanFactory查找Bean的過程
			}
			//typeCheckOnly默認為false ，這里將beanName放到alreadyCreated集合中 表示該Bean正在創(chuàng)建中
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}
			try {
			    // 這里來到了我們要重點關注的地方了，bd的合并 ??
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				//如果存在依賴Bean，需要進行依賴查找	
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					// 省略dependsOn 依賴查找代碼
				}
				// 這里的if..else if .. else 是根據(jù)scope取值來的
				//scope=singleton時
				if (mbd.isSingleton()) {
					//省略單實例Bean創(chuàng)建過程
				}
				//scope=prototype時
				else if (mbd.isPrototype()) {
					//省略Prototype Bean創(chuàng)建過程
				}
				//scope=request、application、session時
				else {
					// 省略其他Scope Bean的創(chuàng)建過程
		}
		if (requiredType != null && !requiredType.isInstance(bean)) {
			//省略類型轉換代碼
		}
		// 返回創(chuàng)建的Bean
		return (T) bean;
	}

上面的方法實現(xiàn)比較長、比較復雜，這里只對重要的地方進行些注釋說明并將與本次討論無關的代碼先行進行注釋。

下面就進入到BeanDefinition的合并邏輯了

//假設beanName=user
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// 檢查緩存，若存在直接返回
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
    //getBeanDefinition(beanName)==>實際上去DefaultListableBeanFactory.beanDefinitionMap中根據(jù)key查找BeanDefinition，這在注冊階段已經放到beanDefinitionMap了。
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {
		return getMergedBeanDefinition(beanName, bd, null);
	}
//根據(jù)上面的舉例可知beanName=user,bd是User類的BeanDefinition，containingBd=null
protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {
		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;
			// 嘗試從緩存中拿
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}
			if (mbd == null) {
        //如果當前BeanDefinition沒有指定parentName,說明其不存在父BeanDefinition，不需要合并。以RootBeanDefinition形式展現(xiàn)
				if (bd.getParentName() == null) {
					// 如果bd是RootBeanDefinition類型，直接類型轉換
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
            //通過bd屬性構造RootBeanDefinition
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					// 走到這里說明存在parentName，當前bd需要與其父bd合并
					BeanDefinition pbd;
					try {
            //得到父BeanName
						String parentBeanName = transformedBeanName(bd.getParentName());
            //!beanName.equals(parentBeanName) 條件成立 說明當前beanName屬于子bd
						if (!beanName.equals(parentBeanName)) {
              //遞歸地以父bd名稱 查找父BeanDefinition。之所以遞歸地查找，是因為 可能此時的parentBeanName還有父，實體類存在多重繼承關系
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
              //走到這里，說明beanName.equals(parentBeanName),很有可能是父bd查找BeanDefinition時走來的。
              //獲取父BeanFactory，BeanFactory也是有層次的，有父子關系的，可參見ConfigurableBeanFactory#setParentBeanFactory
							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);
					}
					// pbd是父BeanDefinition，由其構造為RootBeanDefinition
					mbd = new RootBeanDefinition(pbd);
          //bd是子BeanDefinition，主要是繼承父類的屬性，并覆蓋與父類同名的屬性，有興趣的可以看一下overrideFrom方法實現(xiàn)
					mbd.overrideFrom(bd);
				}
				// 如果父bd未指定scope，則設置默認值
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}
				//由于containingBd=null 這里就不看了
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}
				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}
			//最終返回根據(jù)當前beanName找到的bd
			return mbd;
		}
	}

分析了上面的源碼，我們試著總結一下：

1、如果不存在parentName，即不需要被合并，直接將bd轉為RootBeanDefinition 返回即可

2、如果存在parentName