SimpleAliasRegistry主要使用map作为alias的缓存,并对接口AliasRegistry进行实现,具体代码如下:
public class SimpleAliasRegistry implements AliasRegistry {
//aliasMap 用来缓存alias,此处考虑并发情况用ConcurrentHashMap
private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
//为一个bean注册一个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");
//如果别名和bean的名称一样则移除缓存中的别名
//jdk1.8优化此处没有加synchronized同步块
if (alias.equals(name)) {
this.aliasMap.remove(alias);
}
else {
//判断是否允许覆盖
if (!allowAliasOverriding()) {
//获取该别名的映射
String registeredName = this.aliasMap.get(alias);
//如果该映射跟给的映射不一样则抛异常
if (registeredName != null && !registeredName.equals(name)) {
throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
//判断name跟alias是否存在反向映射
checkForAliasCircle(name, alias);
//将别名添加到缓存map中
this.aliasMap.put(alias, name);
}
}
//此方法用来判断别名是否允许被覆盖
protected boolean allowAliasOverriding() {
return true;
}
//删除指定的别名,如果不存在则抛异常
@Override
public void removeAlias(String alias) {
//删除alias指定的别名
String name = this.aliasMap.remove(alias);
//如果对应的映射为空则抛错
if (name == null) {
throw new IllegalStateException("No alias '" + alias + "' registered");
}
}
//判断此别名是否存在或者说此name是否是别名
@Override
public boolean isAlias(String name) {
return this.aliasMap.containsKey(name);
}
//获得该bean的所有别名如果存在的话
@Override
public String[] getAliases(String name) {
List<String> result = new ArrayList<String>();
//此处加同步块
synchronized (this.aliasMap) {
retrieveAliases(name, result);
}
return StringUtils.toStringArray(result);
}
//递归遍历name的别名,并将其放到result集合
private void retrieveAliases(String name, List<String> result) {
for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
String registeredName = entry.getValue();
if (registeredName.equals(name)) {
String alias = entry.getKey();
result.add(alias);
//递归调用
retrieveAliases(alias, result);
}
}
}
//主要存储格式化处理后的name和alias
public void resolveAliases(StringValueResolver valueResolver) {
Assert.notNull(valueResolver, "StringValueResolver must not be null");
synchronized (this.aliasMap) {
Map<String, String> aliasCopy = new HashMap<String, String>(this.aliasMap);
for (String alias : aliasCopy.keySet()) {
String registeredName = aliasCopy.get(alias);
String resolvedAlias = valueResolver.resolveStringValue(alias);
String resolvedName = valueResolver.resolveStringValue(registeredName);
if (resolvedAlias.equals(resolvedName)) {
this.aliasMap.remove(alias);
}
else if (!resolvedAlias.equals(alias)) {
String existingName = this.aliasMap.get(resolvedAlias);
if (existingName != null && !existingName.equals(resolvedName)) {
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);
}
}
}
}
//根据beanName来获取是否存在对应的映射
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;
}
//判断反向映射
protected void checkForAliasCircle(String name, String alias) {
if (alias.equals(canonicalName(name))) {
throw new IllegalStateException("Cannot register alias '" + alias +
"' for name '" + name + "': Circular reference - '" +
name + "' is a direct or indirect alias for '" + alias + "' already");
}
}
}