明天来和小伙伴们聊一聊 Spring 中对于 Bean 别名的解决逻辑。
1. Alias
别名，顾名思义就是给一个 Bean 去两个甚至多个名字。整体上来说，在 Spring 中，有两种不同的别名定义形式：
- 定义 Bean 的 name 属性，name 属性在真正的处理过程中，实际上就是依照别名来解决的。
- 通过 alias 标签定义专门的别名，通过 alias 定义进去的别名和 name 属性定义的别名最终都是合并在一起解决的，所以这两种定义别名的形式最终是必由之路。
那么定义的别名是保留在哪里呢？
大家晓得，Bean 解析进去之后被保留在容器中，别名其实也是一样的，容器中存在一个 aliasMap 专门用来保留 Bean 的别名，保留的格局是 alias->name，例如有一个 Bean 的名字是 user，别名是 userAlias，那么保留在 aliasMap 中就是 userAlias->user。
举个简略例子：
<bean class="org.javaboy.demo.User" id="user" name="user4,user5,user6"/><alias name="user" alias="user2"/><alias name="user2" alias="user3"/>在下面这段定义中，user2、user3、user4、user5、user6 都是别名。
2. AliasRegistry
2.1 AliasRegistry
Spring 中为别名的解决提供了 AliasRegistry 接口，这个接口中提供了别名解决的次要办法：
public interface AliasRegistry { void registerAlias(String name, String alias); void removeAlias(String alias); boolean isAlias(String name); String[] getAliases(String name);}- registerAlias：这个办法用来增加别名，外围逻辑就是向 aliasMap 中增加数据。
- removeAlias：这个办法用来从 aliasMap 中移除一个别名。
- isAlias：判断给定的 name 是否是一个别名。
- getAliases：依据给定的名字去获取所有的别名。
办法就这四个，看一下这个接口的实现类有哪些。
大家看到，AliasRegistry 的实现类其实还是蛮多的，然而大部分都是容器，真正实现了 AliasRegistry 中四个办法的只有 SimpleAliasRegistry，其余的容器大部分其实都是为了具备别名治理的能力，继承了 SimpleAliasRegistry。
所以真正给咱们整活的其实是 SimpleAliasRegistry。
2.2 SimpleAliasRegistry
SimpleAliasRegistry 类中的内容比拟多，为了解说不便，我就挨个贴属性和办法进去，贴出来后和大家分享。
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);首先，SimpleAliasRegistry 中定义了一个 aliasMap，这个就是用来保留别名的，这是一个 Map 汇合，接下来所有的操作都是围绕这个汇合开展。
@Overridepublic void removeAlias(String alias) { synchronized (this.aliasMap) { String name = this.aliasMap.remove(alias); if (name == null) { throw new IllegalStateException("No alias '" + alias + "' registered"); } }}这个办法用来移除别名，移除的思路很简略，就是从 aliasMap 中移除数据即可，如果 remove 办法返回值为 null 那就阐明要移除的别名不存在，那么间接抛出异样。
@Overridepublic boolean isAlias(String name) { return this.aliasMap.containsKey(name);}这个是判断是否蕴含某一个别名，这个判断简略。有一个跟它容易产生歧义的办法，如下：
public boolean hasAlias(String name, String alias) { String registeredName = this.aliasMap.get(alias); return ObjectUtils.nullSafeEquals(registeredName, name) || (registeredName != null && hasAlias(name, registeredName));}这个办法是判断给定的 name 和 alias 之间是否具备关联关系。判断的逻辑就是先去 aliasMap 中，依据 alias 查出来这个 alias 所对应的实在 beanName，即 registeredName，而后判断 registeredName 和 name 是否相等，如果相等就间接返回，如果不相等就持续递归调用，为什么要递归呢？因为 aliasMap 中存在的别名可能是这样的：
- a->b
- b->c
- c->d
即 a 是 b 的别名，b 是 c 的别名，c 是 d 的别名，当初如果想要判断 a 和 d 之间的关系，那么依据 a 查出来的 b 显然不等于 d，所以要持续递归，再依据 b 查 c，依据 c 查到 d，这样就能确定 a 和 d 是否有关系了。
@Overridepublic String[] getAliases(String name) { List<String> result = new ArrayList<>(); synchronized (this.aliasMap) { retrieveAliases(name, result); } return StringUtils.toStringArray(result);}private void retrieveAliases(String name, List<String> result) { this.aliasMap.forEach((alias, registeredName) -> { if (registeredName.equals(name)) { result.add(alias); retrieveAliases(alias, result); } });}getAliases 办法是依据传入的 name 找到其对应的别名，然而因为别名可能存在多个，所以调用 retrieveAliases 办法递归去查找所有的别名，将找到的别名都存入到一个汇合中，最终将汇合转为数组返回。
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"); }}这个办法用来查看别名是否存在死结，即 a 是 b 的别名，b 是 a 的别名这种状况。查看的形式很简略，就是调用 hasAlias 办法，然而将传入的两个参数颠倒过去就能够了。
public void resolveAliases(StringValueResolver valueResolver) { synchronized (this.aliasMap) { Map<String, String> aliasCopy = new HashMap<>(this.aliasMap); aliasCopy.forEach((alias, registeredName) -> { String resolvedAlias = valueResolver.resolveStringValue(alias); String resolvedName = valueResolver.resolveStringValue(registeredName); if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) { this.aliasMap.remove(alias); } else if (!resolvedAlias.equals(alias)) { String existingName = this.aliasMap.get(resolvedAlias); if (existingName != null) { if (existingName.equals(resolvedName)) { this.aliasMap.remove(alias); return; } throw new IllegalStateException( "Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias + "') for name '" + resolvedName + "': It is already registered for name '" + registeredName + "'."); } checkForAliasCircle(resolvedName, resolvedAlias); this.aliasMap.remove(alias); this.aliasMap.put(resolvedAlias, resolvedName); } else if (!registeredName.equals(resolvedName)) { this.aliasMap.put(alias, resolvedName); } }); }}这个办法是解决别名是占位符的状况，例如当引入了一个 .properties 文件之后，那么在配置别名的时候就能够援用 .properties 中的变量，那么下面这个办法就是用来解析变量的。
例如上面这种状况，我有一个 alias.properties，如下：
name=useralias=javaboy而后在 XML 文件中应用这个 properties 文件，如下：
<context:property-placeholder location="classpath:alias.properties"/><alias name="${name}" alias="${alias}"/>对于这种状况，一开始存入到 aliasMap 中的就是占位符了，resolveAliases 办法就是要将这些占位符解析为具体的字符串。
大家看到，首先这里将 aliasMap 复制一份，生成一个 aliasCopy，而后进行遍历。在遍历时，依据 valueResolver 将援用应用的占位符解析为真正的字符，如果解析进去的。如果解析进去的 name 和别名是雷同的，那么显然是有问题的，就须要把这个别名移除掉。
持续判断，如果解析进去的别名和本来的别名不相等（阐明别名应用了占位符），那么就去检查一下这个别名对应的 name，如果这个 name 曾经存在，且等于占位符解析进去的 name，阐明这个别名曾经被定义过了，即反复定义，那么就把别名移除掉即可。如果这个别名指向的 name 和占位符解析进去的 name 不相等，阐明试图让一个别名指向两个 bean，那么就间接抛出异样了。
如果解析进去的别名还没有指向 name 属性的话，那么就失常解决，查看是否存在死结、移除带占位符的别名，存入解析之后的别名。
最初，如果本来的名称和解析之后的属性名称不相等，那么就间接保留这个别名即可。
@Overridepublic void registerAlias(String name, String alias) { synchronized (this.aliasMap) { if (alias.equals(name)) { this.aliasMap.remove(alias); } else { String registeredName = this.aliasMap.get(alias); if (registeredName != null) { if (registeredName.equals(name)) { return; } if (!allowAliasOverriding()) { throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" + name + "': It is already registered for name '" + registeredName + "'."); } } checkForAliasCircle(name, alias); this.aliasMap.put(alias, name); } }}这个就是应用最多的别名注册了，传入的参数别离是 bean 的 name 和 alias，如果 alias 跟 name 相等，二话不说间接移除，这个 alias 有问题。
否则就去查问这个 alias，查看这个 alias 是否曾经有对应的 name 了，如果有，且等于传入的 name，那么间接返回就行了，不必注册，因为曾经注册过了；如果有且不等于传入的 name，那么就抛出异样，因为一个 alias 不能指向两个 name。最初就是检查和保留了。
public String canonicalName(String name) { String canonicalName = name; String resolvedName; do { resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName;}这个办法用来解析进去别名里边顶格的名字，例如有一个 bean 有很多别名，a->b,b->c,c->d，那么这个办法的目标就是传入 a、b、c 中任意一个，返回 d 即可。因为 Spring 容器在解决的时候，并不必管这么多别名问题，容器只须要专一一个名字即可，因为最初一个别名实际上就是指向实在的 beanId 了，所以最终拿到的 bean 名称其实相当于 bean 的 ID 了。
别名的解决次要就是这些办法。
3. 原理剖析
后面咱们说了，别名的起源次要是两个中央：name 属性和 alias 标签，咱们别离来看。
3.1 name 解决
对于 name 属性的解决，有两个中央，一个是在 bean 定义解析的时候，将 name 属性解析为 alias，具体在 BeanDefinitionParserDelegate#parseBeanDefinitionElement 办法中（这个办法在之前跟大家讲 bean 的默认名称生成策略的时候，见过）：
@Nullablepublic BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { String id = ele.getAttribute(ID_ATTRIBUTE); String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); List<String> aliases = new ArrayList<>(); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } //省略其余}能够看到，这里就从 XML 节点中提取进去 name 属性，而后切分为一个数组，并将之存入到 aliases 属性中。接下来在后续的 BeanDefinitionReaderUtils#registerBeanDefinition 办法中，再把 aliases 中的值注册一下，如下：
public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { String beanName = definitionHolder.getBeanName(); registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String alias : aliases) { registry.registerAlias(beanName, alias); } }}这就是 XML 中的 name 属性是如何变为别名的。
3.2 别名标签解决
别名的另一个起源是别名标签，在 Spring 解析 XML 标签的时候，有针对别名标签的专门解决，具体位置是在 DefaultBeanDefinitionDocumentReader#parseDefaultElement 办法中：
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele); }}这里会去判断标签的类型，如果是别名，就调用 processAliasRegistration 办法进行解决：
protected void processAliasRegistration(Element ele) { 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); } getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); }}能够看到，这里也是从 XML 文件中的别名标签上，提取进去 name 和 alias 属性值，最初调用 registerAlias 办法进行注册。
好啦，这就是 Spring 中对于别名的解决流程啦～