18--Spring注册BeanDefinition

版权声明：如有转载，请标明出处，谢谢合作！ https://blog.csdn.net/lyc_liyanchao/article/details/83041869

上一节分析了Spring解析xml默认命名空间并将解析到的数据封住至BeanDefinitionHolder对象中。接下来就可以执行BeanDefinition的注册了。该过程分为两个部分，注册BeanDefinition和注册aliases（别名）。

1. 引

上一节分析到了processBeanDefinition方法中的第一步，接着往下执行就应该是装饰BeanDefinition对象和执行BeanDefinition注册。

/**
 * 解析bean标签将其转换为definition并注册到BeanDefinitionRegistry
 * Process the given bean element, parsing the bean definition and registering it with the registry.
 */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 1、将解析的节点信息封装至BeanDefinitionHolder对象
    // BeanDefinitionHolder-->封装了BeanDefinition,beanName以及aliases
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // 2、装饰BeanDefinition
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            // 3、执行注册
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        // 4、发送注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

1. 注册BeanDefinition步骤简析

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

    // Register bean definition under primary name.
    // 1、注册BeanDefinition
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

    // Register aliases for bean name, if any.
    // 2、注册aliases（别名）
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        for (String alias : aliases) {
            registry.registerAlias(beanName, alias);
        }
    }
}

从代码中可以了解到，该过程一共分为了两个部分

• 1、注册BeanDefinition
• 2、注册aliases（别名）

下面对这两个过程逐一进行分析。

3.注册注册BeanDefinition

注册注册BeanDefinition的工作交给了BeanDefinitionRegistry接口的默认实现DefaultListableBeanFactory。该过程还是比较复杂的。来看代码。。。

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {

    // 1、如果beanDefinition是AbstractBeanDefinition实例,则验证
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            //验证不能将静态工厂方法与方法重写相结合(静态工厂方法必须创建实例)
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);
        }
    }

    // 2、优先尝试从缓存中加载BeanDefinition
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        // beanName已经存在且不允许被覆盖，抛出异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        // 使用新的BeanDefinition覆盖已经加载的BeanDefinition，if else中只有日志打印，无实质代码，删除为了阅读方便
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {}
        else if (!beanDefinition.equals(existingDefinition)) {}
        else {}
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    // 3、缓存中无对应的BeanDefinition，则直接注册
    else {
        // 如果beanDefinition已经被标记为创建(为了解决单例bean的循环依赖问题)
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                // 加入beanDefinitionMap
                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);
                // 将updatedDefinitions赋值给beanDefinitionNames
                this.beanDefinitionNames = updatedDefinitions;
                // 如果manualSingletonNames中包含新注册的beanName
                if (this.manualSingletonNames.contains(beanName)) {
                    // 创建set集合并将manualSingletonNames加入到新创建的set集合
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    // 移除新注册的beanName
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
            //以上操作就是重新创建beanDefinitionNames和manualSingletonNames集合,这段代码我也不是很理解...
        }
        else {
            // 将beanDefinition信息维护至缓存
            // beanDefinitionMap-->(key->beanName,value->beanDefinition)
            this.beanDefinitionMap.put(beanName, beanDefinition);
            // beanDefinitionNames-->维护了beanName集合
            this.beanDefinitionNames.add(beanName);
            // manualSingletonNames缓存了手动注册的单例bean，所以需要调用一下remove方法，防止beanName重复
            // 例如：xmlBeanFactory.registerSingleton("myDog", new Dog());
            // 就可以向manualSingletonNames中注册单例bean
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    // 4、重置BeanDefinition，
    // 当前注册的bean的定义已经在beanDefinitionMap缓存中存在，
    // 或者其实例已经存在于单例bean的缓存中
    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

注册流程在代码里已经标注的很清楚了，其中synchronized方法中的代码，分析不是很明确，希望了解的同学可以留言指正。

4.注册别名

// 注册别名
@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)) {
            //移除别名
            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) {
                //缓存中的别名和beanName(注意:不是别名)相同,不做任何操作,不需要再次注册
                if (registeredName.equals(name)) {
                    // An existing alias - no need to re-register
                    return;
                }
                //缓存中存在别名,且不允许覆盖,抛出异常
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                            name + "': It is already registered for name '" + registeredName + "'.");
                }
            }
            //检查给定名称是否已指向另一个方向的别名作为别名,预先捕获循环引用并抛出相应的IllegalStateException
            checkForAliasCircle(name, alias);
            //缓存别名
            this.aliasMap.put(alias, name);
        }
    }
}

5.分析

以上操作已经完成了整个BeanDefinition和别名的注册，加上以前分析的代码我们可以发现一些Spring源码中的书写技巧。

• 方法职责单一，Spring中很少有一个长而复杂的方法，也很少在一个方法里处理多个逻辑，即便有也是将具体的逻辑分支细化，在主方法里调用。
• 处理流程明确简析，Spring中很多方法，例如我们今天分析的BeanDefinition注册，以及接下来要分析的获取bean的过程等，都是先进行合法验证、尝试从缓存中获取、如未能从缓存中获取到才去真正创建对象实例、将新创建的实例加入缓存等等。

以上只是两个小例子，多读代码，多跟踪调试，才是阅读开源代码的途径，随着阅读次数的增加，相信大家会原来越加深对框架的理解，当我们真正能读懂Spring的源码之后，相信大家在看其他的源码，也能触类旁通，成为阅读开源代码的高手。