本文深入剖析Spring框架中的SimpleAliasRegistry类，详细解读其如何管理bean的别名，包括注册、删除、查询及解析等核心功能。同时，文章探讨了SimpleAliasRegistry在处理循环引用和别名覆盖时的机制。
从今天开始,我们将沿着DefaultListableBeanFactory的继承线,从上往下梳理他们的实现,如果有不清楚DefaultListableBeanFactory继承线的,可以参考《Spring5源码浅析(五)—DefaultListableBeanFactory之总览》.首先来看一下继承线的顶部SimpleAliasRegistry的源码,SimpleAliasRegistry是AliasRegistry的实现类.而AliasRegistry主要是用来管理别名的,它只提供了四个简单的函数:registerAlias(String name,String alias),removeAlias(String alias),isAlias(String name),getAliases(String name).因此我们会重点探讨这四个函数.
首先是第一个registerAlias(String name,String alias),这个函数主要用于别名注册,源码如下所示:
/** Logger available to subclasses. */
protected final Log logger = LogFactory.getLog(getClass());
/** Map from alias to canonical name. */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
@Override
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) {
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)) {
// 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 + "'.");
}
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 + "'");
}
}
}
}
/**
* Return whether alias overriding is allowed.
* Default is {@code true}.
*/
protected boolean allowAliasOverriding() {
return true;
}
/**
* Determine whether the given name has the given alias registered.
* @param name the name to check
* @param alias the alias to look for
* @since 4.2.1
*/
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;
}
/**
* Check whether the given name points back to the given alias as an alias
* in the other direction already, catching a circular reference upfront
* and throwing a corresponding IllegalStateException.
* @param name the candidate name
* @param alias the candidate alias
* @see #registerAlias
* @see #hasAlias
*/
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名称和alias的别名对应是放在map集合中的,其次这里使用的是支持多线程访问的ConcurrentHashMap<>(),然后它又使用了synchronized锁住了具体操作的代码,保证代码块不会被多个线程同时执行.具体的执行中,如果这个bean已经注册过了,就会直接返回,如果这个别名被其他的bean使用了,那么就会依据是否允许覆盖(默认为允许)的配置来进行覆盖或是直接抛出异常的操作.其次他会去检查,看该别名是否会引起循环引用的情况,如果有循环引用就抛出异常.如果没有就正常的往aliasMap中以别名alias为key,bean的名称name为value进行注册.
在判断循环引用的时候,他调用的是hasAlias,只不过传参的时候,是将当前bean的别名作为了bean的名称,而将bean的名称作为了Bean的别名传入到了hasAlias中.而hasAlias则进行了两轮判断,首先检查当前bean的别名是否曾被作为Bean的名称注册过,如果有,就获取那个Bean的别名看是否与当前Bean的名字相同,如果相同则判断为循环调用.其次,会依次以迭代的方式检查集合中的别名是否曾被作为Bean的名称注册过,如果有,就获取那个Bean的名字,看是否与当前Bean的名称相同,如果相同,则判断为循环引用.
第二个函数和第三个函数是removeAlias(String alias)和isAlias(String),这是用来删除别名以及判断别名是否存在的,这两个函数比较容易理解,而removeAlias则只是用了同步锁来保证aliasMap不会被其他的线程来进行编辑操作,源码如下所示:
@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);
}最后一个函数是getAlias(String name),这个函数主要是获取指定Bean的所有别名,源码如下所示:
@Override
public String[] getAliases(String name) {
List<String> result = new ArrayList<>();
synchronized (this.aliasMap) {
retrieveAliases(name, result);
}
return StringUtils.toStringArray(result);
}
/**
* Transitively retrieve all aliases for the given name.
* @param name the target name to find aliases for
* @param result the resulting aliases list
*/
private void retrieveAliases(String name, List<String> result) {
this.aliasMap.forEach((alias, registeredName) -> {
if (registeredName.equals(name)) {
result.add(alias);
retrieveAliases(alias, result);
}
});
}通过这个函数,我们可以看到他除了能获取当前bean的所有别名之外,它还能够获取到Bean名称等于当前Bean别名的那些Bean的别名,并会层层进行迭代.
这个实现类除了实现了AliasRegistry接口的功能之外,还提供了别名的解析这个函数,也就是resolveAliases(StringValueResolver valueResolver).在《Spring5源码浅析(三)—ConfigurableBeanFactory》这篇中,ConfigurableBeanFactory就有这个接口的声明,我们正好可以参考一下SimpleAliasRegistry这个类给我们提供的resolveAliases实现.源码如下所示:
/**
* Resolve all alias target names and aliases registered in this
* factory, applying the given StringValueResolver to them.
* <p>The value resolver may for example resolve placeholders
* in target bean names and even in alias names.
* @param valueResolver the StringValueResolver to apply
*/
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);
}
});
}
}这里呢,首先需要对他的参数StringValueResolver做一个解释,这个接口是Spring从2.5版本就开始提供的,主要是提供一个String值的解析策略.这是一个函数式接口,因此它是支持Lambda表达式的.在这个函数里,主要考虑的是用这个解析器来解析Bean的别名.
在resolveAliases这个函数中,做的第一件事儿是如果当前Bean的名字或者他的别名不符合解析器的规则,就将这个Bean的注册条目从注册集合(aliasMap)中删除.当然如果解析后的Bean的名字和别名相同的话,也会执行删除操作.
其次,如果当前注册条目(条目1)解析后的别名和当前条目的别名不同,那么它会判断解析后的别名是否已注册过,如果已注册过(条目2)且以解析后的别名注册的那个Bean的名字(条目2)和当前注册条目的Bean的名字(条目1)相同,则移除.如果不相同,则抛出异常说解析后的别名无法注册,因为解析后的别名已被注册过了.如果解析后的别名没有被注册过,它首先会检查解析后的别名与Bean名称是否存在循环引用,然后他首先会将原别名对应的注册条目删除,并在注册集合(aliasMap)中替换为解析后的别名,以及对应的解析后的bean名称.
最后,如果解析后的别名与当前注册条目的别名相同,且Bean的名称不同,那就将原有的Bean名称替换为解析后的Bean名称(这有可能是一个覆盖操作,因为原来的Bean名称与解析后的Bean名称可能对应的不是同一个Bean.)
这个接口还提供了一个函数,是用来检索给定别名的最原生的Bean名称的函数,其实现源码如下所示:
/**
* Determine the raw name, resolving aliases to canonical names.
* @param name the user-specified name
* @return the transformed 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;
}这个函数首先依据给定的别名,去寻找Bean对应的名字,然后再以Bean名字作为别名去寻找,一直寻找到别名对应的Bean名字为空,就证明当前别名是最原生的Bean名字.
到此,我们已经将SimpleAliasRegistry已经分析完了,除了它本身的一些功能之外,还有一些额外的东西.比如,在这里Spring使用断言机制来取代以往的if条件判断,这是一个比较新颖的用法,可以值得我们尝试。其次,是关于日志输出问题,它多加了一个日志级别的判断,从而能够更好地控制日志代码的灵活性。然后,它在处理集合的时候,使用了对原生集合的复制,然后再去进行处理,这非常地值得借鉴。最后,他还把一些可能会更改的逻辑适时地使用了protected的修饰符,这也是值得我们去考虑的.
好了,今天的分享内容就到这里,如果大家在看这篇博文的时候，发现有什么问题或者有什么建议,大家可以通过评论的方式或者发邮件(Jacob_earl@163.com)给我。下次我们来分享DefaultSingletonBeanRegistry这个SimpleAliasRegistry的子类.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
