@NonNull private static List<MediaType> acceptedMediaTypes(ServerRequest.Headers headers) { List<MediaType> acceptedMediaTypes = headers.accept(); if (acceptedMediaTypes.isEmpty()) { acceptedMediaTypes = Collections.singletonList(MediaType.ALL); } else { MediaType.sortBySpecificityAndQuality(acceptedMediaTypes); } return acceptedMediaTypes; }
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()); } }
MediaType.sortBySpecificityAndQuality(selectedMediaTypes); return selectedMediaTypes;
MediaType.sortBySpecificityAndQuality(result);
@Override public List<MediaType> resolveMediaTypes(ServerWebExchange exchange) throws NotAcceptableStatusException { try { List<MediaType> mediaTypes = exchange.getRequest().getHeaders().getAccept(); MediaType.sortBySpecificityAndQuality(mediaTypes); return (!CollectionUtils.isEmpty(mediaTypes) ? mediaTypes : MEDIA_TYPE_ALL_LIST); } catch (InvalidMediaTypeException ex) { String value = exchange.getRequest().getHeaders().getFirst("Accept"); throw new NotAcceptableStatusException( "Could not parse 'Accept' header [" + value + "]: " + ex.getMessage()); } }
MediaType.sortBySpecificityAndQuality(selectedMediaTypes); return selectedMediaTypes;
/** * {@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()); } }
MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
MediaType.sortBySpecificityAndQuality(mediaTypes);
MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
private MediaType selectMediaType(ServerWebExchange exchange, Supplier<List<MediaType>> producibleTypesSupplier) { List<MediaType> acceptableTypes = getAcceptableTypes(exchange); List<MediaType> producibleTypes = getProducibleTypes(exchange, producibleTypesSupplier); Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>(); for (MediaType acceptable : acceptableTypes) { for (MediaType producible : producibleTypes) { if (acceptable.isCompatibleWith(producible)) { compatibleMediaTypes.add(selectMoreSpecificMediaType(acceptable, producible)); } } } List<MediaType> result = new ArrayList<>(compatibleMediaTypes); MediaType.sortBySpecificityAndQuality(result); for (MediaType mediaType : result) { if (mediaType.isConcrete()) { return mediaType; } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION_ALL)) { return MediaType.APPLICATION_OCTET_STREAM; } } return null; }
/** * Return a {@code RequestPredicate} that tests if the request's * {@linkplain ServerRequest.Headers#accept() accept} header is * {@linkplain MediaType#isCompatibleWith(MediaType) compatible} with any of the given media types. * * @param mediaTypes the media types to match the request's accept header against * @return a predicate that tests the request's accept header against the given media types */ public static RequestPredicate accept(MediaType... mediaTypes) { Assert.notEmpty(mediaTypes, "'mediaTypes' must not be empty"); Set<MediaType> mediaTypeSet = new HashSet<>(Arrays.asList(mediaTypes)); return headers(headers -> { List<MediaType> acceptedMediaTypes = headers.accept(); MediaType.sortBySpecificityAndQuality(acceptedMediaTypes); return acceptedMediaTypes.stream() .anyMatch(acceptedMediaType -> mediaTypeSet.stream() .anyMatch(acceptedMediaType::isCompatibleWith)); }); }
private List<MediaType> resolveMediaTypes(HttpServletRequest request) throws HttpMediaTypeNotAcceptableException { Enumeration<String> headerValueArray = request.getHeaders(HttpHeaders.ACCEPT); if (headerValueArray == null) { return Collections.<MediaType>emptyList(); } List<String> headerValues = Collections.list(headerValueArray); try { List<MediaType> mediaTypes = MediaType.parseMediaTypes(headerValues); MediaType.sortBySpecificityAndQuality(mediaTypes); return mediaTypes; } catch (InvalidMediaTypeException ex) { throw new HttpMediaTypeNotAcceptableException( "Could not parse 'Accept' header " + headerValues + ": " + ex.getMessage()); } }
if (null != acceptHeader) { List<MediaType> requestedTypes = MediaType.parseMediaTypes(acceptHeader); MediaType.sortBySpecificityAndQuality(requestedTypes); LOG.trace("Acceptable response types: {}", MediaType.toString(requestedTypes)); for (MediaType t : requestedTypes) {
/** * {@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()); } }
/** * {@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()); } }
public TextWebSocketFrame toWebSocketResponse(String acceptHeader) throws Exception { MediaType negotiatedType = MediaType.TEXT_HTML; if (null != acceptHeader) { List<MediaType> requestedTypes = MediaType.parseMediaTypes(acceptHeader); MediaType.sortBySpecificityAndQuality(requestedTypes); LOG.trace("Acceptable response types: {}", MediaType.toString(requestedTypes)); for (MediaType t : requestedTypes) { if (t.includes(MediaType.TEXT_HTML)) { negotiatedType = MediaType.TEXT_HTML; LOG.trace("{} allows HTML", t.toString()); break; } if (t.includes(MediaType.APPLICATION_JSON)) { negotiatedType = MediaType.APPLICATION_JSON; LOG.trace("{} allows JSON", t.toString()); break; } } } String result = null; if (negotiatedType.equals(MediaType.APPLICATION_JSON)) { result = this.generateJson(JsonUtil.getObjectMapper()); } else { result = this.generateHtml().toString(); } return new TextWebSocketFrame(result); }
private List<MediaType> resolveMediaTypes(ServerWebExchange exchange) throws NotAcceptableStatusException { try { List<MediaType> mediaTypes = exchange.getRequest().getHeaders().getAccept(); MediaType.sortBySpecificityAndQuality(mediaTypes); return mediaTypes; } catch (InvalidMediaTypeException ex) { String value = exchange.getRequest().getHeaders().getFirst("Accept"); throw new NotAcceptableStatusException( "Could not parse 'Accept' header [" + value + "]: " + ex.getMessage()); } }
@Override public List<MediaType> resolveMediaTypes(ServerWebExchange exchange) throws NotAcceptableStatusException { try { List<MediaType> mediaTypes = exchange.getRequest().getHeaders().getAccept(); MediaType.sortBySpecificityAndQuality(mediaTypes); return mediaTypes; } catch (InvalidMediaTypeException ex) { String value = exchange.getRequest().getHeaders().getFirst("Accept"); throw new NotAcceptableStatusException( "Could not parse 'Accept' header [" + value + "]: " + ex.getMessage()); } }