Spring官网阅读（五）BeanDefinition（下）

//  是否抽象
boolean isAbstract();
// 获取父BeanDefinition的名称
String getParentName();

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 <bean id="parent" abstract="true"
    class="com.dmz.official.merge.TestBean">
  <property name="name" value="parent"/>
  <property name="age" value="1"/>
 </bean>
 <bean id="child"
    class="com.dmz.official.merge.DerivedTestBean"
    parent="parent" >
  <property name="name" value="override"/>
 </bean>
</beans>

public class DerivedTestBean {
 private String name;

 private int age;

    // 省略getter setter方法
}

public class TestBean {
 private String name;

 private String age;

     // 省略getter setter方法
}

public class Main {
 public static void main(String[] args) {
  ClassPathXmlApplicationContext cc = new ClassPathXmlApplicationContext("application.xml");
  DerivedTestBean derivedTestBean = (DerivedTestBean) cc.getBean("child");
  System.out.println("derivedTestBean的name = " + derivedTestBean.getName());
  System.out.println("derivedTestBean的age = " + derivedTestBean.getAge());
 }
}

 public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory,
                List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        // .....
     // 省略部分代码，省略的代码主要时用来执行程序员手动调用API注册的容器的后置处理器
        // .....

  // 发生一次bd的合并
        // 这里只会获取实现了BeanDefinitionRegistryPostProcessor接口的Bean的名字
   String[] postProcessorNames =             beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
   for (String ppName : postProcessorNames) {
                // 筛选实现了PriorityOrdered接口的后置处理器
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
     // 去重
     processedBeans.add(ppName);
    }
   }
   // .....
            // 只存在一个internalConfigurationAnnotationProcessor 处理器，用于扫描
         // 这里只会执行了实现了PriorityOrdered跟BeanDefinitionRegistryPostProcessor的后置处理器
   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   // .....
         // 这里又进行了一个bd的合并
   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
   for (String ppName : postProcessorNames) {
                // 筛选实现了Ordered接口的后置处理器
    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
     processedBeans.add(ppName);
    }
   }
   // .....
         // 执行的是实现了BeanDefinitionRegistryPostProcessor接口跟Ordered接口的后置处理器
   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
   boolean reiterate = true;
   while (reiterate) {
    reiterate = false;
            // 这里再次进行了一次bd的合并
    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    for (String ppName : postProcessorNames) {
     if (!processedBeans.contains(ppName)) {
                        // 筛选只实现了BeanDefinitionRegistryPostProcessor的后置处理器
      currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
      processedBeans.add(ppName);
      reiterate = true;
     }
    }
    sortPostProcessors(currentRegistryProcessors, beanFactory);
    registryProcessors.addAll(currentRegistryProcessors);
                // 执行的是普通的后置处理器，即没有实现任何排序接口（PriorityOrdered或Ordered)
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    currentRegistryProcessors.clear();
   }
        // .....
        // 省略部分代码，这部分代码跟BeanfactoryPostProcessor接口相关，这节bd的合并无关，下节容器的扩展点中我会介绍
        // .....

 }

public void preInstantiateSingletons() throws BeansException {
    // .....
 // 省略跟合并无关的代码
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // .....

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    // .....
    // 省略跟合并无关的代码
    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    checkMergedBeanDefinition(mbd, beanName, args);

    // Guarantee initialization of beans that the current bean depends on.
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        // ....
    }
    if (mbd.isSingleton()) {
        // ....
    }
    // ....

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    // Quick check on the concurrent map first, with minimal locking.
    // 从缓存中获取合并后的bd
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    if (mbd != null) {
        return mbd;
    }
    // 如何获取不到的话，开始真正的合并
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

 protected RootBeanDefinition getMergedBeanDefinition(
   String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
   throws BeanDefinitionStoreException {

  synchronized (this.mergedBeanDefinitions) {
   RootBeanDefinition mbd = null;

   // Check with full lock now in order to enforce the same merged instance.
   if (containingBd == null) {
    mbd = this.mergedBeanDefinitions.get(beanName);
   }

   if (mbd == null) {
                // 如果没有parentName的话直接使用自身合并
                // 就是new了RootBeanDefinition然后再进行属性的拷贝
    if (bd.getParentName() == null) {
     if (bd instanceof RootBeanDefinition) {
      mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
     }
     else {
      mbd = new RootBeanDefinition(bd);
     }
    }
    else {
     // 需要进行父子的合并
     BeanDefinition pbd;
     try {
      String parentBeanName = transformedBeanName(bd.getParentName());
      if (!beanName.equals(parentBeanName)) {
                            // 这里是递归，在将父子合并时，需要确保父bd已经合并过了
       pbd = getMergedBeanDefinition(parentBeanName);
      }
      else {
                            // 一般不会进这个判断
                            // 到父容器中找对应的bean，然后进行合并，合并也发生在父容器中
       BeanFactory parent = getParentBeanFactory();
       if (parent instanceof ConfigurableBeanFactory) {
        pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
       }
       // 省略异常信息......
      }
     }
     // 省略异常信息......
     //
     mbd = new RootBeanDefinition(pbd);
                    //用子bd中的属性覆盖父bd中的属性
     mbd.overrideFrom(bd);
    }

    // 默认设置为单例
    if (!StringUtils.hasLength(mbd.getScope())) {
     mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
    }
                // 当前bd如果内部嵌套了一个bd,并且嵌套的bd不是单例的，但是当前的bd又是单例的
                // 那么将当前的bd的scope设置为嵌套bd的类型
    if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
     mbd.setScope(containingBd.getScope());
    }
    // 将合并后的bd放入到mergedBeanDefinitions这个map中
                // 之后还是可能被清空的，因为bd可能被修改
    if (containingBd == null && isCacheBeanMetadata()) {
     this.mergedBeanDefinitions.put(beanName, mbd);
    }
   }

   return mbd;
  }
 }

<bean id="luBanService" class="com.dmz.official.service.LuBanService" scope="prototype">
    <property name="lookUpService">
        <bean class="com.dmz.official.service.LookUpService" scope="singleton"></bean>
    </property>
</bean>