SpringMVC源碼解讀 - RequestMapping注解實現解讀 - RequestCondition體系

一般我們開發時,使用最多的還是@RequestMapping注解方式.

@RequestMapping(value = "/", param = "role=guest", consumes = "!application/json")
public void myHtmlService() {
    // ... 
}

台前的是RequestMapping ,正經干活的卻是RequestCondition,根據配置的不同條件匹配request.

 

@RequestMapping注解,請看<SpringMVC源碼解讀 - HandlerMapping - RequestMappingHandlerMapping初始化>

典型的接口+模板.一個接口ReqeustCondition,一個抽象類,定義基礎,然后n多的具體實現.

 

實現中可以分為3類:基礎實現,外觀類和容器.

　　其中CompositeRequestCondition和RequestMappingInfo本身不帶任何的匹配條件,只是用於包裝其他的RequestCondition進行匹配

基礎實現:
　　consumes對應request的提交內容類型content type,如application/json, text/html

　　headers 對應http request 的請求頭

　　params對應http request parameter

　　Patterns對應url,就是注解value中的配置

　　produces指定返回的內容類型的content type，僅當request請求頭中的(Accept)類型中包含該指定類型才返回

　　requestMethods對應 http method,如GET,POST,PUT,DELETE等

外觀類:

　　RequestConditionHolder,用於不知道具體是RequestCondition哪個子類時.自定義的條件,使用的這個進行封裝

容器:

　　CompositeRequestCondition封裝基礎實現,具體的匹配都委托給基礎實現類.

　　RequestMappingInfo,對應@RequestMapping注解,一一對應注解內容與基礎實現,使用時一一委托.

 

 

先來看看RequestCondition的接口定義

package org.springframework.web.servlet.mvc.condition;
    /**
     * The contract for request conditions.
     */
    public interface RequestCondition<T> {

        /**
         * 將不同的篩選條件合並
         */
        T combine(T other);

        /**
         * 根據request查找匹配到的篩選條件
         */
        T getMatchingCondition(HttpServletRequest request);

        /**
         * 不同篩選條件比較,用於排序
         */
        int compareTo(T other, HttpServletRequest request);

    }
}

 

老規矩,接下來得上抽象類AbstractRequestCondition

AbstractRequestCondition做的事不多,覆寫equals,hashCode,toString.實現equals,hashCode,toString時預留模板方法getContent();實現toString時預留模板方法getToStringInfix().

package org.springframework.web.servlet.mvc.condition;
/**
 * A base class for {@link RequestCondition} types providing implementations of
 * {@link #equals(Object)}, {@link #hashCode()}, and {@link #toString()}.
 *
 * @author Rossen Stoyanchev
 * @since 3.1
 */
public abstract class AbstractRequestCondition<T extends AbstractRequestCondition<T>> implements RequestCondition<T> {

    /**
     * Return the discrete items a request condition is composed of.
     * For example URL patterns, HTTP request methods, param expressions, etc.
     * @return a collection of objects, never {@code null}
     */
    protected abstract Collection<?> getContent();

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o != null && getClass().equals(o.getClass())) {
            AbstractRequestCondition<?> other = (AbstractRequestCondition<?>) o;
            return getContent().equals(other.getContent());
        }
        return false;
    }

    @Override
    public int hashCode() {
        return getContent().hashCode();
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("[");
        for (Iterator<?> iterator = getContent().iterator(); iterator.hasNext();) {
            Object expression = iterator.next();
            builder.append(expression.toString());
            if (iterator.hasNext()) {
                builder.append(getToStringInfix());
            }
        }
        builder.append("]");
        return builder.toString();
    }

    /**
     * The notation to use when printing discrete items of content.
     * For example " || " for URL patterns or " && " for param expressions.
     */
    protected abstract String getToStringInfix();

}

 

接下來得看具體實現了,捏不到軟柿子,用ParamsRequestCondition簡單說明下子類吧

// ParamsRequestCondition

// 保存解析出來的param匹配條件
private final Set<ParamExpression> expressions;

ParamExpression其實很簡單,看父類AbstractNameValueExpression很清楚

// AbstractNameValueExpression

package org.springframework.web.servlet.mvc.condition;
abstract class AbstractNameValueExpression<T> implements NameValueExpression<T> {
    // 參數的名字
    protected final String name;
    // 參數的值
    protected final T value;
    // 參數的匹配規則,是= 還是!=
    protected final boolean isNegated;
}

到這里我們就可以看懂,使用ParamExpression保存param參數,這樣可以任意多個.

combine的實現也就水到渠成,直接把expression拼接到一個集合里就行:

package org.springframework.web.servlet.mvc.condition;
public final class ParamsRequestCondition extends AbstractRequestCondition<ParamsRequestCondition> {
    /**
     * Returns a new instance with the union of the param expressions
     * from "this" and the "other" instance.
     */
    public ParamsRequestCondition combine(ParamsRequestCondition other) {
        Set<ParamExpression> set = new LinkedHashSet<ParamExpression>(this.expressions);
        set.addAll(other.expressions);
        return new ParamsRequestCondition(set);
    }
}

 

getMatchingCondition時,只要有一個不符合就判定條件不匹配

package org.springframework.web.servlet.mvc.condition;
public final class ParamsRequestCondition extends AbstractRequestCondition<ParamsRequestCondition> {
    /**
     * Returns "this" instance if the request matches all param expressions;
     * or {@code null} otherwise.
     */
    public ParamsRequestCondition getMatchingCondition(HttpServletRequest request) {
        for (ParamExpression expression : expressions) {
            if (!expression.match(request)) {
                return null;
            }
        }
        return this;
    }
}

這邊的match方法比較有意思,可以看下

package org.springframework.web.servlet.mvc.condition;
abstract class AbstractNameValueExpression<T> implements NameValueExpression<T> {
    public final boolean match(HttpServletRequest request) {
        boolean isMatch;
        if (this.value != null) { 
            isMatch = matchValue(request);
        }
        else { // 沒有value時,只要匹配name就好
            isMatch = matchName(request);
        }
        return isNegated ? !isMatch : isMatch; // 這邊需要看仔細,=與!=的處理
    }

    protected abstract boolean matchName(HttpServletRequest request);

    protected abstract boolean matchValue(HttpServletRequest request);
}

ParamExpression中給出matchName與matchValue的實現.

ParamExpression這里又是接口+抽象實現+模板方法設計模式,偷個懶,暫時不去關心各層抽象的什么.

 

compareTo根據匹配條件的多少來判定順序

// ParamsRequestCondition

    public int compareTo(ParamsRequestCondition other, HttpServletRequest request) {
        return other.expressions.size() - this.expressions.size();
    }

 

記得還留有兩個模板方法

getContent直接返回記錄param的expressions

getToStringInfix則使用&&

// ParamsRequestCondition

    @Override
    protected Collection<ParamExpression> getContent() {
        return expressions;
    }

    @Override
    protected String getToStringInfix() {
        return " && ";
    }

再看看是如何解析param的 

// ParamsRequestCondition

    /**
     * Create a new instance from the given param expressions.
     * @param params expressions with syntax defined in {@link RequestMapping#params()};
     *     if 0, the condition will match to every request.
     */
    public ParamsRequestCondition(String... params) {
        this(parseExpressions(params));
    }

    private static Collection<ParamExpression> parseExpressions(String... params) {
        Set<ParamExpression> expressions = new LinkedHashSet<ParamExpression>();
        if (params != null) {
            for (String param : params) {
                expressions.add(new ParamExpression(param));
            }
        }
        return expressions;
    }

核心的代碼還是在AbstractNameValueExpression

// AbstractNameValueExpression

邏輯不復雜,代碼看着有點煩,是不是應該聽Martin Fowler在<重構>中的建議,來個extract method?

    AbstractNameValueExpression(String expression) {
        int separator = expression.indexOf('=');
        if (separator == -1) {
            this.isNegated = expression.startsWith("!");
            this.name = isNegated ? expression.substring(1) : expression;
            this.value = null;
        }
        else {
            this.isNegated = (separator > 0) && (expression.charAt(separator - 1) == '!');
            this.name = isNegated ? expression.substring(0, separator - 1) : expression.substring(0, separator);
            this.value = parseValue(expression.substring(separator + 1));
        }
    }

 

 

RequestCondition的解讀未完,待續:

SpringMVC源碼解讀 - RequestMapping注解實現解讀 - ConsumesRequestCondition

SpringMVC源碼解讀 - RequestMapping注解實現解讀 - RequestMappingInfo