/** * Return the list of acceptable {@linkplain MediaType media types}, * as specified by the {@code Accept} header. * <p>Returns an empty list when the acceptable media types are unspecified. */ public List<MediaType> getAccept() { return MediaType.parseMediaTypes(get(ACCEPT)); }
/** * Parse the given list of (potentially) comma-separated strings into a * list of {@code MediaType} objects. * <p>This method can be used to parse an Accept or Content-Type header. * @param mediaTypes the string to parse * @return the list of media types * @throws InvalidMediaTypeException if the media type value cannot be parsed * @since 4.3.2 */ public static List<MediaType> parseMediaTypes(@Nullable List<String> mediaTypes) { if (CollectionUtils.isEmpty(mediaTypes)) { return Collections.emptyList(); } else if (mediaTypes.size() == 1) { return parseMediaTypes(mediaTypes.get(0)); } else { List<MediaType> result = new ArrayList<>(8); for (String mediaType : mediaTypes) { result.addAll(parseMediaTypes(mediaType)); } return result; } }
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; }
private static Set<ConsumeMediaTypeExpression> parseExpressions(String[] consumes, @Nullable String[] headers) { Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<>(); if (headers != null) { for (String header : headers) { HeaderExpression expr = new HeaderExpression(header); if ("Content-Type".equalsIgnoreCase(expr.name) && expr.value != null) { for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) { result.add(new ConsumeMediaTypeExpression(mediaType, expr.isNegated)); } } } } for (String consume : consumes) { result.add(new ConsumeMediaTypeExpression(consume)); } return result; }
/** * Return the list of acceptable {@linkplain MediaType media types}, * as specified by the {@code Accept} header. * <p>Returns an empty list when the acceptable media types are unspecified. */ public List<MediaType> getAccept() { return MediaType.parseMediaTypes(get(ACCEPT)); }
private static Set<ConsumeMediaTypeExpression> parseExpressions(String[] consumes, String[] headers) { Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<>(); if (headers != null) { for (String header : headers) { HeadersRequestCondition.HeaderExpression expr = new HeadersRequestCondition.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; }
private Set<ProduceMediaTypeExpression> parseExpressions(String[] produces, String[] headers) { Set<ProduceMediaTypeExpression> result = new LinkedHashSet<>(); if (headers != null) { for (String header : headers) { HeadersRequestCondition.HeaderExpression expr = new HeadersRequestCondition.HeaderExpression(header); if ("Accept".equalsIgnoreCase(expr.name)) { for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) { result.add(new ProduceMediaTypeExpression(mediaType, expr.isNegated)); } } } } if (produces != null) { for (String produce : produces) { result.add(new ProduceMediaTypeExpression(produce)); } } return result; }
/** * Parse the given list of (potentially) comma-separated strings into a * list of {@code MediaType} objects. * <p>This method can be used to parse an Accept or Content-Type header. * @param mediaTypes the string to parse * @return the list of media types * @throws InvalidMediaTypeException if the media type value cannot be parsed * @since 4.3.2 */ public static List<MediaType> parseMediaTypes(@Nullable List<String> mediaTypes) { if (CollectionUtils.isEmpty(mediaTypes)) { return Collections.emptyList(); } else if (mediaTypes.size() == 1) { return parseMediaTypes(mediaTypes.get(0)); } else { List<MediaType> result = new ArrayList<>(8); for (String mediaType : mediaTypes) { result.addAll(parseMediaTypes(mediaType)); } return result; } }
protected boolean wantJson(HttpServletRequest request) { String accept = request.getHeader("Accept"); boolean json = false; if (StringUtils.hasText(accept)) { for (MediaType mediaType : MediaType.parseMediaTypes(accept)) { if (mediaType.equals(MediaType.APPLICATION_JSON)) { json = true; break; } } } return json; }
private MediaType getMediaTypes(HttpServletRequest request) { String acceptHeader = request.getHeader(ACCEPT_HEADER); if (StringUtils.hasText(acceptHeader)) { try { List<MediaType> acceptableMediaTypes = MediaType.parseMediaTypes(acceptHeader); return acceptableMediaTypes.isEmpty() ? null : acceptableMediaTypes.get(0); } catch (IllegalArgumentException ex) { if (logger.isDebugEnabled()) { logger.debug("Could not parse accept header [" + acceptHeader + "]: " + ex.getMessage()); } return null; } } return null; }
protected boolean acceptsJson(HttpServletRequest request) { List<MediaType> mediaTypes = MediaType.parseMediaTypes(request.getHeader(HttpHeaders.ACCEPT)); return mediaTypes.stream().anyMatch(m -> m.isCompatibleWith(MediaType.APPLICATION_JSON)); }
public ContentTypeAwareResponse getResponse(HttpServletRequest request) { try { List<MediaType> mediaTypes = MediaType.parseMediaTypes(request.getHeader("Accept")); MediaType.sortBySpecificityAndQuality(mediaTypes); for (MediaType mediaType : mediaTypes) { final ContentTypeAwareResponse accessDeniedHandler = ACCESS_DENIED_HANDLER_MAP.get(mediaType.removeQualityValue()); if (accessDeniedHandler != null) { return accessDeniedHandler; } } } catch (Exception ignore) { } if (request.getRequestURI().endsWith(".xml")) { return APPLICATION_XML_REQUEST_HANDLER; } return JSON_ACCESS_DENIED_HANDLER; } }
/** * {@inheritDoc} * @throws HttpMediaTypeNotAcceptableException if the 'Accept' header cannot be parsed */ @Override public List<MediaType> resolveMediaTypes(NativeWebRequest request) throws HttpMediaTypeNotAcceptableException { String[] headerValueArray = request.getHeaderValues(HttpHeaders.ACCEPT); if (headerValueArray == null) { return MEDIA_TYPE_ALL_LIST; } List<String> headerValues = Arrays.asList(headerValueArray); try { List<MediaType> mediaTypes = MediaType.parseMediaTypes(headerValues); MediaType.sortBySpecificityAndQuality(mediaTypes); return !CollectionUtils.isEmpty(mediaTypes) ? mediaTypes : MEDIA_TYPE_ALL_LIST; } catch (InvalidMediaTypeException ex) { throw new HttpMediaTypeNotAcceptableException( "Could not parse 'Accept' header " + headerValues + ": " + ex.getMessage()); } }
private boolean matchesAcceptHeader(String requestValue, List<String> expectedValues) { // Accept header is not required to be checked! if (requestValue == null) { return true; } List<MediaType> requestValues = MediaType.parseMediaTypes(requestValue); for (String expectedValue : expectedValues) { if (MediaType.parseMediaType(expectedValue).includes(requestValues.get(0))) { return true; } } return false; }
private static Set<ConsumeMediaTypeExpression> parseExpressions(String[] consumes, @Nullable String[] headers) { Set<ConsumeMediaTypeExpression> result = new LinkedHashSet<>(); if (headers != null) { for (String header : headers) { HeaderExpression expr = new HeaderExpression(header); if ("Content-Type".equalsIgnoreCase(expr.name) && expr.value != null) { for (MediaType mediaType : MediaType.parseMediaTypes(expr.value)) { result.add(new ConsumeMediaTypeExpression(mediaType, expr.isNegated)); } } } } for (String consume : consumes) { result.add(new ConsumeMediaTypeExpression(consume)); } return result; }
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; }
/** * Select the Accept header's value from the given accepts array: * if JSON exists in the given array, use it; * otherwise use all of them (joining into a string) * * @param accepts The accepts array to select from * @return List The list of MediaTypes to use for the Accept header */ public List<MediaType> selectHeaderAccept(String[] accepts) { if (accepts.length == 0) { return null; } for (String accept : accepts) { MediaType mediaType = MediaType.parseMediaType(accept); if (isJsonMime(mediaType)) { return Collections.singletonList(mediaType); } } return MediaType.parseMediaTypes(StringUtils.arrayToCommaDelimitedString(accepts)); }
@Test public void parseMediaTypes() throws Exception { String s = "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c"; List<MediaType> mediaTypes = MediaType.parseMediaTypes(s); assertNotNull("No media types returned", mediaTypes); assertEquals("Invalid amount of media types", 4, mediaTypes.size()); mediaTypes = MediaType.parseMediaTypes(""); assertNotNull("No media types returned", mediaTypes); assertEquals("Invalid amount of media types", 0, mediaTypes.size()); }
/** * {@inheritDoc} * @throws HttpMediaTypeNotAcceptableException if the 'Accept' header cannot be parsed */ @Override public List<MediaType> resolveMediaTypes(NativeWebRequest request) throws HttpMediaTypeNotAcceptableException { String[] headerValueArray = request.getHeaderValues(HttpHeaders.ACCEPT); if (headerValueArray == null) { return MEDIA_TYPE_ALL_LIST; } List<String> headerValues = Arrays.asList(headerValueArray); try { List<MediaType> mediaTypes = MediaType.parseMediaTypes(headerValues); MediaType.sortBySpecificityAndQuality(mediaTypes); return !CollectionUtils.isEmpty(mediaTypes) ? mediaTypes : MEDIA_TYPE_ALL_LIST; } catch (InvalidMediaTypeException ex) { throw new HttpMediaTypeNotAcceptableException( "Could not parse 'Accept' header " + headerValues + ": " + ex.getMessage()); } }
@Test public void acceptHeader() { this.builder.accept(MediaType.TEXT_HTML, MediaType.APPLICATION_XML); MockHttpServletRequest request = this.builder.buildRequest(this.servletContext); List<String> accept = Collections.list(request.getHeaders("Accept")); List<MediaType> result = MediaType.parseMediaTypes(accept.get(0)); assertEquals(1, accept.size()); assertEquals("text/html", result.get(0).toString()); assertEquals("application/xml", result.get(1).toString()); }