Spring-SimpleAliasRegistry

AliasRegistry

  • SimpleAliasRegistry继承org.springframework.core.AliasRegistry
  1. public interface AliasRegistry {
  3.     /**
  4.      * Given a name, register an alias for it.
  5.      * 别名注册
  6.      *
  7.      * @param name  the canonical name
  8.      * @param alias the alias to be registered
  9.      * @throws IllegalStateException if the alias is already in use
  10.      *                               and may not be overridden
  11.      * @see SimpleAliasRegistry
  12.      * @see org.springframework.context.support.GenericApplicationContext
  13.      */
  14.     void registerAlias(String name, String alias);
  16.     /**
  17.      * Remove the specified alias from this registry.
  18.      * 别名移除
  19.      *
  20.      * @param alias the alias to remove
  21.      * @throws IllegalStateException if no such alias was found
  22.      */
  23.     void removeAlias(String alias);
  25.     /**
  26.      * Determine whether this given name is defines as an alias
  27.      * (as opposed to the name of an actually registered component).
  28.      * 是不是别名
  29.      *
  30.      * @param name the name to check
  31.      * @return whether the given name is an alias
  32.      */
  33.     boolean isAlias(String name);
  35.     /**
  36.      * Return the aliases for the given name, if defined.
  37.      * 从别名注册map中获取别名信息
  38.      *
  39.      * @param name the name to check for aliases
  40.      * @return the aliases, or an empty array if none
  41.      */
  42.     String[] getAliases(String name);
  44. }

SimpleAliasRegistry

  1. /**
  2.  * Simple implementation of the {@link AliasRegistry} interface.
  3.  * Serves as base class for
  4.  * {@link org.springframework.beans.factory.support.BeanDefinitionRegistry}
  5.  * implementations.
  6.  *
  7.  * @author Juergen Hoeller
  8.  * @since 2.5.2
  9.  */
  10. public class SimpleAliasRegistry implements AliasRegistry {
  12.     /**
  13.      * Logger available to subclasses.
  14.      */
  15.     protected final Log logger = LogFactory.getLog(getClass());
  17.     /**
  18.      * Map from alias to canonical name.
  19.      * 存放别名的map(线程安全的),
  20.      * 结构: alias-> name
  21.      */
  22.     private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
  25.     /**
  26.      * {@code <alias name="appleBean" alias="hhh"/>}
  27.      *
  28.      * @param name  the canonical name
  29.      *              alias 标签的name属性
  30.      * @param alias the alias to be registered
  31.      *              alias 标签的alias属性
  32.      */
  33.     @Override
  34.     public void registerAlias(String name, String alias) {
  35.         Assert.hasText(name, "'name' must not be empty");
  36.         Assert.hasText(alias, "'alias' must not be empty");
  37.         synchronized (this.aliasMap) {
  38.             // 判断: 别名和名字是否相同
  39.             if (alias.equals(name)) {
  40.                 //相同在别名map中移除
  41.                 this.aliasMap.remove(alias);
  42.                 if (logger.isDebugEnabled()) {
  43.                     logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
  44.                 }
  45.             }
  46.             else {
  47.                 // 不相同
  48.                 // 从map对象中获取别名为alias的value
  49.                 String registeredName = this.aliasMap.get(alias);
  50.                 if (registeredName != null) {
  51.                     // 判断map中是否有有一个别名和传入的name相同的内容
  52.                     if (registeredName.equals(name)) {
  53.                         // An existing alias - no need to re-register
  54.                         return;
  55.                     }
  56.                     if (!allowAliasOverriding()) {
  57.                         throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
  58.                                 name + "': It is already registered for name '" + registeredName + "'.");
  59.                     }
  60.                     if (logger.isDebugEnabled()) {
  61.                         logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
  62.                                 registeredName + "' with new target name '" + name + "'");
  63.                     }
  64.                 }
  65.                 // 别名环检查
  66.                 checkForAliasCircle(name, alias);
  67.                 // 放入 map 对象中 alias-> name
  68.                 this.aliasMap.put(alias, name);
  69.                 if (logger.isTraceEnabled()) {
  70.                     logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
  71.                 }
  72.             }
  73.         }
  74.     }
  76.     /**
  77.      * Return whether alias overriding is allowed.
  78.      * Default is {@code true}.
  79.      * 是否允许重写别名
  80.      */
  81.     protected boolean allowAliasOverriding() {
  82.         return true;
  83.     }
  85.     /**
  86.      * Determine whether the given name has the given alias registered.
  87.      * <p>
  88.      * 递归判断是否已经存在别名
  89.      *
  90.      * @param name  the name to check
  91.      * @param alias the alias to look for
  92.      * @since 4.2.1
  93.      */
  94.     public boolean hasAlias(String name, String alias) {
  95.         for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
  96.             // 获取key值
  97.             String registeredName = entry.getValue();
  98.             if (registeredName.equals(name)) {
  99.                 String registeredAlias = entry.getKey();
  100.                 // 循环引用判断
  101.                 if (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias)) {
  102.                     return true;
  103.                 }
  104.             }
  105.         }
  106.         return false;
  107.     }
  109.     /**
  110.      * 别名移除
  111.      *
  112.      * @param alias the alias to remove
  113.      */
  114.     @Override
  115.     public void removeAlias(String alias) {
  116.         synchronized (this.aliasMap) {
  117.             // 判断是否移除成功
  118.             String name = this.aliasMap.remove(alias);
  119.             if (name == null) {
  120.                 throw new IllegalStateException("No alias '" + alias + "' registered");
  121.             }
  122.         }
  123.     }
  125.     /**
  126.      * 判断是否是一个别名,校验方式{@link org.springframework.core.SimpleAliasRegistry#aliasMap} 的key是否包含
  127.      *
  128.      * @param name the name to check
  129.      * @return
  130.      */
  131.     @Override
  132.     public boolean isAlias(String name) {
  133.         return this.aliasMap.containsKey(name);
  134.     }
  136.     /**
  137.      * 获取别名列表
  138.      *
  139.      * @param name the name to check for aliases
  140.      * @return
  141.      */
  142.     @Override
  143.     public String[] getAliases(String name) {
  144.         List<String> result = new ArrayList<>();
  145.         synchronized (this.aliasMap) {
  146.             retrieveAliases(name, result);
  147.         }
  148.         return StringUtils.toStringArray(result);
  149.     }
  151.     /**
  152.      * Transitively retrieve all aliases for the given name.
  153.      * 根据 name 获取别名
  154.      *
  155.      * @param name   the target name to find aliases for
  156.      * @param result the resulting aliases list
  157.      */
  158.     private void retrieveAliases(String name, List<String> result) {
  159.         // 循环获取
  160.         this.aliasMap.forEach((alias, registeredName) -> {
  161.             if (registeredName.equals(name)) {
  162.                 result.add(alias);
  163.                 // 递归查询循环引用的别名
  164.                 retrieveAliases(alias, result);
  165.             }
  166.         });
  167.     }
  169.     /**
  170.      * Resolve all alias target names and aliases registered in this
  171.      * factory, applying the given StringValueResolver to them.
  172.      * <p>The value resolver may for example resolve placeholders
  173.      * in target bean names and even in alias names.
  174.      *
  175.      * @param valueResolver the StringValueResolver to apply
  176.      */
  177.     public void resolveAliases(StringValueResolver valueResolver) {
  178.         Assert.notNull(valueResolver, "StringValueResolver must not be null");
  179.         synchronized (this.aliasMap) {
  180.             Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
  181.             aliasCopy.forEach((alias, registeredName) -> {
  182.                 String resolvedAlias = valueResolver.resolveStringValue(alias);
  183.                 String resolvedName = valueResolver.resolveStringValue(registeredName);
  184.                 if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
  185.                     this.aliasMap.remove(alias);
  186.                 }
  187.                 else if (!resolvedAlias.equals(alias)) {
  188.                     String existingName = this.aliasMap.get(resolvedAlias);
  189.                     if (existingName != null) {
  190.                         if (existingName.equals(resolvedName)) {
  191.                             // Pointing to existing alias - just remove placeholder
  192.                             this.aliasMap.remove(alias);
  193.                             return;
  194.                         }
  195.                         throw new IllegalStateException(
  196.                                 "Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias +
  197.                                         "') for name '" + resolvedName + "': It is already registered for name '" +
  198.                                         registeredName + "'.");
  199.                     }
  200.                     checkForAliasCircle(resolvedName, resolvedAlias);
  201.                     this.aliasMap.remove(alias);
  202.                     this.aliasMap.put(resolvedAlias, resolvedName);
  203.                 }
  204.                 else if (!registeredName.equals(resolvedName)) {
  205.                     this.aliasMap.put(alias, resolvedName);
  206.                 }
  207.             });
  208.         }
  209.     }
  211.     /**
  212.      * Check whether the given name points back to the given alias as an alias
  213.      * in the other direction already, catching a circular reference upfront
  214.      * and throwing a corresponding IllegalStateException.
  215.      * <p>
  216.      * 判断是否循环别名
  217.      *
  218.      * @param name  the candidate name
  219.      * @param alias the candidate alias
  220.      * @see #registerAlias
  221.      * @see #hasAlias
  222.      */
  223.     protected void checkForAliasCircle(String name, String alias) {
  224.         if (hasAlias(alias, name)) {
  225.             throw new IllegalStateException("Cannot register alias '" + alias +
  226.                     "' for name '" + name + "': Circular reference - '" +
  227.                     name + "' is a direct or indirect alias for '" + alias + "' already");
  228.         }
  229.     }
  231.     /**
  232.      * Determine the raw name, resolving aliases to canonical names.
  233.      *
  234.      * @param name the user-specified name
  235.      * @return the transformed name
  236.      */
  237.     public String canonicalName(String name) {
  238.         String canonicalName = name;
  239.         // Handle aliasing...
  240.         String resolvedName;
  241.         do {
  242.             resolvedName = this.aliasMap.get(canonicalName);
  243.             if (resolvedName != null) {
  244.                 canonicalName = resolvedName;
  245.             }
  246.         }
  247.         while (resolvedName != null);
  248.         return canonicalName;
  249.     }
  251. }