08--SpringIoC容器初始化BeanDefinition注册

上篇已经讲到将资源文件里的标签解析为BeanDefinition对象并封装至BeanDefinitionHolder对象,接下来就是对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) {
    //解析Element节点,并将转换信息封装到BeanDefinitionHolder
    //BeanDefinitionHolder封装了definition,beanName,以及aliases信息
    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));
    }
}

通过上面代码可以看到, 通过BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());进行注册,跟踪源码

/**
 * 将解析到的bean注册到beanFactory
 * @param definitionHolder 封装了definition,beanName,以及aliases信息
 * @param registry         BeanDefinitionRegistry可以理解为spring内置数据库,通过hashMap维护bean注册信息
 * @throws BeanDefinitionStoreException if registration failed
 */
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws
        BeanDefinitionStoreException {

    // Register bean definition under primary name.
    // 获取beanName
    String beanName = definitionHolder.getBeanName();
    // 执行注册
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

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

beanDefinition分为了两个部分, beanName注册和aliases注册

1. beanName注册

@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");

    //如果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);
        }
    }

    //尝试从缓存中获取beanDefinition
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    //如果beanDefinition在缓存中已经存在
    if (existingDefinition != null) {
        // beanDefinition在缓存中已经存在,且不允许被覆盖,
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        //缓存中existingDefinition角色索引值小于beanDefinition角色索引值,则用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 + "]");
            }
        }
        //缓存中的existingDefinition不等于beanDefinition,则用beanDefinition覆盖缓存中的existingDefinition
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        //直接用beanDefinition覆盖缓存中的existingDefinition
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        //覆盖,这里我们也可以看到spring内部通过Map<String, BeanDefinition>来维护注册的beanDefinition信息
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    //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信息维护到缓存中
            // Still in startup registration phase
            //beanDefinitionMap-->(key->beanName,value->beanDefinition)
            this.beanDefinitionMap.put(beanName, beanDefinition);
            //beanDefinitionNames-->维护了beanName集合
            this.beanDefinitionNames.add(beanName);
            //manualSingletonNames维护的是手动注册的bean,所以如果manualSingletonNames缓存已经存在beanName,要将其移除
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

2. aliases别名注册

//获取bean的别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
    //循环并注册别名
    for (String alias : aliases) {
        registry.registerAlias(beanName, alias);
    }
}

修改xml配置文件,增加别名

<bean id="foo" class="org.springframework.tests.sample.beans.TestBean" p:name="Baz" name="foo,myFoo"/>

再来看别名的注册过程

// 注册别名
@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 + "'.");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
                            registeredName + "' with new target name '" + name + "'");
                }
            }
            //检查给定名称是否已指向另一个方向的别名作为别名,预先捕获循环引用并抛出相应的IllegalStateException
            checkForAliasCircle(name, alias);
            //缓存别名
            this.aliasMap.put(alias, name);
            if (logger.isTraceEnabled()) {
                logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
            }
        }
    }
}

分析到这里已经完成了资源文件定位,资源文件解析,注册BeanDefinition,SpringIoC容器的启动工作也就到此结束了,到这里大家可以发现,SpringIoC容器初始化的过程中,并没有发现我们最想看的依赖注入部分,这个操作发生在什么时候呢,就是在我们第一次像IoC容器索取bean的时候,即下面这句代码ITestBean foo = (ITestBean) beanFactory.getBean("foo");,虽然代码只有一行,但是其复杂度远远超出我们想象,再接下来几篇代码中,我们就会分析IoC容器的依赖注入~