注册解析的BeanDefinition

前言

　　上两篇文章讲述了bean标签的解析以及bean标签中子元素的解析，其实在注册解析的BeanDefinition之前，还有一步是对bean标签的装饰，即对bean自定义的标签和自定义的属性进行解析，这个将放在后面的文章讲述，这篇文章讲述的是注册解析了的BeanDefinition。

注册解析的BeanDefinition

对于配置文件来说，解析的已经解析完了，装饰也装饰完了（对bean自定义的标签和自定义的属性进行解析），对于得到的BeanDefinition已经满足后续的使用要求了，还剩下的工作就是注册了，也就是：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                // Register the final decorated instance.
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
            }
            catch (BeanDefinitionStoreException ex) {
                getReaderContext().error("Failed to register bean definition with name '" +
                        bdHolder.getBeanName() + "'", ele, ex);
            }
            // Send registration event.
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

上述代码的第7行了。这个函数是默认标签解析函数的起始函数。之前的文章也提到过。继续跟踪这段代码：

public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        // 使用beanName做唯一标识注册
        String beanName = definitionHolder.getBeanName();
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

        // 注册所有的别名
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

从上述代码可以看出，解析的BeanDefinition都会被注册到BeanDefinitionRegistry类型的实例registry中，而整个的BeanDefinition的注册分成了两部分：通过beanName的注册和通过别名注册。

通过beanName注册BeanDefinition

对于BeanDefinition的注册的方式是将BeanDefinition直接放入map中，还做了一些其他的事情。来看：

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) beanDefinition).validate();
            }
            catch (BeanDefinitionValidationException ex) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                        "Validation of bean definition failed", ex);
            }
        }

        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        // 处理注册已经注册的beanName情况
        if (existingDefinition != null) {
            // 如果对应的beanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常。
            if (!isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
            }
            else if (existingDefinition.getRole() < beanDefinition.getRole()) {
                // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
                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 + "]");
                }
            }
            this.beanDefinitionMap.put(beanName, beanDefinition);
        }
        else {
            if (hasBeanCreationStarted()) {
                // 因为beanDefinitionMap是全局变量，这里定会存在并发访问的情况
                synchronized (this.beanDefinitionMap) {
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                    updatedDefinitions.addAll(this.beanDefinitionNames);
                    updatedDefinitions.add(beanName);
                    this.beanDefinitionNames = updatedDefinitions;
                    if (this.manualSingletonNames.contains(beanName)) {
                        Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                        updatedSingletons.remove(beanName);
                        this.manualSingletonNames = updatedSingletons;
                    }
                }
            }
            else {
                // 注册beanDefinition
                this.beanDefinitionMap.put(beanName, beanDefinition);
                // 记录beanName
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);
            }
            this.frozenBeanDefinitionNames = null;
        }

        if (existingDefinition != null || containsSingleton(beanName)) {
            // 重置所有beanName对应的缓存
            resetBeanDefinition(beanName);
        }
    }

上述的代码中我们可以看出，在bean 的注册处理方式上，主要进行了以下几个步骤：

（1）对AbstractBeanDefinition的校验。在解析XML文件的时候我们提过校验，但是此校验非彼校验，之前的校验是针对于XML格式的校验，而此时的校验是针对于AbstractBeanDefinition的methodOverrides属性的。

（2）对beanName已经注册了的情况进行处理，如果设置了不允许bean的覆盖，则会抛出异常，否则就直接覆盖。

（3）加入beanDefinitionMap缓存。

（4）清除解析之前留下的对应beanName的缓存。

通过别名注册BeanDefinition

在理解了上述的注册bean原理后，理解别名注册的原理就容易多了：

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与alias相同的话就不记录alias，并删除对应的alias
            if (alias.equals(name)) {
                this.aliasMap.remove(alias);
                if (logger.isDebugEnabled()) {
                    logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
                }
            }
            else {
                String registeredName = this.aliasMap.get(alias);
                if (registeredName != null) {
                    if (registeredName.equals(name)) {
                        // An existing alias - no need to re-register
                        return;
                    }
                    //如果alias不允许被覆盖则抛出异常
                    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 + "'");
                    }
                }
                //当A->B存在时，若再次出现A->C->B时，则会抛出异常
                checkForAliasCircle(name, alias);
                this.aliasMap.put(alias, name);
                if (logger.isTraceEnabled()) {
                    logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
                }
            }
        }
    }

注册alias的步骤如下：

（1）alias与beanName相同时的处理。若alias与beanName名称相同则不需要处理还会删除原有的alias。

（2）alias覆盖处理。若aliasName已经使用并已经指向了另一个beanName则需要用户设置进行处理。

（3）alias循环处理。当A->B存在时，若再次出现A->C->B时，则会抛出异常。

（4）注册alias。

通知监听器解析及注册完成

　　通过代码：

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

来完成这个工作，这里的实现只为扩展，当程序开发人员需要对注册BeanDefinition事件进行监听时可以通过注册监听器的方式并将处理逻辑写入监听器中，目前Spring中并没有对此事件做任何处理。

public void fireComponentRegistered(ComponentDefinition componentDefinition) {
        this.eventListener.componentRegistered(componentDefinition);
    }

public void componentRegistered(ComponentDefinition componentDefinition) {
        // no-op
    }

参考：《Spring源码深度解析》 郝佳 编著：