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

public class GenericBeanDefinitionDemo {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //父BeanDefinition
        GenericBeanDefinition rootBeanDefinition = new GenericBeanDefinition();
        rootBeanDefinition.setBeanClass(SuperUser.class);
        //設(shè)置參數(shù)
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        propertyValues.addPropertyValue("address", "地址");
        rootBeanDefinition.setPropertyValues(propertyValues);
        //子BeanDefinition
        GenericBeanDefinition childBeanDefinition = new GenericBeanDefinition();
        childBeanDefinition.setBeanClass(User.class);
        //設(shè)置構(gòu)造參數(shù)
        ConstructorArgumentValues argumentValues = new ConstructorArgumentValues();
        argumentValues.addIndexedArgumentValue(0, "我就是我");
        argumentValues.addIndexedArgumentValue(1, 18);
        childBeanDefinition.setConstructorArgumentValues(argumentValues);
        childBeanDefinition.setParentName("superUser");
        //類型相同時(shí) 以子類為主
        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();
    }
}

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進(jìn)行轉(zhuǎn)換，我們?cè)谇懊娼榻B過(guò)了
		final String beanName = transformedBeanName(name);
		Object bean;
		// 如果是單例Bean
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			//省略日志輸出
			// 這里的邏輯是根據(jù)beanName判斷是否為FactoryBea,并采用相應(yīng)方式去處理
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		//如果不是單例對(duì)象
		else {
			// 對(duì)原型對(duì)象進(jìn)行驗(yàn)證，如果當(dāng)前beanName已經(jīng)在創(chuàng)建中了 拋出異常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			// 獲取父BeanFactory，前面我們介紹過(guò)了 BeanFactory允許有層級(jí)，可已存在父BeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//如果存在父BeanFactory 去父BeanFactory中查找bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				//省略去父BeanFactory查找Bean的過(guò)程
			}
			//typeCheckOnly默認(rèn)為false ，這里將beanName放到alreadyCreated集合中 表示該Bean正在創(chuàng)建中
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}
			try {
			    // 這里來(lái)到了我們要重點(diǎn)關(guān)注的地方了，bd的合并 ??
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				//如果存在依賴Bean，需要進(jìn)行依賴查找	
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					// 省略dependsOn 依賴查找代碼
				}
				// 這里的if..else if .. else 是根據(jù)scope取值來(lái)的
				//scope=singleton時(shí)
				if (mbd.isSingleton()) {
					//省略單實(shí)例Bean創(chuàng)建過(guò)程
				}
				//scope=prototype時(shí)
				else if (mbd.isPrototype()) {
					//省略Prototype Bean創(chuàng)建過(guò)程
				}
				//scope=request、application、session時(shí)
				else {
					// 省略其他Scope Bean的創(chuàng)建過(guò)程
		}
		if (requiredType != null && !requiredType.isInstance(bean)) {
			//省略類型轉(zhuǎn)換代碼
		}
		// 返回創(chuàng)建的Bean
		return (T) bean;
	}

//假設(shè)beanName=user
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// 檢查緩存，若存在直接返回
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
    //getBeanDefinition(beanName)==>實(shí)際上去DefaultListableBeanFactory.beanDefinitionMap中根據(jù)key查找BeanDefinition，這在注冊(cè)階段已經(jīng)放到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) {
        //如果當(dāng)前BeanDefinition沒(méi)有指定parentName,說(shuō)明其不存在父BeanDefinition，不需要合并。以RootBeanDefinition形式展現(xiàn)
				if (bd.getParentName() == null) {
					// 如果bd是RootBeanDefinition類型，直接類型轉(zhuǎn)換
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
            //通過(guò)bd屬性構(gòu)造RootBeanDefinition
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					// 走到這里說(shuō)明存在parentName，當(dāng)前bd需要與其父bd合并
					BeanDefinition pbd;
					try {
            //得到父BeanName
						String parentBeanName = transformedBeanName(bd.getParentName());
            //!beanName.equals(parentBeanName) 條件成立 說(shuō)明當(dāng)前beanName屬于子bd
						if (!beanName.equals(parentBeanName)) {
              //遞歸地以父bd名稱 查找父BeanDefinition。之所以遞歸地查找，是因?yàn)?可能此時(shí)的parentBeanName還有父，實(shí)體類存在多重繼承關(guān)系
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
              //走到這里，說(shuō)明beanName.equals(parentBeanName),很有可能是父bd查找BeanDefinition時(shí)走來(lái)的。
              //獲取父BeanFactory，BeanFactory也是有層次的，有父子關(guān)系的，可參見(jiàn)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，由其構(gòu)造為RootBeanDefinition
					mbd = new RootBeanDefinition(pbd);
          //bd是子BeanDefinition，主要是繼承父類的屬性，并覆蓋與父類同名的屬性，有興趣的可以看一下overrideFrom方法實(shí)現(xiàn)
					mbd.overrideFrom(bd);
				}
				// 如果父bd未指定scope，則設(shè)置默認(rèn)值
				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ù)當(dāng)前beanName找到的bd
			return mbd;
		}
	}