SpringMVC源码解读 - RequestMapping注解实现解读 - ConsumesRequestCondition

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