Spring 水滴石穿(二) 工厂实现之别名注册AliasRegistry
文章目录
AliasRegistry接口
Ioc容器应该提供一种机制来灵活匹配bean实例,spring就提供了别名机制来处理多个name对应同一个bean的情况,或许有的同学会问那用一个map来存储这种情况不就好了干嘛多此一举要弄个别名机制呢?我的思考是一方面在删除一个bean时,需要遍历这个map找到对应的key来删除不够简单,性能也差,另一方面也会导致beanMap过于臃肿,不够简单明了,所以才有了AliasRegistry提供别名注册功能,正如代码
//注册
void registerAlias(String name, String alias);
//移除
void removeAlias(String alias);
//是否时别名
boolean isAlias(String name);
//获得所有别名
String[] getAliases(String name);SimpleAliasRegistry实现
ublic class SimpleAliasRegistry implements AliasRegistry {
/** 采用map存储别名映射关系 */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
@Override
public void registerAlias(String name, String alias) {
//注意ConcurrentHashMap只是单个内部操作安全,这里有复合操作,所以上锁
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)) {
// 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 + "'.");
}
}
//检测循环引用,如果是的话抛出异常
checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
}
}
}
//决定是否可以重写别名
protected boolean allowAliasOverriding() {
return true;
}
//校验是否指定beanName有指定的别名,别名可能是个引用链
public boolean hasAlias(String name, String alias) {
String registeredName = this.aliasMap.get(alias);
return ObjectUtils.nullSafeEquals(registeredName, name) || (registeredName != null
&& hasAlias(name, registeredName));
}
@Override
public void removeAlias(String alias) {
synchronized (this.aliasMap) {
String name = this.aliasMap.remove(alias);
if (name == null) {
throw new IllegalStateException("No alias '" + alias + "' registered");
}
}
}
@Override
public boolean isAlias(String name) {
return this.aliasMap.containsKey(name);
}
@Override
public String[] getAliases(String name) {
List<String> result = new ArrayList<>();
synchronized (this.aliasMap) {
retrieveAliases(name, result);
}
return StringUtils.toStringArray(result);
}
//递归查找指定name的所有alias
private void retrieveAliases(String name, List<String> result) {
this.aliasMap.forEach((alias, registeredName) -> {
if (registeredName.equals(name)) {
result.add(alias);
retrieveAliases(alias, result);
}
});
}
//用指定的解析器解析所有的alias和name信息,暂不关注
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)) {
// 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);
}
});
}
}
//检测循环引用的情况
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");
}
}
//解析别名到真正的bean name
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
这里有几个注意点
1.为何需要循环引用的检测?
设想map中是这样子的A->B B->C C->A,假如你要获取A的真正的bean的name,是否就进入了死循环了?我们必须明白的一点是这个map中既可以存别名与实名的映射,也可以存别名与别名的映射,一个实名的所有别名在这个map中是个引用链。
2.循环引用检测的实现
还是上面的map,就不该存放C->A,它的实现就是要检测C->A是否循环,只需要检测A->C是否存在,又有可能存在间接的A->C引用,所以采用递归方式
3.获取别名的实名
前面说了这个map其实存放的是个引用链,所以要获取真正的实名,还是需要做个循环,从传参一直遍历到这个引用链的尾部去,这也就是canonicalName方法做的事情。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论