org.springframework.web.servlet.mvc.condition.ProducesRequestCondition.java Source code

Java tutorial

Introduction

Here is the source code for org.springframework.web.servlet.mvc.condition.ProducesRequestCondition.java

Source

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.servlet.mvc.condition;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.servlet.http.HttpServletRequest;

import org.springframework.http.MediaType;
import org.springframework.lang.Nullable;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.HttpMediaTypeException;
import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.accept.ContentNegotiationManager;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.context.request.ServletWebRequest;
import org.springframework.web.cors.CorsUtils;
import org.springframework.web.servlet.mvc.condition.HeadersRequestCondition.HeaderExpression;

/**
 * A logical disjunction (' || ') request condition to match a request's 'Accept' header
 * to a list of media type expressions. Two kinds of media type expressions are
 * supported, which are described in {@link RequestMapping#produces()} and
 * {@link RequestMapping#headers()} where the header name is 'Accept'.
 * Regardless of which syntax is used, the semantics are the same.
 *
 * @author Arjen Poutsma
 * @author Rossen Stoyanchev
 * @since 3.1
 */
public final class ProducesRequestCondition extends AbstractRequestCondition<ProducesRequestCondition> {

    private static final ContentNegotiationManager DEFAULT_CONTENT_NEGOTIATION_MANAGER = new ContentNegotiationManager();

    private static final ProducesRequestCondition EMPTY_CONDITION = new ProducesRequestCondition();

    private static final List<ProduceMediaTypeExpression> MEDIA_TYPE_ALL_LIST = Collections
            .singletonList(new ProduceMediaTypeExpression(MediaType.ALL_VALUE));

    private static final String MEDIA_TYPES_ATTRIBUTE = ProducesRequestCondition.class.getName() + ".MEDIA_TYPES";

    private final List<ProduceMediaTypeExpression> expressions;

    private final ContentNegotiationManager contentNegotiationManager;

    /**
     * Creates a new instance from "produces" expressions. If 0 expressions
     * are provided in total, this condition will match to any request.
     * @param produces expressions with syntax defined by {@link RequestMapping#produces()}
     */
    public ProducesRequestCondition(String... produces) {
        this(produces, null, null);
    }

    /**
     * Creates a new instance with "produces" and "header" expressions. "Header"
     * expressions where the header name is not 'Accept' or have no header value
     * defined are ignored. If 0 expressions are provided in total, this condition
     * will match to any request.
     * @param produces expressions with syntax defined by {@link RequestMapping#produces()}
     * @param headers expressions with syntax defined by {@link RequestMapping#headers()}
     */
    public ProducesRequestCondition(String[] produces, @Nullable String[] headers) {
        this(produces, headers, null);
    }

    /**
     * Same as {@link #ProducesRequestCondition(String[], String[])} but also
     * accepting a {@link ContentNegotiationManager}.
     * @param produces expressions with syntax defined by {@link RequestMapping#produces()}
     * @param headers expressions with syntax defined by {@link RequestMapping#headers()}
     * @param manager used to determine requested media types
     */
    public ProducesRequestCondition(String[] produces, @Nullable String[] headers,
            @Nullable ContentNegotiationManager manager) {

        this.expressions = new ArrayList<>(parseExpressions(produces, headers));
        Collections.sort(this.expressions);
        this.contentNegotiationManager = manager != null ? manager : DEFAULT_CONTENT_NEGOTIATION_MANAGER;
    }

    /**
     * Private constructor for internal use to create matching conditions.
     * Note the expressions List is neither sorted nor deep copied.
     */
    private ProducesRequestCondition(List<ProduceMediaTypeExpression> expressions, ProducesRequestCondition other) {
        this.expressions = expressions;
        this.contentNegotiationManager = other.contentNegotiationManager;
    }

    private Set<ProduceMediaTypeExpression> parseExpressions(String[] produces, @Nullable String[] headers) {
        Set<ProduceMediaTypeExpression> result = new LinkedHashSet<>();
        if (headers != null) {
            for (String header : headers) {
                HeaderExpression expr = new HeaderExpression(header);
                if ("Accept".equalsIgnoreCase(expr.name) && expr.value != null) {
                    for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) {
                        result.add(new ProduceMediaTypeExpression(mediaType, expr.isNegated));
                    }
                }
            }
        }
        for (String produce : produces) {
            result.add(new ProduceMediaTypeExpression(produce));
        }
        return result;
    }

    /**
     * Return the contained "produces" expressions.
     */
    public Set<MediaTypeExpression> getExpressions() {
        return new LinkedHashSet<>(this.expressions);
    }

    /**
     * Return the contained producible media types excluding negated expressions.
     */
    public Set<MediaType> getProducibleMediaTypes() {
        Set<MediaType> result = new LinkedHashSet<>();
        for (ProduceMediaTypeExpression expression : this.expressions) {
            if (!expression.isNegated()) {
                result.add(expression.getMediaType());
            }
        }
        return result;
    }

    /**
     * Whether the condition has any media type expressions.
     */
    @Override
    public boolean isEmpty() {
        return this.expressions.isEmpty();
    }

    @Override
    protected List<ProduceMediaTypeExpression> getContent() {
        return this.expressions;
    }

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

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

    /**
     * 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#isCompatibleWith(MediaType)}.
     * @param request the current request
     * @return the same instance if there are no expressions;
     * or a new condition with matching expressions;
     * or {@code null} if no expressions match.
     */
    @Override
    @Nullable
    public ProducesRequestCondition getMatchingCondition(HttpServletRequest request) {
        if (CorsUtils.isPreFlightRequest(request)) {
            return EMPTY_CONDITION;
        }
        if (isEmpty()) {
            return this;
        }
        List<MediaType> acceptedMediaTypes;
        try {
            acceptedMediaTypes = getAcceptedMediaTypes(request);
        } catch (HttpMediaTypeException ex) {
            return null;
        }
        List<ProduceMediaTypeExpression> result = getMatchingExpressions(acceptedMediaTypes);
        if (!CollectionUtils.isEmpty(result)) {
            return new ProducesRequestCondition(result, this);
        } else if (MediaType.ALL.isPresentIn(acceptedMediaTypes)) {
            return EMPTY_CONDITION;
        } else {
            return null;
        }
    }

    @Nullable
    private List<ProduceMediaTypeExpression> getMatchingExpressions(List<MediaType> acceptedMediaTypes) {
        List<ProduceMediaTypeExpression> result = null;
        for (ProduceMediaTypeExpression expression : this.expressions) {
            if (expression.match(acceptedMediaTypes)) {
                result = result != null ? result : new ArrayList<>();
                result.add(expression);
            }
        }
        return result;
    }

    /**
     * Compares this and another "produces" condition as follows:
     * <ol>
     * <li>Sort 'Accept' header media types by quality value via
     * {@link MediaType#sortByQualityValue(List)} and iterate the list.
     * <li>Get the first index of matching media types in each "produces"
     * condition first matching with {@link MediaType#equals(Object)} and
     * then with {@link MediaType#includes(MediaType)}.
     * <li>If a lower index is found, the condition at that index wins.
     * <li>If both indexes are equal, the media types at the index are
     * compared further with {@link MediaType#SPECIFICITY_COMPARATOR}.
     * </ol>
     * <p>It is assumed that both instances have been obtained via
     * {@link #getMatchingCondition(HttpServletRequest)} and each instance
     * contains the matching producible media type expression only or
     * is otherwise empty.
     */
    @Override
    public int compareTo(ProducesRequestCondition other, HttpServletRequest request) {
        try {
            List<MediaType> acceptedMediaTypes = getAcceptedMediaTypes(request);
            for (MediaType acceptedMediaType : acceptedMediaTypes) {
                int thisIndex = this.indexOfEqualMediaType(acceptedMediaType);
                int otherIndex = other.indexOfEqualMediaType(acceptedMediaType);
                int result = compareMatchingMediaTypes(this, thisIndex, other, otherIndex);
                if (result != 0) {
                    return result;
                }
                thisIndex = this.indexOfIncludedMediaType(acceptedMediaType);
                otherIndex = other.indexOfIncludedMediaType(acceptedMediaType);
                result = compareMatchingMediaTypes(this, thisIndex, other, otherIndex);
                if (result != 0) {
                    return result;
                }
            }
            return 0;
        } catch (HttpMediaTypeNotAcceptableException ex) {
            // should never happen
            throw new IllegalStateException("Cannot compare without having any requested media types", ex);
        }
    }

    @SuppressWarnings("unchecked")
    private List<MediaType> getAcceptedMediaTypes(HttpServletRequest request)
            throws HttpMediaTypeNotAcceptableException {

        List<MediaType> result = (List<MediaType>) request.getAttribute(MEDIA_TYPES_ATTRIBUTE);
        if (result == null) {
            result = this.contentNegotiationManager.resolveMediaTypes(new ServletWebRequest(request));
            request.setAttribute(MEDIA_TYPES_ATTRIBUTE, result);
        }
        return result;
    }

    private int indexOfEqualMediaType(MediaType mediaType) {
        for (int i = 0; i < getExpressionsToCompare().size(); i++) {
            MediaType currentMediaType = getExpressionsToCompare().get(i).getMediaType();
            if (mediaType.getType().equalsIgnoreCase(currentMediaType.getType())
                    && mediaType.getSubtype().equalsIgnoreCase(currentMediaType.getSubtype())) {
                return i;
            }
        }
        return -1;
    }

    private int indexOfIncludedMediaType(MediaType mediaType) {
        for (int i = 0; i < getExpressionsToCompare().size(); i++) {
            if (mediaType.includes(getExpressionsToCompare().get(i).getMediaType())) {
                return i;
            }
        }
        return -1;
    }

    private int compareMatchingMediaTypes(ProducesRequestCondition condition1, int index1,
            ProducesRequestCondition condition2, int index2) {

        int result = 0;
        if (index1 != index2) {
            result = index2 - index1;
        } else if (index1 != -1) {
            ProduceMediaTypeExpression expr1 = condition1.getExpressionsToCompare().get(index1);
            ProduceMediaTypeExpression expr2 = condition2.getExpressionsToCompare().get(index2);
            result = expr1.compareTo(expr2);
            result = (result != 0) ? result : expr1.getMediaType().compareTo(expr2.getMediaType());
        }
        return result;
    }

    /**
     * Return the contained "produces" expressions or if that's empty, a list
     * with a {@value MediaType#ALL_VALUE} expression.
     */
    private List<ProduceMediaTypeExpression> getExpressionsToCompare() {
        return (this.expressions.isEmpty() ? MEDIA_TYPE_ALL_LIST : this.expressions);
    }

    /**
     * Use this to clear {@link #MEDIA_TYPES_ATTRIBUTE} that contains the parsed,
     * requested media types.
     * @param request the current request
     * @since 5.2
     */
    public static void clearMediaTypesAttribute(HttpServletRequest request) {
        request.removeAttribute(MEDIA_TYPES_ATTRIBUTE);
    }

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

        ProduceMediaTypeExpression(MediaType mediaType, boolean negated) {
            super(mediaType, negated);
        }

        ProduceMediaTypeExpression(String expression) {
            super(expression);
        }

        public final boolean match(List<MediaType> acceptedMediaTypes) {
            boolean match = matchMediaType(acceptedMediaTypes);
            return !isNegated() == match;
        }

        private boolean matchMediaType(List<MediaType> acceptedMediaTypes) {
            for (MediaType acceptedMediaType : acceptedMediaTypes) {
                if (getMediaType().isCompatibleWith(acceptedMediaType) && matchParameters(acceptedMediaType)) {
                    return true;
                }
            }
            return false;
        }

        private boolean matchParameters(MediaType acceptedMediaType) {
            for (String name : getMediaType().getParameters().keySet()) {
                String s1 = getMediaType().getParameter(name);
                String s2 = acceptedMediaType.getParameter(name);
                if (StringUtils.hasText(s1) && StringUtils.hasText(s2) && !s1.equalsIgnoreCase(s2)) {
                    return false;
                }
            }
            return true;
        }
    }

}