DefaultListBeanFactory的子類之SimpleAliasRegistry

DefaultListBeanFactory類結構層次圖

從繼承圖看，SimpleAliasRegistry是DefaultListBeanFactory繼承類中最底層的實現類。

SimpleAliasRegistry

GitHub:
SimpleAliasRegistry.java
SimpleAliasRegistryTests.java

SimpleAliasRegistry藉助ConcurrentHashMap來作別名的存儲，用KEY 存儲別名alias，用VALUE 存儲別名對應的真名或者別名

1.registerAlias(String name, String 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");
        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)) {
                        // 已經存在的別名 - 不須要再次註冊，Map中已經有alias->registeredName了且registeredName等於name
                        return;
                    }
                    // 比方說Map中有alias->registeredName了
                    // 你如今卻要求改成alias->name
                    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 + "'");
                    }
                }
                // 若是說Map中已經存在name->alias，
                // 那麼如今alias->name就是循環引用了
                // 會拋出異常
                checkForAliasCircle(name, alias);
                this.aliasMap.put(alias, name);
                if (logger.isTraceEnabled()) {
                    logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
                }
            }
        }
    }

checkForAliasCircle(String name, String alias)

檢查是否是已經存在name->alias，卻還要註冊alias->name，這種循環可能會使得其餘遞歸的方法無限循環下去

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");
    }
}

2.hasAlias(String name, String alias)

雖然這不 是接口AliasRegistry的方法,但確是SimpleAliasRegister判斷name是否包含別名alias的重要方法。採起的方法是先找Map的Value（即先找name），找到name以後能夠判斷該name對應的registeredAlias是否和參數中的alias相同，若是相同返回true，不相同則遞歸尋找。

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;
}

hasAlias方法實現了鏈式查找別名。

SimpleAliasRegistry registry = new SimpleAliasRegistry();
registry.registerAlias("test", "testAlias");
registry.registerAlias("testAlias", "testAlias2");
registry.registerAlias("testAlias2", "testAlias3");

咱們能夠獲得（別名alias，原名name）的對應Map
testAlias->test
testAlias2->testAlias
testAlias3->testAlias2
那麼咱們就testAlias3->testAlias2->testAlias->test,使用hasAlias尋找的方向與箭頭方法相反

再好比

SimpleAliasRegistry registry = new SimpleAliasRegistry();
registry.registerAlias("name", "alias_a");
registry.registerAlias("name", "alias_b");

registry.registerAlias("real_name", "name");

registry.registerAlias("name", "alias_c");
}

這裏的每一條鏈接線+鏈接線首位兩個實體=concurrentHashMap中的一條記錄。總共三條別名鏈，他們分別是
alias_a->name->real_name;
alias_b->name->real_name;
alias_c->name->real_name;
位於鏈尾的real_name的就是canonicalName

3.canonicalName（String name)

輸入一個name參數（多是別名alias），查詢他的規範名，也就是位於鏈尾的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;
}

4. getAlias(String name)

public String[] getAliases(String name) {
    List<String> result = new ArrayList<>();
    synchronized (this.aliasMap) {
        retrieveAliases(name, result);
    }
    return StringUtils.toStringArray(result);
}

private void retrieveAliases(String name, List<String> result) {
    this.aliasMap.forEach((alias, registeredName) -> {
        if (registeredName.equals(name)) {
            result.add(alias);
            retrieveAliases(alias, result);
        }
    });
}

lambda 表達式很差懂,我們再翻譯一下

private void retrieveAliases(String name, List<String> result) {
    for (Map.Entry<String, String> entry : aliasMap.entrySet()) {
        String alias = entry.getKey();
        String registeredName = entry.getValue();
        if (registeredName.equals(name)) {
            result.add(alias);
            retrieveAliases(alias, result);
        }
    });
}

從Map中先找匹配的value（name），找到了，就把對應key（alias）添加到列表中，再把key（alias）當成name，繼續尋找。舉個例子,若是有這樣一條別名鏈
a->b->c->d，那麼
getAlias("d") 結果是["c", "b" ,"a"]
getAlias("c") 結果是["b" ,"a"]
getAlias("b") 結果是["a"]
getAlias("a") 結果是[]

5.resolveAliases(StringValueResolver valueResolver

這個方法和registerAlias(String name, String alias)類似度極高。
在執行resolveAliases以前，aliasMap中存儲的是（別名alias，別名目標名稱registeredName），運用值解析器解析以後，別名alias將被替換爲resolvedAlias，

/**
 * 解析在此工廠中註冊的全部別名目標名稱和別名，並將給定的
 * StringValueResolver應用於它們。
 * 例如，值解析器能夠解析目標bean名稱中的佔位符，甚至能夠
 * 解析別名中的佔位符。
 */
public void resolveAliases(StringValueResolver valueResolver) {
    Assert.notNull(valueResolver, "StringValueResolver must not be null");
    synchronized (this.aliasMap) {
        // 拷貝一份aliasMap，這樣就能夠再遍歷aliasMap副本時，修改原aliasMap
        Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
        aliasCopy.forEach((alias, registeredName) -> {
            // 
            String resolvedAlias = valueResolver.resolveStringValue(alias);
            String resolvedName = valueResolver.resolveStringValue(registeredName);
            // （狀況零）
            // 若是解析出的別名或者解析出的目標名稱爲null，亦或者二者相同，則移除alias->registeredName
            if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
                this.aliasMap.remove(alias);
            }
            else if (!resolvedAlias.equals(alias)) {
                // 若是已解析的別名resolvedAlias不等於alias
                String existingName = this.aliasMap.get(resolvedAlias);
                if (existingName != null) {
                    if (existingName.equals(resolvedName)) {
                        // （狀況二）
                        // 指向現有別名，只須要刪除佔位符
                        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)) {
                // （狀況三）
                // 若是已解析的別名resolvedAlias等於alias
                // 可是已解析的註冊名resolvedName不等於原註冊名registeredName
                // 則使用已解析的註冊名resolvedName覆蓋原註冊名registeredName
                // alias->resolvedName
                this.aliasMap.put(alias, resolvedName);
            }
        });
    }
}

狀況一

• 假如alias不等於resolvedAlias，且resolvedAlias->existingName不存在。那麼，移除alias->resigteredName，新增resolvedAlias->resolvedName
  

狀況二

• 假如alias不等於resolvedAlias，且resolvedAlias->existingName已經存在，那麼移除alias->resigteredName
  

狀況三

• 假如alias等於resolvedAlias，且resolvedName不等於registeredName。那麼，用resolvedAlias/alias->resolvedName覆蓋alias->resigteredName

• StringValueResolver的結構圖：
  

• StringValueResolver的主要接口方法
  String resolveStringValue(String strVal)，其做用是解析給定的String值，例如解析佔位符