Spring源码(二-1)-XML文件的读取-bean标签

1,232 阅读7分钟

bean标签的解析及注册

上篇博文看到的四个标签中, bean 的解析最为复杂和重要。进入DefaultBeanDefinitionDocumentReaderprocessBeanDefinition(ele, delegate)函数

protected void processBeanDefinition(Element ele,
  BeanDefinitionParserDelegate delegate) {
  //委托 BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement
  //方法进行元素解析,
  //返回 BeanDefinitionHolder对象,这个对象就会包含
  //BeanDefinition,beanName以及aliases
  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(
    ele); > 1
  if(bdHolder != null) {
    //当返回的 bdHolder 不为空的情况下,如果存在默认标签的子节点下
    //再有自定义标签, 需要再次对自定义标签进行解析
    bdHolder = delegate.decorateBeanDefinitionIfRequired(ele,
      bdHolder);
    try {
      // Register the final decorated instance.
      //注册解析得到的BeanDefinition
      BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
        getReaderContext().getRegistry()); > 2
    }
    catch(BeanDefinitionStoreException ex) {
      getReaderContext().error(
        "Failed to register bean definition with name '" +
        bdHolder.getBeanName() + "'", ele, ex);
    }
    // Send registration event.
    //通知相关的监昕器,这个 bean 加载完成了
    getReaderContext().fireComponentRegistered(new BeanComponentDefinition(
      bdHolder));
  }
}

解析 BeanDefinition

首先进入delegate.parseBeanDefinitionElement(ele);函数

@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @
  Nullable BeanDefinition containingBean) {
  //解析id属性
  String id = ele.getAttribute(ID_ATTRIBUTE);
  //解析name属性
  String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
  List < String > aliases = new ArrayList < > ();
  // 将bean元素的name放入别名数组中,spring支持两种方式定义别名,
  // 一种是通过<alias>,另一种是<bean name=""/>
  if(StringUtils.hasLength(nameAttr)) {
    //分割nameAttr
    String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr,
      MULTI_VALUE_ATTRIBUTE_DELIMITERS);
    aliases.addAll(Arrays.asList(nameArr));
  }
  String beanName = id;
  // 如果beanName为空 并且别名集合不为空,将第一个别名作为beanName
  if(!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
    beanName = aliases.remove(0);
    if(logger.isTraceEnabled()) {
      logger.trace("No XML 'id' specified - using '" + beanName +
        "' as bean name and " + aliases + " as aliases");
    }
  }
  // 内部Bean为空时
  // 什么情况下不为空呢?也就是有内部类时
  /**
   * <bean  class="com.gongj.bean.User" name="user2,use" id="user">
   * 		<property name="vip">
   * 			<bean id="inner" class="com.gongj.bean.User$Vip">
   * 				<constructor-arg ref="user"/>
   * 				<property name="vipLevel" value="9"/>
   * 			</bean>
   * 		</property>
   * 	</bean>
   *
   */
  if(containingBean == null) {
    //验证指定的bean名称(也就是id属性)和别名是否已经存在
    checkNameUniqueness(beanName, aliases, ele);
  }
  // 对bean标签的其他属性进行解析,并封装在 GenericBeanDefinition 类型的实例中 
  AbstractBeanDefinition beanDefinition =
    parseBeanDefinitionElement(ele, beanName, containingBean); > 1
  if(beanDefinition != null) {
    //如果不存在 beanName
    if(!StringUtils.hasText(beanName)) {
      try {
        if(containingBean != null) {
          //那么根据 BeanDefinitionReaderUtils 提供的命名规则为当前 
          //bean 生成对应的beanName
          beanName = BeanDefinitionReaderUtils.generateBeanName(
            beanDefinition, this.readerContext.getRegistry(),
            true);
        }
        else {
          // 根据 XmlReaderContext 生成对应的beanName
          //类似于 com.gongj.bean.User#0
          beanName = this.readerContext.generateBeanName(
            beanDefinition);
          // 类似于:com.gongj.bean.User
          String beanClassName = beanDefinition.getBeanClassName();
          if(beanClassName != null && beanName.startsWith(
              beanClassName) && beanName.length() > beanClassName.length() &&
            !this.readerContext.getRegistry().isBeanNameInUse(
              beanClassName)) {
            //放入别名集合中
            aliases.add(beanClassName);
          }
        }
        if(logger.isTraceEnabled()) {
          logger.trace("Neither XML 'id' nor 'name' specified - " +
            "using generated bean name [" + beanName + "]");
        }
      }
      catch(Exception ex) {
        error(ex.getMessage(), ele);
        return null;
      }
    }
    String[] aliasesArray = StringUtils.toStringArray(aliases);
    //将获取到的信息封装到 BeanDefinitionHolder 实例中
    return new BeanDefinitionHolder(beanDefinition, beanName,
      aliasesArray);
  }
  return null;
}

进入标记点 >1parseBeanDefinitionElement(ele, beanName, containingBean)函数,对标签其他属性的解析过程。

@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele,
  String beanName, @Nullable BeanDefinition containingBean) {
  this.parseState.push(new BeanEntry(beanName));
  String className = null;
  //class
  if(ele.hasAttribute(CLASS_ATTRIBUTE)) {
    className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
  }
  String parent = null;
  //parent
  if(ele.hasAttribute(PARENT_ATTRIBUTE)) {
    parent = ele.getAttribute(PARENT_ATTRIBUTE);
  }
  try {
    //将class与parentName作为参数,创建一个 GenericBeanDefinition 实例
    AbstractBeanDefinition bd = createBeanDefinition(className,
      parent); > 1
    //解析默认 bean 标签的各种属性,通过set方法进行属性赋值
    parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); >2
    //提取description
    bd.setDescription(DomUtils.getChildElementValueByTagName(ele,
      DESCRIPTION_ELEMENT));
    // 解析meta元数据
    parseMetaElements(ele, bd);
    //解析lookup-method属性
    parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
    //解析replaced-method属性
    parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
    //解析构造函数参数
    parseConstructorArgElements(ele, bd);
    //解析property子元素
    parsePropertyElements(ele, bd);
    // 解析qualifier子元素
    parseQualifierElements(ele, bd);
    bd.setResource(this.readerContext.getResource());
    bd.setSource(extractSource(ele));
    return bd;
  }
  catch(ClassNotFoundException ex) {
    error("Bean class [" + className + "] not found", ele, ex);
  }
  catch(NoClassDefFoundError err) {
    error("Class that bean class [" + className +
      "] depends on not found", ele, err);
  }
  catch(Throwable ex) {
    error("Unexpected failure during bean definition parsing", ele,
      ex);
  }
  finally {
    this.parseState.pop();
  }
  return null;
}

进入createBeanDefinition(className, parent)函数

protected AbstractBeanDefinition createBeanDefinition(@Nullable
String className, @Nullable String parentName) 
throws ClassNotFoundException {
  return BeanDefinitionReaderUtils.createBeanDefinition(parentName,
    className, this.readerContext.getBeanClassLoader());
}

然后再调试进入createBeanDefinition( parentName, className, this.readerContext.getBeanClassLoader())函数

public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName, 
@Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
  GenericBeanDefinition bd = new GenericBeanDefinition();
  //parentName可能为空
  bd.setParentName(parentName);
  if(className != null) {
    if(classLoader != null) {
      //如果 classLoader 不为空, 则使用传入的 classLoader 加载类对象,否则只是
      //记录className
      bd.setBeanClass(ClassUtils.forName(className, classLoader));
    }
    else {
      bd.setBeanClassName(className);
    }
  }
  return bd;
}

联系之前博文:Spring源码(一)-Bean的定义-BeanDefinition,可以进行考证,如果是 xml 配置,会解析所有属性并统一封装至 GenericBeanDefinition 类型的实例中,之后再逐渐解析。

然后再看一下 标记点 2 那个函数 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); 解析默认 bean 标签的各种属性。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele,
  String beanName, @Nullable BeanDefinition containingBean,
  AbstractBeanDefinition bd) {
  //解析 singleton 属性
  if(ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
    //'singleton'属性升级到'scope'声明
    error(
      "Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration",
      ele);
  }
  //解析 scope 属性
  else if(ele.hasAttribute(SCOPE_ATTRIBUTE)) {
    bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
  }
  //当当前Bean没有明确使用 scope 属性时,且当前Bean被解析为是内部bean的话,
  //则默认使用外部Bean的作用域作为当前bean的作用域
  else if(containingBean != null) {
    // Take default from containing bean in case of an inner bean definition.
    bd.setScope(containingBean.getScope());
  }
  //解析 abstract 属性
  if(ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
    bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(
      ABSTRACT_ATTRIBUTE)));
  }
  //解析 lazy-init 属性
  String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
  if(isDefaultValue(lazyInit)) {
    lazyInit = this.defaults.getLazyInit();
  }
  // 若没有设置或设置为其他字符都会被设置为false
  bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
  //解析 autowire 属性
  String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
  bd.setAutowireMode(getAutowireMode(autowire));
  //解析 depends-on 属性
  if(ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
    String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
    bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn,
      MULTI_VALUE_ATTRIBUTE_DELIMITERS));
  }
  //解析 autowire-candidate 属性
  String autowireCandidate = ele.getAttribute(
    AUTOWIRE_CANDIDATE_ATTRIBUTE);
  if(isDefaultValue(autowireCandidate)) {
    String candidatePattern = this.defaults.getAutowireCandidates();
    if(candidatePattern != null) {
      String[] patterns = StringUtils.commaDelimitedListToStringArray(
        candidatePattern);
      bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(
        patterns, beanName));
    }
  }
  else {
    bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
  }
  //解析 primary 属性
  if(ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
    bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(
      PRIMARY_ATTRIBUTE)));
  }
  //解析 init-method 属性
  if(ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
    String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
    bd.setInitMethodName(initMethodName);
  }
  else if(this.defaults.getInitMethod() != null) {
    bd.setInitMethodName(this.defaults.getInitMethod());
    bd.setEnforceInitMethod(false);
  }
  //解析 destroy-method 属性
  if(ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
    String destroyMethodName = ele.getAttribute(
      DESTROY_METHOD_ATTRIBUTE);
    bd.setDestroyMethodName(destroyMethodName);
  }
  else if(this.defaults.getDestroyMethod() != null) {
    bd.setDestroyMethodName(this.defaults.getDestroyMethod());
    bd.setEnforceDestroyMethod(false);
  }
  //解析 factory-method 属性
  if(ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
    bd.setFactoryMethodName(ele.getAttribute(
      FACTORY_METHOD_ATTRIBUTE));
  }
  //解析 factory-bean 属性
  if(ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
    bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
  }
  return bd;
}

每个属性的作用可以看笔者的之前源码:Spring源码(一)-Bean的定义-BeanDefinition

注册BeanDefinition

到这里Spring已经将 xml 中的配置信息封装至BeanDefinitionHolder对象,接下来就可以执行对 BeanDefinition 的注册了,一起继续向下吧。调试进入 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())函数

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder,
  BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
  // Register bean definition under primary name.
  // 注册bean定义
  String beanName = definitionHolder.getBeanName();
  registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); >
  1
  // Register aliases for bean name, if any.
  // 注册bean名称的别名(如果有的话)
  String[] aliases = definitionHolder.getAliases();
  if(aliases != null) {
    for(String alias: aliases) {
      registry.registerAlias(beanName, alias); > 2
    }
  }
}

从上面的代码可以看出 ,解析的 BeanDefinition 都会被注册到 BeanDefinitionRegistry 类型的实例中, 对于 BeanDefinition 的注册分成了两部分:通过 beanName 的注册以及通过别名的注册。


通过beanName注册

首先进入registry.registerBeanDefinition(beanName,definitionHolder.getBeanDefinition())函数,进入该函数会进入到 BeanDefinitionRegistry接口,该接口下有三个子类,我们选择进入默认使用的DefaultListableBeanFactory子类

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
  Assert.hasText(beanName, "Bean name must not be empty");
  Assert.notNull(beanDefinition, "BeanDefinition must not be null");
  if(beanDefinition instanceof AbstractBeanDefinition) {
    try {
      /*
      *注册前的最后一次校验
      主要是对于 AbstractBeanDefinition 中的 methodOverrides 属性校验,
      * 校验 methodOverrides 是否与工厂方法并存或者 methodOverrides 
      对应的方法根本不存在
      */
      ((AbstractBeanDefinition) beanDefinition).validate();
    }
    catch(BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(),
        beanName, "Validation of bean definition failed", ex);
    }
  }
  // beanDefinitionMap: bean定义对象的映射 key为beanName
  // 根据beanName获取BeanDefinition
  BeanDefinition existingDefinition = this.beanDefinitionMap.get(
    beanName);
  //处理已经注册的 Bean 情况
  if(existingDefinition != null) {
    //如果对应的 Bean 已经注册且在配置中配置了 bean 不允许被覆盖,
    //则抛出异常,默认是 true,也就是允许覆盖
    if(!isAllowBeanDefinitionOverriding()) {
      throw new BeanDefinitionOverrideException(beanName,
        beanDefinition, existingDefinition);
    }
    // getRole方法可以去看上篇 BeanDefinition
    // 使用新的BeanDefinition覆盖已经加载的BeanDefinition
    else if(existingDefinition.getRole() < beanDefinition.getRole()) {
      if(logger.isInfoEnabled()) {
        logger.info(
          "Overriding user-defined bean definition for bean '" +
          beanName +
          "' with a framework-generated bean definition: replacing [" +
          existingDefinition + "] with [" + beanDefinition + "]");
      }
    }
    else if(!beanDefinition.equals(existingDefinition)) {
      if(logger.isDebugEnabled()) {
        logger.debug("Overriding bean definition for bean '" +
          beanName + "' with a different definition: replacing [" +
          existingDefinition + "] with [" + beanDefinition + "]");
      }
    }
    else {
      if(logger.isTraceEnabled()) {
        logger.trace("Overriding bean definition for bean '" +
          beanName + "' with an equivalent definition: replacing [" +
          existingDefinition + "] with [" + beanDefinition + "]");
      }
    }
    //注册 BeanDefinition,加入 beanDefinitionMap 缓存。
    this.beanDefinitionMap.put(beanName, beanDefinition);
  }
  //处理未注册的情况
  else {
    // 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
    if(hasBeanCreationStarted()) {
      
      synchronized(this.beanDefinitionMap) {
        //注册 BeanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
        // 创建List<String>并将缓存的beanDefinitionNames和新的beanName加入集合
        List < String > updatedDefinitions = new ArrayList < > (
          this.beanDefinitionNames.size() + 1);
        updatedDefinitions.addAll(this.beanDefinitionNames);
        updatedDefinitions.add(beanName);
        this.beanDefinitionNames = updatedDefinitions;
        removeManualSingletonName(beanName); > 1
      }
    }
    else {
      // Still in startup registration phase
      // 仍处于启动注册阶段
      this.beanDefinitionMap.put(beanName, beanDefinition);
      //维护了beanName集合
      this.beanDefinitionNames.add(beanName);
      removeManualSingletonName(beanName); > 1
    }
    this.frozenBeanDefinitionNames = null;
  }
  // 当前注册的bean的定义已经在beanDefinitionMap缓存中存在,
  // 或者其实例已经存在于单例bean的缓存中(singletonObjects),
  //就进行重置当前Bean的BeanDefinition
  if(existingDefinition != null || containsSingleton(beanName)) {
    resetBeanDefinition(beanName);
  }
}
protected boolean hasBeanCreationStarted() {
  return !this.alreadyCreated.isEmpty();
}

我们看一下removeManualSingletonName(beanName)这个函数,这个函数使用了 java8 的函数式接口。

private void removeManualSingletonName(String beanName) {
  updateManualSingletonNames(set - > set.remove(beanName), set - >
    set.contains(beanName));
}
private void updateManualSingletonNames(Consumer < Set < String >>
  action, Predicate < Set < String >> condition) {
  if(hasBeanCreationStarted()) {
   
    synchronized(this.beanDefinitionMap) {
      //如果manualSingletonNames中包含新注册的beanName
      //对应 set -> set.contains(beanName)
      if(condition.test(this.manualSingletonNames)) {
        // 创建set集合并将manualSingletonNames加入到新创建的set集合
        Set < String > updatedSingletons = new LinkedHashSet < >
          (this.manualSingletonNames);
        //然后移除新注册的beanName
        //对应set.remove(beanName)
        action.accept(updatedSingletons);
        this.manualSingletonNames = updatedSingletons;
      }
    }
  }
  else {
    // Still in startup registration phase
    if(condition.test(this.manualSingletonNames)) {
      action.accept(this.manualSingletonNames);
    }
  }
}

第一个函数表达式入参为一个 Consumer 消费型接口,代表接受一个输入参数并且无返回的操作 第二个函数表达式入参为一个 Predicate 断言形接口,接受一个输入参数,返回一个布尔值结果。


接下来就看看上面代码所用的数据存储容器:

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

  • beanDefinitionMap:bean定义对象的映射,key为beanName,value为BeanDefinition
  • beanDefinitionNames :beanName列表
  • alreadyCreated :存储至少创建了一次的bean的名称
  • manualSingletonNames:手动注册的单例的名称列表

通过别名注册

进入registry.registerAlias(beanName, alias)函数,会跳转到 AliasRegistry接口,该接口下有两个实现类 GenericApplicationContextSimpleAliasRegistry,我们选择SimpleAliasRegistry

@Override
public void registerAlias(String name, String alias) {
  Assert.hasText(name, "'name' must not be empty");
  Assert.hasText(alias, "'alias' must not be empty");
  synchronized(this.aliasMap) {
    //别名与beanName相同
    if(alias.equals(name)) {
      //将该别名从Map中移除
      this.aliasMap.remove(alias);
      if(logger.isDebugEnabled()) {
        logger.debug("Alias definition '" + alias +
          "' ignored since it points to same name");
      }
    }
    //别名与beanName不相同
    else {
      // 根据传入的别名获取beanName
      String registeredName = this.aliasMap.get(alias);
      if(registeredName != null) {
        //已经注册的名称与当前需要注册的beanName相等
        /*
        <alias name="user" alias="user2"></alias>
        <alias name="user" alias="user2"></alias>
         */
        if(registeredName.equals(name)) {
          // An existing alias - no need to re-register
          //已存在的别名-不需要重新注册
          return;
        }
        //如果 alias 不允许被覆盖则抛出异常,默认是true,允许被覆盖
        if(!allowAliasOverriding()) {
          throw new IllegalStateException("Cannot define alias '" +
            alias + "' for name '" + name +
            "': It is already registered for name '" +
            registeredName + "'.");
        }
        if(logger.isDebugEnabled()) {
          logger.debug("Overriding alias '" + alias +
            "' definition for registered name '" +
            registeredName + "' with new target name '" + name +
            "'");
        }
      }
      // 检查给定的名称(user2)是否指向给定的别名(user)作为别名(user2)
      /*
         2、<alias name="user" alias="user2"></alias>
         1、<alias name="user2" alias="user"></alias>
          */
      checkForAliasCircle(name, alias);
      //缓存别名
      this.aliasMap.put(alias, name);
      if(logger.isTraceEnabled()) {
        logger.trace("Alias definition '" + alias +
          "' registered for name '" + name + "'");
      }
    }
  }
}

bean 标签的解析及注册解析完成啦!