4、Spring 源码学习 ~ 默认标签的解析之 Bean 标签注册

默认标签的解析之 Bean 标签注册

一、注册解析的 BeanDefinition

关注前面的章节，我们已经对配置文件，进行了解析，得到了 BeanDefinition 对象，接下来的工作就是注册了。我们来看 processBeanDefinition 函数中的以下代码：

// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

具体源码如下：

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

   	// 使用 beanName 作为唯一标识注册
    // Register bean definition under primary name.
    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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

从上面可以看出，解析的 beanDefinition 会被注册到 BeanDefinitionRegistry 的实例 registry 中，而注册分为 beanName 的注册和别名 alias 的注册。

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

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            /**
              * 注册前最后一次校验，这里的校验不同于之前的 xml 文件校验
              * 主要是对于 AbstractBeanDefinition 属性中的 methodOverrides 校验
              * 校验 methodOverrides 是否与工厂方法并存或者 methodOverrides 对应的方法根本不存在
              **/
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                                   "Validation of bean definition failed", ex);
        }
    }

    //因为 beanDefinitionMap 是全局变量，这里会存在并发访问的情况
    //spring 使用的是 ConcurrentHashMap 来解决此情况
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    // 是否已注册，里面是已注册的 beanName 的处理逻辑
    if (existingDefinition != null) {
        //配置文件中配置了 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 + "]");
            }
        }
        //注册 beanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    // 未注册 beanName 的处理逻辑
    else {
        //bean 的创建是否已开始
        //即在此期间是否有任何 bean 被标记为已创建,则记为已开始
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            //已启动的集合不允许在修改
            synchronized (this.beanDefinitionMap) {
                //注册 beanDefinition
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                removeManualSingletonName(beanName);
            }
        }
        else {
            //仍处于启动注册阶段，还未开始 bean 的创建
            // Still in startup registration phase
            //注册 beanDefinition
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        //重置所有 beanName 对应的缓存
        resetBeanDefinition(beanName);
    }
    else if (isConfigurationFrozen()) {
        //删除关于按类型映射的任何缓存
        clearByTypeCache();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

上述代码在对 bean 的注册处理方式上，主要进行了以下几个步骤：

• **1、对 AbstractBeanDefinition 的校验。**在解析 xml 文件时，我们提过校验，但这里的校验是针对 AbstractBeanDefinition 中的 methodOverrides 属性。
• **2、对 beanName 已经注册的情况处理。**若设置了不允许覆盖，则抛出异常，否则，在 beanDefinitionMap 中直接覆盖
• **3、对 beanName 未注册的情况处理。**放入 beanDefinitionMap 中
• **4、重置解析 bean 时，所有 bean 相关缓存。**包括从它派生的 bean 的缓存
• 5、删除关于按类型映射的任何缓存。

2、通过别名 alias 注册

直接看源码，如下：

@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 与 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;
                }
                //不允许注册，抛出异常
                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 或 B->A 时，则抛出异常。
            checkForAliasCircle(name, alias);
            this.aliasMap.put(alias, name);
            if (logger.isTraceEnabled()) {
                logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

二、通知监听器解析和注册已完成

// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

目前 Spring 并没有对此事件做任何逻辑处理，如果我们想拓展以实现自己的逻辑，可以通过注册监听器的方式，并将逻辑写入监听器中。

到此，我们已经完成了 bean 标签的解析和注册工作了，下面的章节，我们来学习 alias 标签的解析。