Alias
Spring一般可以通过BeanName和Bean的type来获取bean。根据BeanName其实是根据name和alias获取bean。Bean的name和alias是根据我们配置决定的，主要是跟id和name这两个属性有关系。name和alias的逻辑：
- 假如配置了id，BeanName就是id。
- 如果只配置了name，那BeaName就是配置的name。
- 如果同时配置了id，那BeanName就是id，而配置的name就是Aliase。
- 如果配置了多个name，会取首个name作为BeanName,其他是Aliase
- 如果都没配的话就是
appcontext.(全限定类名)#0。
我们在获取spring的bean的时候，对于getBean(String name)这个方法，参数name既可以是name也可以是alias。
AliasRegistry:
public interface AliasRegistry {
void registerAlias(String name, String alias);
void removeAlias(String alias);
boolean isAlias(String name);
String[] getAliases(String name);
}
AliasRegistry提供了管理访问别名的方法。
register alias:
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) {
// name == alias,相当于要注册的alias其实就是name
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)) {
return;
}
//要改alias的name，如果allowAliasOverriding是false（默认true）就抛异常
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 + "'");
}
}
//检查循环
checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
if (logger.isTraceEnabled()) {
logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
}
}
}
}
aliasMap存放了alias -> name的映射。可以看出来要用alias找name是比较方便的，但是要从name找alias就需遍历整个map。
alias循环映射：
从上面源码看，在把alias注册的最后一步需要检查alias循环，那什么是alias循环呢？
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");
}
}
我们可以发现hasAlias的参数是name、alias，而checkForAliasCircle调用hasAlias的时候传的是alias、name，把两个参数调换着传。我们在看hasAlias的源码之前，可以简单推断，如果hasAlias的结果是true的话,其实就是说已经存在了name -> alias的情况，如果我们再注册一个 alias -> name ，那就出现了循环的情况，这个时候会抛出异常，也就是alias循环是不被允许的。
alias传递映射:
public boolean hasAlias(String name, String alias) {
for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
String registeredName = entry.getValue();
if (registeredName.equals(name)) {
String registeredAlias = entry.getKey();
if (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias)) {
return true;
}
}
}
return false;
}
registeredAlias.equals(alias) || hasAlias(registeredAlias, alias) 通过这句,我们发现 hasAlias除了 alias 直接指向 name 的情况(registeredAlias.equals(alias))。还有间接指向的情况(hasAlias(registeredAlias, alias))
举个例子：
假如hasAlias的参数是 name:C, alias:A
那假如注册过 A -> C, 那返回结果肯定是true。
而对于另外一种传递引用的也会是true。 比如注册过： A -> B,B -> C。代码首先找到了C的直接alias B,但是发现B并不等于A，那就会递归去找B的Alias有没有A。这个时候就可以找到A，那结果就是true。
所以对于前面判断循环就不只有直接的互相指向才算是循环(A->B,B->A)，间接互相指向也算是循环(A->B,B->C,C->A)。
根据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;
}
方法比较简单，就是要处理一下传递映射的问题。
假如传入的参数name是A：
对于直接只有 A->B 这样的映射，那结果就是B。
对于有传递映射比如： A->B, B->C的情况。结果就是C。
从这个逻辑也可以看出来为什么alias不允许循环映射。
获取name的所有alias：
@Override
public 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);
}
});
}
因为传递映射的关系，所以alias的关系有可能会形成树状结构，所以这里的代码就跟递归遍历树差不多。
resolveAliases ：
public void resolveAliases(StringValueResolver valueResolver) {
Assert.notNull(valueResolver, "StringValueResolver must not be null");
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)) {
// Pointing to existing alias - just remove placeholder
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);
}
});
}
}
待续。。。
