读取XML中的别名配置

回顾上一章节

在上一篇文章中，我们深入探索了 Spring 如何从命名空间找到对应的解析器：

• Spring 通过 parseCustomElement 方法解析非默认命名空间的标签
• 通过 DefaultNamespaceHandlerResolver 加载 META-INF/spring.handlers 文件，建立命名空间到处理器的映射关系
• 通过懒加载和缓存机制，实现按需加载和性能优化
• 通过策略模式和约定优于配置，实现了灵活的扩展机制

💡 关键理解：在解析 XML 配置时，Spring 需要处理各种标签，包括默认命名空间的 <bean>、<alias>、<import> 等标签。那么，Spring 是如何处理 <alias> 标签，为 Bean 定义别名的呢？

统一术语

在开始之前，我们先明确几个关键术语：

• 别名（Alias）：Bean 的另一个名称，可以通过别名访问同一个 Bean
• Bean 名称（Bean Name）：Bean 的唯一标识符，通常通过 id 或 name 属性指定
• AliasRegistry：别名注册表接口，负责管理 Bean 的别名
• SimpleAliasRegistry：别名注册表的简单实现，使用 Map 存储别名映射关系
• BeanDefinitionRegistry：Bean 定义注册表，继承自 AliasRegistry，负责注册和管理 Bean 定义

问题场景

当我们使用 Spring 时，XML 配置文件中可以使用 <alias> 标签为 Bean 定义别名：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义一个Bean -->
    <bean id="userService" class="com.example.UserService"/>
    
    <!-- 为Bean定义别名 -->
    <alias name="userService" alias="userServiceImpl"/>
    <alias name="userService" alias="userServiceBean"/>
</beans>

核心问题：

1. Spring 如何解析 <alias> 标签？ 当遇到 <alias> 标签时，Spring 是如何处理的？
2. 别名是如何存储的？ Spring 使用什么数据结构来存储别名和 Bean 名称之间的映射关系？
3. 别名是如何被使用的？ 当我们通过别名获取 Bean 时，Spring 是如何找到对应的 Bean 的？
4. 别名和 Bean 名称有什么区别？ 为什么需要别名？别名有什么实际用途？
5. 如何处理别名的循环引用？ 如果别名 A 指向别名 B，别名 B 又指向别名 A，Spring 如何处理？

这些问题看似简单，但深入思考会发现，它们背后有一套清晰的机制。让我们从源码中寻找答案。

源码探索

第一步：processAliasRegistration 方法的核心逻辑

关键方法为：processAliasRegistration(Element ele)。

让我们看看这个方法做了什么：

protected void processAliasRegistration(Element ele) {
    // 获取 name 和 alias 的配置
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    
    // 如果存在空字符串则不注册
    boolean valid = true;
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    
    if (valid) {
        try {
            // 注册时通过上下文中的注册器注册别名
            getReaderContext().getRegistry().registerAlias(name, alias);
        } catch (Exception ex) {
            getReaderContext().error("Failed to register alias '" + alias +
                    "' for bean with name '" + name + "'", ele, ex);
        }
    }
}

🔍 发现一：方法的核心逻辑分为三步：

1. 获取 name 和 alias 的配置：从 XML 元素中获取 name 和 alias 属性
2. 验证配置：如果存在空字符串则不注册，并记录错误信息
3. 注册别名：通过上下文中的注册器注册别名

💡 关键理解：注册时通过上下文中的注册器注册别名。这里我们可以回顾一下，一开始的 XmlBeanFactory 实际上就是一个 AliasRegistry，因为他是 AliasRegistry 接口的实现类。

第二步：理解 XmlBeanFactory 的继承关系

我们再细看下这个类：XmlBeanFactory 继承了 DefaultListableBeanFactory，DefaultListableBeanFactory 实现了 BeanDefinitionRegistry，BeanDefinitionRegistry 实现了 AliasRegistry，故拥有了注册别名的能力。

让我们看看这个继承关系：

XmlBeanFactory
    extends DefaultListableBeanFactory
        implements BeanDefinitionRegistry
            extends AliasRegistry

🔍 发现二：通过这个继承链，XmlBeanFactory 最终拥有了 AliasRegistry 的能力，可以注册和管理 Bean 的别名。

💡 类比理解：这就像家族遗传，XmlBeanFactory 继承了父辈的能力，最终拥有了处理别名的"基因"。

💡 思考时刻：为什么 Spring 要设计这样的继承关系？为什么不直接在 XmlBeanFactory 中实现 AliasRegistry 接口？

深入探索：SimpleAliasRegistry 的作用

但当我再去看实际注册别名的代码时，又发现了另一个问题：真正做事的是 SimpleAliasRegistry，而这个类和 XmlBeanFactory 的关系又不太好确定。

🔍 发现五：虽然 XmlBeanFactory 通过继承链拥有了 AliasRegistry 的能力，但实际的别名注册逻辑是在 SimpleAliasRegistry 中实现的。

💡 关键理解：SimpleAliasRegistry 是 AliasRegistry 接口的默认实现，它使用 Map<String, String> 来存储别名和 Bean 名称之间的映射关系。

事已至此，我觉得应该把这个类图拿出来了。让我们通过类图来清晰地展示这些类之间的关系：

🔍 发现六：通过类图我们可以清晰地看到：

1. AliasRegistry：定义了别名管理的接口规范
2. SimpleAliasRegistry：提供了别名管理的默认实现，使用 Map 存储别名映射
3. BeanDefinitionRegistry：继承了 AliasRegistry，同时定义了 Bean 定义管理的接口
4. DefaultListableBeanFactory：实现了 BeanDefinitionRegistry，同时继承了 SimpleAliasRegistry，拥有了别名管理的具体实现
5. XmlBeanFactory：继承了 DefaultListableBeanFactory，因此也拥有了别名管理的能力

💡 关键理解：DefaultListableBeanFactory 通过继承 SimpleAliasRegistry，获得了别名管理的具体实现。这样设计的好处是：

• 职责分离：SimpleAliasRegistry 专注于别名管理
• 代码复用：多个类可以复用 SimpleAliasRegistry 的实现
• 灵活扩展：可以轻松替换不同的别名管理实现

第三步：深入理解 SimpleAliasRegistry 的注册逻辑

所以我们重点看 SimpleAliasRegistry 这个就行。

成员变量

public class SimpleAliasRegistry implements AliasRegistry {
    // 存储别名与bean名的关系：key是别名，value是被代表的名字
    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
}

🔍 发现七：

• aliasMap：成员变量存储了别名与被代表名字的关系。注意：这里的 value 不一定是 bean 名，也可能是别名（因为别名可以指向别名）

💡 关键理解：其实我上面说的"bean名"并不一定对，应该是"被代表的名字"，该名字也可能是别名。因为 Spring 支持别名指向别名的情况。

⚠️ 注意：aliasMap 使用 ConcurrentHashMap 实现，保证了线程安全。key 是别名，value 是被代表的名字（可能是 bean 名，也可能是另一个别名）。

注册方法的核心逻辑

再看注册方法 registerAlias(String name, String alias)：

public void registerAlias(String name, String alias) {
    synchronized (this.aliasMap) {
        // 1. 加同步锁，保证多线程仅有一个线程操作aliasMap
        // 2. 判断别名是否与bean名相同，相同则删除已有的别名缓存
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
        } else {
            // 3. 从缓存中查询是否已存在该别名
            String registeredName = this.aliasMap.get(alias);
            if (registeredName != null) {
                // 存在并且bean名相同则结束
                if (registeredName.equals(name)) {
                    return;
                }
                // 存在但bean名不同则判断是否允许别名覆盖
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot register alias '" + alias +
                            "' for name '" + name + "': It is already registered for name '" +
                            registeredName + "'.");
                }
            }
            // 4. 检查是否存在别名循环
            checkForAliasCircle(name, alias);
            // 5. 一切顺利通过，则将别名和被代表的名字放入缓存
            this.aliasMap.put(alias, name);
        }
    }
}

🔍 发现八：注册方法的核心逻辑分为5步：

1. 加同步锁：使用 synchronized (this.aliasMap) 保证多线程环境下仅有一个线程操作 aliasMap，确保线程安全

2. 判断别名是否与被代表的名字相同：如果别名和名字相同，则删除已有的别名缓存（因为不需要别名指向自己）

3. 检查别名是否已存在：

   • 从缓存中查询是否已存在该别名
   • 如果存在并且指向的名字相同，则直接结束（幂等性）
   • 如果存在但指向的名字不同，则判断是否允许别名覆盖（通过 allowAliasOverriding() 方法，这是一个 Spring 配置），不允许则抛异常

4. 检查是否存在别名循环：比如别名"123" → 名字"456"，别名"456"又代表名字"123"。这个判断也采用了递归，可以细品一下这个逻辑。

5. 注册别名：一切顺利通过，则将别名和被代表的名字放入缓存

💡 关键理解：这里的"名字"（name）不一定是 bean 名，也可能是别名。因为 Spring 支持别名指向别名的情况，所以需要递归检查循环引用。

别名循环检测的递归逻辑

让我们看看 checkForAliasCircle 方法是如何检测循环的：

protected void checkForAliasCircle(String name, String alias) {
    if (hasAlias(alias, name)) {
        throw new IllegalStateException("Cannot register alias '" + alias +
                "' for name '" + name + "': Circular reference - '" +
                name + "' is a direct or indirect alias for '" + alias + "' already");
    }
}

public boolean hasAlias(String name, String alias) {
    String registeredName = this.aliasMap.get(name);
    if (registeredName == null) {
        return false;
    }
    if (registeredName.equals(alias)) {
        return true;
    }
    // 递归检查：如果name指向的名字也有别名，继续递归检查
    return hasAlias(registeredName, alias);
}

🔍 发现九：别名循环检测采用了递归算法：

• 如果 name 已经指向了 alias（直接或间接），则抛出异常
• 通过递归调用 hasAlias，可以检测多层的别名循环

💡 类比理解：这就像检查一个链条是否有环。如果 A 指向 B，B 指向 C，C 又指向 A，就形成了一个环。递归检查就是沿着链条一直走下去，如果最终回到了起点，就说明有循环。

💡 思考时刻：为什么需要检测别名循环？如果不检测会有什么问题？

第四步：通知别名注册的监听器

最终，通知别名注册的监听器。

在 registerAlias 方法中，Spring 会通知所有注册的监听器，告知别名已经注册。这允许其他组件（如 Spring 的工具类、扩展点等）在别名注册时执行相应的操作。

🔍 发现三：Spring 通过监听器机制，实现了别名注册的扩展点。当别名注册完成后，所有注册的监听器都会被通知，可以进行相应的处理。

💡 关键理解：这种监听器机制是 Spring 框架中常见的扩展模式，允许其他组件在关键操作发生时得到通知，并执行相应的逻辑。

监听器的默认实现和扩展方式

其实，这监听器也很有意思，默认是 EmptyReaderEventListener，里面都是空方法实现。

如果需要重写，则需要实现 ReaderEventListener 接口，并在初始化 XmlBeanFactory 时，将自定义的实现 set 进去。

// 默认实现：空方法
public class EmptyReaderEventListener implements ReaderEventListener {
    @Override
    public void defaultsRegistered(DefaultsDefinition defaultsDefinition) {
        // 空实现
    }
    
    @Override
    public void componentRegistered(ComponentDefinition componentDefinition) {
        // 空实现
    }
    
    @Override
    public void aliasRegistered(AliasDefinition aliasDefinition) {
        // 空实现
    }
    
    @Override
    public void importProcessed(ImportDefinition importDefinition) {
        // 空实现
    }
}

🔍 发现四：Spring 通过空对象模式（Null Object Pattern），提供了一个默认的监听器实现。这样即使没有自定义监听器，代码也能正常运行，不会出现空指针异常。

💡 扩展方式：如果需要自定义监听器，需要：

1. 实现 ReaderEventListener 接口
2. 在初始化 XmlBeanFactory 时，通过 setEventListener 方法设置自定义实现

💡 思考时刻：对于 ApplicationContext 是更高级的 BeanFactory，他是否提供了更加优雅更加方便的实现方式呢？

💡 类比理解：就像发布订阅模式，当别名注册这个"事件"发生时，所有"订阅"了这个事件的监听器都会收到通知。默认情况下，Spring 提供了一个"空订阅者"（EmptyReaderEventListener），它什么都不做，但保证了系统的正常运行。

---

设计思想

1. 继承链的设计

Spring 通过精心设计的继承链，让 XmlBeanFactory 最终拥有了别名管理的能力：

XmlBeanFactory
    extends DefaultListableBeanFactory
        extends AbstractAutowireCapableBeanFactory
            extends AbstractBeanFactory
                extends FactoryBeanRegistrySupport
                    extends DefaultSingletonBeanRegistry
                        extends SimpleAliasRegistry
                            implements AliasRegistry

🔍 发现：这种设计的好处是：

• 职责分离：每个类都有明确的职责，SimpleAliasRegistry 专注于别名管理
• 代码复用：多个类可以复用 SimpleAliasRegistry 的实现
• 灵活扩展：可以轻松替换不同的别名管理实现

💡 类比理解：这就像搭积木，每一层都有自己的功能，最终搭成了一个完整的"房子"（BeanFactory）。

2. 线程安全设计

SimpleAliasRegistry 使用 synchronized 关键字和 ConcurrentHashMap 来保证线程安全：

• 同步锁：在 registerAlias 方法中使用 synchronized (this.aliasMap) 保证多线程环境下仅有一个线程操作 aliasMap
• 并发集合：使用 ConcurrentHashMap 作为存储结构，提供了更好的并发性能

💡 关键理解：这种设计既保证了线程安全，又兼顾了性能。在高并发场景下，ConcurrentHashMap 的性能比普通的 HashMap 加锁要好。

3. 防御性编程

Spring 在别名注册时进行了多重检查：

1. 空值检查：检查 name 和 alias 是否为空
2. 重复检查：检查别名是否已存在，处理重复注册的情况
3. 循环检测：使用递归算法检测别名循环引用
4. 覆盖控制：通过 allowAliasOverriding() 配置控制是否允许别名覆盖

🔍 发现：这种防御性编程的思想，让 Spring 能够优雅地处理各种边界情况，提高了系统的健壮性。

💡 类比理解：就像过安检，需要检查身份证（空值检查）、检查是否重复进入（重复检查）、检查是否有危险品（循环检测）、检查是否允许进入（覆盖控制）。

4. 递归算法的应用

别名循环检测使用了递归算法，能够检测多层的别名循环：

// 递归检查：如果name指向的名字也有别名，继续递归检查
return hasAlias(registeredName, alias);

🔍 发现：递归算法的优势是能够处理任意深度的别名链，但需要注意避免栈溢出（虽然在实际场景中，别名链的深度通常不会很深）。

💡 关键理解：递归算法在这里非常适合，因为别名链的结构本身就是递归的（别名可以指向别名，形成链式结构）。

5. 空对象模式

Spring 通过 EmptyReaderEventListener 实现了空对象模式（Null Object Pattern），提供了一个默认的监听器实现。这样即使没有自定义监听器，代码也能正常运行，不会出现空指针异常。

💡 类比理解：就像默认的"空订阅者"，它什么都不做，但保证了系统的正常运行。这比使用 null 更安全，避免了空指针异常。

6. 扩展点设计

Spring 通过监听器机制提供了扩展点，允许开发者在别名注册时执行自定义逻辑：

• 默认实现：EmptyReaderEventListener 提供空实现
• 扩展方式：实现 ReaderEventListener 接口，在初始化时设置自定义实现

🔍 发现：这种设计让 Spring 既提供了默认行为，又允许开发者根据需要扩展功能。

---

大白话总结

让我们用大白话再梳理一遍：

1. 这篇文章讲的是什么？

📝 简单说：Spring 如何解析 XML 中的 <alias> 标签，为 Bean 定义别名，以及别名是如何存储和管理的。

💡 类比：就像给一个人起外号，这个人（Bean）有一个正式名字（bean name），但也可以有多个外号（别名）。Spring 需要记住这些外号和正式名字的对应关系。

2. 别名是如何被解析的？

📝 简单说：

1. 解析 XML 标签：Spring 通过 processAliasRegistration 方法解析 <alias> 标签，获取 name 和 alias 属性
2. 验证配置：检查 name 和 alias 是否为空，如果为空则不注册
3. 注册别名：通过上下文中的注册器（实际上是 XmlBeanFactory）注册别名

💡 类比：就像登记外号，需要先看看外号和正式名字是否都填写了，然后才能登记。

3. 别名是如何存储的？

📝 简单说：

• 存储结构：使用 Map<String, String>（实际上是 ConcurrentHashMap）存储别名映射关系
• key 是别名：Map 的 key 是别名
• value 是被代表的名字：Map 的 value 是被代表的名字（可能是 bean 名，也可能是另一个别名）

💡 类比：就像一本"外号字典"，通过外号（key）可以查到对应的正式名字（value）。

4. 注册别名时做了什么检查？

📝 简单说：

1. 同步锁：保证多线程环境下只有一个线程在操作
2. 相同检查：如果别名和名字相同，则删除已有的别名缓存
3. 重复检查：检查别名是否已存在，如果存在且指向的名字相同，则直接结束；如果指向的名字不同，则判断是否允许覆盖
4. 循环检测：使用递归算法检测别名循环（如 A→B，B→A）
5. 注册：一切顺利通过，则将别名和名字放入缓存

💡 类比：就像登记外号时的多重检查：不能重复登记（重复检查）、不能形成循环（循环检测）、需要保证安全（同步锁）。

5. 为什么要检测别名循环？

📝 简单说：如果不检测别名循环，可能会导致无限递归，最终导致栈溢出或死循环。

💡 类比：就像两个人互相给对方起外号，A 的外号是 B，B 的外号是 A，这样就形成了一个循环。如果不检测，查找时就会一直循环下去。

6. 监听器是做什么的？

📝 简单说：监听器是一个扩展点，当别名注册完成时，会通知所有注册的监听器。默认情况下，Spring 提供了一个"空监听器"（EmptyReaderEventListener），它什么都不做，但保证了系统的正常运行。

💡 类比：就像发布订阅模式，当别名注册这个"事件"发生时，所有"订阅"了这个事件的监听器都会收到通知。默认情况下，Spring 提供了一个"空订阅者"，它什么都不做，但保证了系统的正常运行。

---

总结

通过这篇文章，我们深入探索了 Spring 如何读取 XML 中的别名配置：

核心流程

1. 解析 XML 标签：通过 processAliasRegistration 方法解析 <alias> 标签，获取 name 和 alias 属性
2. 验证配置：检查 name 和 alias 是否为空，如果为空则不注册
3. 注册别名：通过上下文中的注册器（XmlBeanFactory）注册别名
4. 实际注册：SimpleAliasRegistry 负责实际的别名注册逻辑
5. 通知监听器：注册完成后，通知所有注册的监听器

关键设计

• 继承链设计：通过精心设计的继承链，让 XmlBeanFactory 最终拥有了别名管理的能力
• 线程安全：使用 synchronized 和 ConcurrentHashMap 保证线程安全
• 防御性编程：进行多重检查（空值检查、重复检查、循环检测、覆盖控制）
• 递归算法：使用递归算法检测别名循环引用
• 空对象模式：通过 EmptyReaderEventListener 实现空对象模式
• 扩展点设计：通过监听器机制提供扩展点

核心数据结构

• aliasMap：ConcurrentHashMap<String, String>，存储别名与被代表名字的映射关系
  • key：别名
  • value：被代表的名字（可能是 bean 名，也可能是另一个别名）

关键方法

• processAliasRegistration(Element ele)：解析 XML 标签，获取配置，调用注册器注册别名
• registerAlias(String name, String alias)：注册别名的核心方法，包含5个步骤的检查
• checkForAliasCircle(String name, String alias)：检查别名循环
• hasAlias(String name, String alias)：递归检查是否存在别名关系

思考题

1. 为什么 Spring 要设计这样的继承链？ 为什么不直接在 XmlBeanFactory 中实现 AliasRegistry 接口？
2. 为什么需要检测别名循环？ 如果不检测会有什么问题？
3. ConcurrentHashMap 和 synchronized 一起使用是否多余？ 为什么 Spring 要这样设计？
4. 递归算法在检测别名循环时，如何避免栈溢出？ 在实际场景中，别名链的深度通常是多少？
5. 对于 ApplicationContext 是更高级的 BeanFactory，他是否提供了更加优雅更加方便的实现方式呢？

---

延伸阅读：

• Spring 源码：AliasRegistry
• Spring 源码：SimpleAliasRegistry
• Spring 源码：BeanDefinitionParserDelegate
• Spring 源码：ReaderEventListener
• Spring 源码：EmptyReaderEventListener
• 上一篇文章：XML命名空间到标签解析