【小家Spring】分享Spring中一个小巧而优雅的类SimpleAliasRegistry源码分析(别名注册、管理器)(上)

简介: 【小家Spring】分享Spring中一个小巧而优雅的类SimpleAliasRegistry源码分析(别名注册、管理器)(上)

前言


上一篇分享了:【小家Spring】一文读懂Spring中的BeanFactory和FactoryBean的区别。为了缓解疲劳,本文来个小插曲~~不用费太多脑力的


Spring是一个非常优秀且流行的框架,里面不乏有很多优秀的设计模式、设计思想。


本文主要针对其中一个非常小巧的类:SimpleAliasRegistry做一个源码解读。顺便也分享给大家,若有分析得不到位的地方,非常欢迎指正,毕竟我也是第一次看。


分析此类的源码是因为此类很具有代表性,可以部分代表Spring的代码功底,优雅~~~因为群里有好几次提到过说此类虽然很小巧,但是代码设计得很优雅


初识


首先看到,这个类实现了接口AliasRegistry,而这个接口顾名思义:它就是别名管理器。Spring提供了一个默认实现:SimpleAliasRegistry。内部会缓存这些别名和真实名称的对应关系


在Spring环境下,我们很容易的为一个Bean定义一个或者多个别名:

 <bean id="app:dataSource" class="...">
    <alias name="app:dataSoure" alias="user:dataSoure"/>
    <alias name="app:dataSoure" alias="device:dataSoure"/>
  </bean>
或者:
直接使用bean标签的name属性,就是别名
<bean id="aaa",name="bbb,ccc,ddd"/>


到这个时候,可能很多人就会问了,当前都SpringBoot环境了,哪还会用到xml了啊,所以别名这个在Boot这就不会再用了。


其实不然,SpringBoot中我们配置一个Bean一般会这么来写:


@Configuration
public class ApplicationConfig {
    @Bean
    public Object object() {
        return new Object();
    }
}


这个时候我打断点,发现还真的没有注册别名。而@Bean注解里也并没有alias等相关属性,是不是Boot就真的不支持了呢?


其实,只支持的。@Bean虽然没有alias属性,但是它的名称可以是数组,可以写多个名称,而经过我实现发现。当只写一个值的时候,只有名称没有别名。但是当你写多个值的时候,除了第一个是名称,后面的全都是别名。

    @Bean(value = {"aaa", "bbb", "ccc"})
    public Object object() {
        return new Object();
    }


断点启动:


image.png


image.png


证实了我上面的结论。虽然别名我们用得挺少,特别是在当下的Boot环境了。但是强大的Spring还是支持的。


当然这并不是本文讨论的重点,重点还是看“优雅的”代码:


public interface AliasRegistry {
  //增  给name新增一个别名alias
  void registerAlias(String name, String alias);
  //删  删除一个别名
  void removeAlias(String alias);
  //此name是否含有别名
  boolean isAlias(String name);
  //获取此name对应的所有的别名
  String[] getAliases(String name);
}


它的实现类有不少,此处我们只看SimpleAliasRegistry :


public class SimpleAliasRegistry implements AliasRegistry {
  /** 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;
  }
  @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);
  }
  /**
   * 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);
      }
    });
  }
  /**
   * 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);
        }
      });
    }
  }
  /**
   * 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");
    }
  }
  /**
   * 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;
  }
}

本文就是重点分析此类,代码行数若除去注释,100行左右,但是里面的写法确实是有不少可圈可点的地方。

相关文章
|
存储 Java 数据库
Spring Boot 注册登录系统:问题总结与优化实践
在Spring Boot开发中,注册登录模块常面临数据库设计、密码加密、权限配置及用户体验等问题。本文以便利店销售系统为例,详细解析四大类问题:数据库字段约束(如默认值缺失)、密码加密(明文存储风险)、Spring Security配置(路径权限不当)以及表单交互(数据丢失与提示不足)。通过优化数据库结构、引入BCrypt加密、完善安全配置和改进用户交互,提供了一套全面的解决方案,助力开发者构建更 robust 的系统。
636 0
|
监控 Java 应用服务中间件
Spring Boot整合Tomcat底层源码分析
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置和起步依赖等特性,大大简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是其与Tomcat的整合。
565 1
|
Java Spring
【Spring】方法注解@Bean,配置类扫描路径
@Bean方法注解,如何在同一个类下面定义多个Bean对象,配置扫描路径
859 73
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
本文详细介绍了Spring框架的核心功能,并通过手写自定义Spring框架的方式,深入理解了Spring的IOC(控制反转)和DI(依赖注入)功能,并且学会实际运用设计模式到真实开发中。
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
|
监控 Java 应用服务中间件
SpringBoot是如何简化Spring开发的,以及SpringBoot的特性以及源码分析
Spring Boot 通过简化配置、自动配置和嵌入式服务器等特性,大大简化了 Spring 应用的开发过程。它通过提供一系列 `starter` 依赖和开箱即用的默认配置,使开发者能够更专注于业务逻辑而非繁琐的配置。Spring Boot 的自动配置机制和强大的 Actuator 功能进一步提升了开发效率和应用的可维护性。通过对其源码的分析,可以更深入地理解其内部工作机制,从而更好地利用其特性进行开发。
755 6
|
前端开发 IDE Java
Spring MVC 中因导入错误的 Model 类报错问题解析
在 Spring MVC 或 Spring Boot 开发中,若导入错误的 `Model` 类(如 `ch.qos.logback.core.model.Model`),会导致无法解析 `addAttribute` 方法的错误。正确类应为 `org.springframework.ui.Model`。此问题通常因 IDE 自动导入错误类引起。解决方法包括:删除错误导入、添加正确包路径、验证依赖及清理缓存。确保代码中正确使用 Spring 提供的 `Model` 接口以实现前后端数据传递。
688 0
|
Java Spring
【Spring配置相关】启动类为Current File,如何更改
问题场景:当我们切换类的界面的时候,重新启动的按钮是灰色的,不能使用,并且只有一个Current File 项目,下面介绍两种方法来解决这个问题。
495 10
|
前端开发 Java Spring
Spring MVC源码分析之DispatcherServlet#getHandlerAdapter方法
`DispatcherServlet`的 `getHandlerAdapter`方法是Spring MVC处理请求的核心部分之一。它通过遍历预定义的 `HandlerAdapter`列表,找到适用于当前处理器的适配器,并调用适配器执行具体的处理逻辑。理解这个方法有助于深入了解Spring MVC的工作机制和扩展点。
273 1
|
前端开发 Java Spring
Spring MVC源码分析之DispatcherServlet#getHandlerAdapter方法
`DispatcherServlet`的 `getHandlerAdapter`方法是Spring MVC处理请求的核心部分之一。它通过遍历预定义的 `HandlerAdapter`列表,找到适用于当前处理器的适配器,并调用适配器执行具体的处理逻辑。理解这个方法有助于深入了解Spring MVC的工作机制和扩展点。
334 1
|
前端开发 Java Spring
Spring MVC源码分析之DispatcherServlet#getHandlerAdapter方法
`DispatcherServlet`的 `getHandlerAdapter`方法是Spring MVC处理请求的核心部分之一。它通过遍历预定义的 `HandlerAdapter`列表,找到适用于当前处理器的适配器,并调用适配器执行具体的处理逻辑。理解这个方法有助于深入了解Spring MVC的工作机制和扩展点。
282 0