Example usage for org.springframework.web HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException

Introduction

In this page you can find the example usage for org.springframework.web HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException.

Prototype

public HttpMediaTypeNotSupportedException(String message) 

Source Link

Document

Create a new HttpMediaTypeNotSupportedException.

Usage

From source file:org.openinfobutton.responder.controller.OpenInfobuttonResponderController.java

/**
 *
 * @param request/*  w  w w  .j  a  v a  2s  .c  o m*/
 * @param response
 * @param model
 * @return
 * @throws MissingServletRequestParameterException
 * @throws HttpMediaTypeNotSupportedException
 * @throws IllegalArgumentException
 */
@RequestMapping("/responder")
public String openInfobuttonRequestHandler(final HttpServletRequest request, final HttpServletResponse response,
        final ModelMap model) throws MissingServletRequestParameterException,
        HttpMediaTypeNotSupportedException, IllegalArgumentException {

    response.setHeader("Cache-Control", "no-cache");
    // todo: if authorization is required return 401 when not authorized

    setRequiredResponseObjects();

    // throws IllegalArgumentException
    Map<String, String> requestParameters = responderService
            .getKnowledgeRequestParameterMap(request.getParameterMap());

    // throws MissingServletRequestParameterException
    responderService.requestContainsRequiredParameters(requestParameters);
    Collection<Asset> matchedAssets = responderService.findAssetsByInfobuttonRequest(requestParameters);

    model.addAttribute("atomFeedMetadata", this.atomFeedMetadata);
    model.addAttribute("indexPropertyInterpretationMap", this.indexPropertyInterpretationMap);
    model.addAttribute("requestParameters", requestParameters);
    model.addAttribute("assets", matchedAssets);

    String viewType = requestParameters.get("knowledgeResponseType");

    if (viewType == null) { // default
        return ATOM_PAGE;
    } else if ("text/html".equals(viewType)) {
        return HTML_PAGE;
    } else if ("text/xml".equals(viewType)) {
        return ATOM_PAGE;
    } else {
        throw new HttpMediaTypeNotSupportedException("Unsupported knowledgeResponseType: " + viewType);
    }

}

---

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

private Object readWithMessageConverters(MethodParameter methodParam, HttpInputMessage inputMessage,
        Class paramType) throws Exception {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        StringBuilder builder = new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
        String paramName = methodParam.getParameterName();
        if (paramName != null) {
            builder.append(' ');
            builder.append(paramName);/*from ww w  . j  ava  2s  . co  m*/
        }
        throw new HttpMediaTypeNotSupportedException(
                "Cannot extract parameter (" + builder.toString() + "): no Content-Type found");
    }

    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
            if (messageConverter.canRead(paramType, contentType)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Reading [" + paramType.getName() + "] as \"" + contentType + "\" using ["
                            + messageConverter + "]");
                }
                return messageConverter.read(paramType, inputMessage);
            }
        }
    }
    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
}

---

From source file:org.springframework.web.bind.annotation.support.HandlerMethodInvoker.java

@SuppressWarnings({ "unchecked", "rawtypes" })
private Object readWithMessageConverters(MethodParameter methodParam, HttpInputMessage inputMessage,
        Class<?> paramType) throws Exception {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        StringBuilder builder = new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
        String paramName = methodParam.getParameterName();
        if (paramName != null) {
            builder.append(' ');
            builder.append(paramName);/*from www. j a va2 s.  c o m*/
        }
        throw new HttpMediaTypeNotSupportedException(
                "Cannot extract parameter (" + builder.toString() + "): no Content-Type found");
    }

    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
            if (messageConverter.canRead(paramType, contentType)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Reading [" + paramType.getName() + "] as \"" + contentType + "\" using ["
                            + messageConverter + "]");
                }
                return messageConverter.read((Class) paramType, inputMessage);
            }
        }
    }
    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
}

---

From source file:org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver.java

/**
 * Create the method argument value of the expected parameter type by reading
 * from the given HttpInputMessage./*w w  w .j ava2 s. c  om*/
 * @param <T> the expected type of the argument value to be created
 * @param inputMessage the HTTP input message representing the current request
 * @param parameter the method parameter descriptor
 * @param targetType the target type, not necessarily the same as the method
 * parameter type, e.g. for {@code HttpEntity<String>}.
 * @return the created method argument value
 * @throws IOException if the reading from the request fails
 * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
 */
@SuppressWarnings("unchecked")
@Nullable
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
        Type targetType)
        throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

    MediaType contentType;
    boolean noContentType = false;
    try {
        contentType = inputMessage.getHeaders().getContentType();
    } catch (InvalidMediaTypeException ex) {
        throw new HttpMediaTypeNotSupportedException(ex.getMessage());
    }
    if (contentType == null) {
        noContentType = true;
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    }

    Class<?> contextClass = parameter.getContainingClass();
    Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);
    if (targetClass == null) {
        ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
        targetClass = (Class<T>) resolvableType.resolve();
    }

    HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod()
            : null);
    Object body = NO_VALUE;

    EmptyBodyCheckingHttpInputMessage message;
    try {
        message = new EmptyBodyCheckingHttpInputMessage(inputMessage);

        for (HttpMessageConverter<?> converter : this.messageConverters) {
            Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter
                    .getClass();
            GenericHttpMessageConverter<?> genericConverter = (converter instanceof GenericHttpMessageConverter
                    ? (GenericHttpMessageConverter<?>) converter
                    : null);
            if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType)
                    : (targetClass != null && converter.canRead(targetClass, contentType))) {
                if (logger.isDebugEnabled()) {
                    logger.debug(
                            "Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                }
                if (message.hasBody()) {
                    HttpInputMessage msgToUse = getAdvice().beforeBodyRead(message, parameter, targetType,
                            converterType);
                    body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse)
                            : ((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
                    body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
                } else {
                    body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
                }
                break;
            }
        }
    } catch (IOException ex) {
        throw new HttpMessageNotReadableException("I/O error while reading input message", ex);
    }

    if (body == NO_VALUE) {
        if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod)
                || (noContentType && !message.hasBody())) {
            return null;
        }
        throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
    }

    return body;
}

---

From source file:org.springframework.web.servlet.mvc.method.annotation.support.AbstractMessageConverterMethodProcessor.java

@SuppressWarnings("unchecked")
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter methodParam,
        Class<T> paramType) throws IOException, HttpMediaTypeNotSupportedException {

    HttpInputMessage inputMessage = createInputMessage(webRequest);

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        StringBuilder builder = new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
        String paramName = methodParam.getParameterName();
        if (paramName != null) {
            builder.append(' ');
            builder.append(paramName);/*w  w w  . ja  va2  s . c o  m*/
        }
        throw new HttpMediaTypeNotSupportedException("Cannot read parameter (" + builder.toString()
                + ") using HttpMessageConverters: no Content-Type found in HTTP request");
    }

    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
            if (messageConverter.canRead(paramType, contentType)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Reading [" + paramType.getName() + "] as \"" + contentType + "\" using ["
                            + messageConverter + "]");
                }
                return ((HttpMessageConverter<T>) messageConverter).read(paramType, inputMessage);
            }
        }
    }

    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
}

---