SpringMVC源码解读

consumes  指定处理请求的提交内容类型（media-Type），例如application/json, text/html.

所以这边的ConsumesRequestCondition就是通过content type进行url过滤的.

具体分析前,我们先准备下基础知识.

　　1. MediaType(org.springframework.http包下,封装n多api)

　　2. MediaTypeExpression接口,对MediaType和是否匹配关系(=或!=)的封装

　　3. AbstractMediaTypeExpression体系,也就是ConsumeMediaTypeExpression和ProduceMediaTypeExpression.

// MediaTypeExpression接口

package org.springframework.web.servlet.mvc.condition;
public interface MediaTypeExpression {

    MediaType getMediaType();

    boolean isNegated();

}

AbstractMediaTypeExpression构造方法处理是否!后,委托MediaType处理

// AbstractMediaTypeExpression

    AbstractMediaTypeExpression(String expression) {
        if (expression.startsWith("!")) {
            isNegated = true;
            expression = expression.substring(1);
        }
        else {
            isNegated = false;
        }
        this.mediaType = MediaType.parseMediaType(expression);
    }

看看条件匹配的match

// AbstractMediaTypeExpression

    public final boolean match(HttpServletRequest request) {
        try {
            boolean match = matchMediaType(request);
            return !isNegated ? match : !match;
        }
        catch (HttpMediaTypeException ex) {
            return false;
        }
    }

    protected abstract boolean matchMediaType(HttpServletRequest request) throws HttpMediaTypeException;

Consume和Produce的区别终于出来了

static class ConsumeMediaTypeExpression extends AbstractMediaTypeExpression {
        @Override
        protected boolean matchMediaType(HttpServletRequest request) throws HttpMediaTypeNotSupportedException {
            try {
                MediaType contentType = StringUtils.hasLength(request.getContentType()) ?
                        MediaType.parseMediaType(request.getContentType()) :
                        MediaType.APPLICATION_OCTET_STREAM;
                        return getMediaType().includes(contentType);
            }
            catch (IllegalArgumentException ex) {
                throw new HttpMediaTypeNotSupportedException(
                        "Can't parse Content-Type [" + request.getContentType() + "]: " + ex.getMessage());
            }
        }
}

    private final List<ProduceMediaTypeExpression> MEDIA_TYPE_ALL_LIST =
            Collections.singletonList(new ProduceMediaTypeExpression("*/*"));


    /**
     * Parses and matches a single media type expression to a request's 'Accept' header.
     */
    class ProduceMediaTypeExpression extends AbstractMediaTypeExpression {

        @Override
        protected boolean matchMediaType(HttpServletRequest request) throws HttpMediaTypeNotAcceptableException {
            List<MediaType> acceptedMediaTypes = getAcceptedMediaTypes(request);
            for (MediaType acceptedMediaType : acceptedMediaTypes) {
                if (getMediaType().isCompatibleWith(acceptedMediaType)) {
                    return true;
                }
            }
            return false;
        }
    }

正文

combine方法,这边不做合并,直接覆盖

// ConsumesRequestCondition

    /**
     * Returns the "other" instance if it has any expressions; returns "this"
     * instance otherwise. Practically that means a method-level "consumes"
     * overrides a type-level "consumes" condition.
     */
    public ConsumesRequestCondition combine(ConsumesRequestCondition other) {
        return !other.expressions.isEmpty() ? other : this;
    }

getMatchingCondition的规则是存在一个即判定匹配

// ConsumesRequestCondition

    /**
     * Checks if any of the contained media type expressions match the given
     * request 'Content-Type' header and returns an instance that is guaranteed
     * to contain matching expressions only. The match is performed via
     * {@link MediaType#includes(MediaType)}.
     *
     * @param request the current request
     *
     * @return the same instance if the condition contains no expressions;
     *         or a new condition with matching expressions only;
     *         or {@code null} if no expressions match.
     */
    public ConsumesRequestCondition getMatchingCondition(HttpServletRequest request) {
        if (isEmpty()) {
            return this;
        }
        Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<ConsumeMediaTypeExpression>(expressions);
        for (Iterator<ConsumeMediaTypeExpression> iterator = result.iterator(); iterator.hasNext();) {
            ConsumeMediaTypeExpression expression = iterator.next();
            if (!expression.match(request)) {
                iterator.remove();
            }
        }
        return (result.isEmpty()) ? null : new ConsumesRequestCondition(result);
    }

compareTo谁有匹配规则谁牛逼,都有的话比较第一个expression

// ConsumesRequestCondition

    public int compareTo(ConsumesRequestCondition other, HttpServletRequest request) {
        if (this.expressions.isEmpty() && other.expressions.isEmpty()) {
            return 0;
        }
        else if (this.expressions.isEmpty()) {
            return 1;
        }
        else if (other.expressions.isEmpty()) {
            return -1;
        }
        else {
            return this.expressions.get(0).compareTo(other.expressions.get(0));
        }
    }

看看初始化吧

    /**
     * Creates a new instance with "consumes" and "header" expressions.
     * "Header" expressions where the header name is not 'Content-Type' or have
     * no header value defined are ignored. If 0 expressions are provided in
     * total, the condition will match to every request
     * @param consumes as described in {@link RequestMapping#consumes()}
     * @param headers as described in {@link RequestMapping#headers()}
     */
    public ConsumesRequestCondition(String[] consumes, String[] headers) {
        this(parseExpressions(consumes, headers));
    }

    private static Set<ConsumeMediaTypeExpression> parseExpressions(String[] consumes, String[] headers) {
        Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<ConsumeMediaTypeExpression>();
        if (headers != null) {
            for (String header : headers) {
                HeaderExpression expr = new HeaderExpression(header);
                if ("Content-Type".equalsIgnoreCase(expr.name)) {
                    for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) {
                        result.add(new ConsumeMediaTypeExpression(mediaType, expr.isNegated));
                    }
                }
            }
        }
        if (consumes != null) {
            for (String consume : consumes) {
                result.add(new ConsumeMediaTypeExpression(consume));
            }
        }
        return result;
    }