Spring之AntPathMatcher

前言

AntPathMatcher是什么？主要用來解決什么問題？

背景：在做uri匹配規則發現這個類，根據源碼對該類進行分析，它主要用來做類URLs字符串匹配；

效果

可以做URLs匹配，規則如下

1. ？匹配一個字符
2. *匹配0個或多個字符
3. **匹配0個或多個目錄

用例如下

• /trip/api/*x    匹配 /trip/api/x，/trip/api/ax，/trip/api/abx ；但不匹配 /trip/abc/x；
• /trip/a/a?x    匹配 /trip/a/abx；但不匹配 /trip/a/ax，/trip/a/abcx
• /**/api/alie    匹配 /trip/api/alie，/trip/dax/api/alie；但不匹配 /trip/a/api
• /**/*.htmlm   匹配所有以.htmlm結尾的路徑

核心

AntPathMatcher API接口

由上圖可知，AntPathMatcher提供了豐富的API，主要以doMatch為主，下邊來講doMatch的實現上（其中pattern為制定的url模式，path為具體的url，下邊以英文為主講解）：

1    首先判斷pattern和path的首字符是否同時為設置的分隔符，結果不一致則直接返回false，不進行下邊的操作；

2    分別對pattern和path進行分詞，形成各自的字符串數組，其中分詞的主要代碼如下（這段代碼很清晰）：

public static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
   if (str == null) {
      return null;
   }
   StringTokenizer st = new StringTokenizer(str, delimiters);
   List<String> tokens = new ArrayList<String>();
   while (st.hasMoreTokens()) {
      String token = st.nextToken();
      if (trimTokens) {
         token = token.trim();
      }
      if (!ignoreEmptyTokens || token.length() > 0) {
         tokens.add(token);
      }
   }
   return toStringArray(tokens);
}

注：str代表要進行分詞的字符串，delimiters是進行分詞的分隔符，trimTokens表示是否對每一個分詞進行首尾去空字符串，ignoreEmptyTokens代表分割之后是否保留空字符串；

我們發現，每次計算這個也是要花費一定的時間消耗，那每次真的是要重新計算么 ？看下邊的代碼來找答案（下邊的代碼是在上個方法tokenizeToStringArray調用之前進行）：

private final Map<String, String[]> tokenizedPatternCache = new ConcurrentHashMap<String, String[]>(256);
......
protected String[] tokenizePattern(String pattern) {
   String[] tokenized = null;
   Boolean cachePatterns = this.cachePatterns;
   if (cachePatterns == null || cachePatterns.booleanValue()) {
      tokenized = this.tokenizedPatternCache.get(pattern);
   }
   if (tokenized == null) {
      tokenized = tokenizePath(pattern);
      if (cachePatterns == null && this.tokenizedPatternCache.size() >= CACHE_TURNOFF_THRESHOLD) {
         // Try to adapt to the runtime situation that we're encountering:
         // There are obviously too many different patterns coming in here...
         // So let's turn off the cache since the patterns are unlikely to be reoccurring.
         deactivatePatternCache();
         return tokenized;
      }
      if (cachePatterns == null || cachePatterns.booleanValue()) {
         this.tokenizedPatternCache.put(pattern, tokenized);
      }
   }
   return tokenized;
}

我們看到，這里存了一個pattern的cache tokenizedPatternCache，key為pattern，value為分次之后的字符串數組，每次先到cache獲取，沒有的話則計算，然后放入到cache里邊，這樣在做頻繁的url mapping的時候，由於規則是有限的，可以很大程度減少計算；

同理，path也是通過同樣的計算，不過，path則不會緩存，每次都需要調用tokenizeToStringArray進行分詞（為什么呢？[1]）

接着來說3：

3    對分詞之后的pattern數組和path數組從begin進行遍歷，一旦pattern的第一個字符串是**的話，則跳出來，此時沒有直接返回true，為什么呢[2]？

下邊接着看doMatch的中間部分代碼（也就是說當break或者運行完畢while循環的時候，在退出之前會接着執行下邊的代碼）

1    如果path分詞數組正常執行完畢，則pathIdxStart是會比pathIdxEnd大1的，這個時候，如果pattern的字符串數組也正常耗盡，則來判斷pattern和path的最后一個字符是否同步，按結果返回；

2    如果上邊的循環只執行了一次，則這時候pattIdxStart則和pattIdxEnd相等，同時pattern的最后一個字符是*且path最后是一個分隔符，則直接返回true；

3    如果pattern的最后一個字符串是**則path不需要判斷直接返回true；

4    這一步代表，pattern已經耗盡但是path還沒耗盡，這時候肯定不匹配，直接返回false

接下來接着看，緊接着上邊第二幅黑色背景圖，如果第一次因為**彈出來，看下邊如何處理：

這個時候，開始從后往前遍歷，如果再次彈出來不是因為遇到了**，是正常遍歷完成，這個時候，pathIdxStart是大於pathIdxEnd，這個時候字符串已經耗盡，如果pattern還沒有耗盡，並且最后並不是**，則直接返回false；

如果中間再次出現**，並且path並沒有耗盡，則進行下邊的步驟：

這一部分代碼主要用來循環處理中間再次**的情況，直到完全處理完成，這里邊用到了Java的標簽語法：strLoop，符合條件則跳轉到strLoop（類似goto）;

總結

這一部分的處理理解起來不是非常難懂，但是這個關於字符串匹配的過程是及其細致的，每一個邊界問題都想得比較完美，這一點是相當值得學習的。

后記

其中，每一個path的分詞是如何匹配到pattern的分詞是怎么做的呢？答案就在  matchStrings 這個方法里邊了：

首先用path來匹配pattern的時候，要獲取一個matcher，代碼如下：

final Map<String, AntPathStringMatcher> stringMatcherCache = new ConcurrentHashMap<String, AntPathStringMatcher>(256);
......
protected AntPathStringMatcher getStringMatcher(String pattern) {
   AntPathStringMatcher matcher = null;
   Boolean cachePatterns = this.cachePatterns;
   if (cachePatterns == null || cachePatterns.booleanValue()) {
      matcher = this.stringMatcherCache.get(pattern);
   }
   if (matcher == null) {
      matcher = new AntPathStringMatcher(pattern);
      if (cachePatterns == null && this.stringMatcherCache.size() >= CACHE_TURNOFF_THRESHOLD) {
         // Try to adapt to the runtime situation that we're encountering:
         // There are obviously too many different patterns coming in here...
         // So let's turn off the cache since the patterns are unlikely to be reoccurring.
         deactivatePatternCache();
         return matcher;
      }
      if (cachePatterns == null || cachePatterns.booleanValue()) {
         this.stringMatcherCache.put(pattern, matcher);
      }
   }
   return matcher;
}

這里new AntPathStringMatcher（AntPathMatcher的一個內部類）的時候也是需要一些計算，matcher構建的精華全部在這里了：

public AntPathStringMatcher(String pattern) {
   StringBuilder patternBuilder = new StringBuilder();
   Matcher m = GLOB_PATTERN.matcher(pattern);
   int end = 0;
   while (m.find()) {
      patternBuilder.append(quote(pattern, end, m.start()));
      String match = m.group();
      if ("?".equals(match)) {
         patternBuilder.append('.');
      }
      else if ("*".equals(match)) {
         patternBuilder.append(".*");
      }
      else if (match.startsWith("{") && match.endsWith("}")) {
         int colonIdx = match.indexOf(':');
         if (colonIdx == -1) {
            patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
            this.variableNames.add(m.group(1));
         }
         else {
            String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
            patternBuilder.append('(');
            patternBuilder.append(variablePattern);
            patternBuilder.append(')');
            String variableName = match.substring(1, colonIdx);
            this.variableNames.add(variableName);
         }
      }
      end = m.end();
   }
   patternBuilder.append(quote(pattern, end, pattern.length()));
   this.pattern = Pattern.compile(patternBuilder.toString());
}

這部分計算比較頻繁，也會耗費一定量的時間，所以這里用到了一個叫做 stringMatcherCache 的cache，上文中提到的兩個cache的數量都不能超過65536，有其中任意一個cache超過這個限制，則會清空整個cache。