Example usage for org.springframework.http.converter HttpMessageConverter canWrite

List of usage examples for org.springframework.http.converter HttpMessageConverter canWrite

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.http.converter.*
  5. HttpMessageConverter
  6. canWrite

Introduction

In this page you can find the example usage for org.springframework.http.converter HttpMessageConverter canWrite.

Prototype

boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

Source Link

Document

Indicates whether the given class can be written by this converter.

Usage

From source file:org.infoscoop.api.oauth2.provider.ISOAuth2ExceptionRenderer.java

@SuppressWarnings({ "unchecked", "rawtypes" })
private void writeWithMessageConverters(Object returnValue, HttpInputMessage inputMessage,
        HttpOutputMessage outputMessage, HttpStatus status, HttpServletRequest request)
        throws IOException, HttpMediaTypeNotAcceptableException {
    log.info(request.getRemoteAddr() + " " + returnValue + " " + status.value());

    Class<?> returnValueType = returnValue.getClass();
    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();

    String fileType = request.getPathInfo();
    MediaType acceptedMediaType = MediaType.APPLICATION_JSON;
    if (fileType.substring(fileType.lastIndexOf(".") + 1).equals("xml"))
        acceptedMediaType = MediaType.APPLICATION_XML;

    for (HttpMessageConverter messageConverter : messageConverters) {
        if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
            messageConverter.write(returnValue, acceptedMediaType, outputMessage);
            if (log.isDebugEnabled()) {
                MediaType contentType = outputMessage.getHeaders().getContentType();
                if (contentType == null) {
                    contentType = acceptedMediaType;
                }/*from   ww w . ja  v a  2 s  .c  o  m*/
                log.debug("Written [" + returnValue + "] as \"" + contentType + "\" using [" + messageConverter
                        + "]");
            }
            return;
        }
    }

    for (HttpMessageConverter messageConverter : messageConverters) {
        allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
    }
    throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
}

From source file:org.springframework.boot.actuate.endpoint.mvc.EndpointHandlerAdapter.java

@SuppressWarnings("unchecked")
private void handle(HttpServletRequest request, HttpServletResponse response, Endpoint<?> endpoint)
        throws Exception {

    Object result = endpoint.invoke();
    Class<?> resultClass = result.getClass();

    List<MediaType> mediaTypes = getMediaTypes(request, endpoint, resultClass);
    MediaType selectedMediaType = selectMediaType(mediaTypes);

    ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(response);
    try {/*  w  w w.j  av a2 s .c  o m*/
        if (selectedMediaType != null) {
            selectedMediaType = selectedMediaType.removeQualityValue();
            for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                if (messageConverter.canWrite(resultClass, selectedMediaType)) {
                    ((HttpMessageConverter<Object>) messageConverter).write(result, selectedMediaType,
                            outputMessage);
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Written [" + result + "] as \"" + selectedMediaType + "\" using ["
                                + messageConverter + "]");
                    }
                    return;
                }
            }
        }
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    } finally {
        outputMessage.close();
    }
}

From source file:org.springframework.boot.actuate.endpoint.mvc.EndpointHandlerAdapter.java

private List<MediaType> getProducibleMediaTypes(Endpoint<?> endpoint, Class<?> returnValueClass) {
    MediaType[] mediaTypes = endpoint.produces();
    if (mediaTypes != null && mediaTypes.length != 0) {
        return Arrays.asList(mediaTypes);
    }//  w w  w . ja  va  2 s.  c  om

    if (this.allSupportedMediaTypes.isEmpty()) {
        return Collections.singletonList(MediaType.ALL);
    }

    List<MediaType> result = new ArrayList<MediaType>();
    for (HttpMessageConverter<?> converter : this.messageConverters) {
        if (converter.canWrite(returnValueClass, null)) {
            result.addAll(converter.getSupportedMediaTypes());
        }
    }
    return result;
}

From source file:org.springframework.boot.ops.endpoint.mvc.EndpointHandlerAdapter.java

private List<MediaType> getProducibleMediaTypes(Endpoint<?> endpoint, Class<?> returnValueClass) {
    MediaType[] mediaTypes = endpoint.getProduces();
    if (mediaTypes != null && mediaTypes.length != 0) {
        return Arrays.asList(mediaTypes);
    }/*w  w  w .j  a  v  a  2  s  .  c om*/

    if (this.allSupportedMediaTypes.isEmpty()) {
        return Collections.singletonList(MediaType.ALL);
    }

    List<MediaType> result = new ArrayList<MediaType>();
    for (HttpMessageConverter<?> converter : this.messageConverters) {
        if (converter.canWrite(returnValueClass, null)) {
            result.addAll(converter.getSupportedMediaTypes());
        }
    }
    return result;
}

From source file:org.springframework.cloud.netflix.feign.support.SpringEncoder.java

@Override
public void encode(Object requestBody, Type bodyType, RequestTemplate request) throws EncodeException {
    // template.body(conversionService.convert(object, String.class));
    if (requestBody != null) {
        Class<?> requestType = requestBody.getClass();
        Collection<String> contentTypes = request.headers().get("Content-Type");

        MediaType requestContentType = null;
        if (contentTypes != null && !contentTypes.isEmpty()) {
            String type = contentTypes.iterator().next();
            requestContentType = MediaType.valueOf(type);
        }/*from   w  ww .j a va2 s  . c o  m*/

        for (HttpMessageConverter<?> messageConverter : this.messageConverters.getObject().getConverters()) {
            if (messageConverter.canWrite(requestType, requestContentType)) {
                if (log.isDebugEnabled()) {
                    if (requestContentType != null) {
                        log.debug("Writing [" + requestBody + "] as \"" + requestContentType + "\" using ["
                                + messageConverter + "]");
                    } else {
                        log.debug("Writing [" + requestBody + "] using [" + messageConverter + "]");
                    }

                }

                FeignOutputMessage outputMessage = new FeignOutputMessage(request);
                try {
                    @SuppressWarnings("unchecked")
                    HttpMessageConverter<Object> copy = (HttpMessageConverter<Object>) messageConverter;
                    copy.write(requestBody, requestContentType, outputMessage);
                } catch (IOException ex) {
                    throw new EncodeException("Error converting request body", ex);
                }
                // clear headers
                request.headers(null);
                // converters can modify headers, so update the request
                // with the modified headers
                request.headers(getHeaders(outputMessage.getHeaders()));

                // do not use charset for binary data
                if (messageConverter instanceof ByteArrayHttpMessageConverter) {
                    request.body(outputMessage.getOutputStream().toByteArray(), null);
                } else {
                    request.body(outputMessage.getOutputStream().toByteArray(), Charset.forName("UTF-8"));
                }
                return;
            }
        }
        String message = "Could not write request: no suitable HttpMessageConverter "
                + "found for request type [" + requestType.getName() + "]";
        if (requestContentType != null) {
            message += " and content type [" + requestContentType + "]";
        }
        throw new EncodeException(message);
    }
}

From source file:org.springframework.http.converter.FormHttpMessageConverter.java

@SuppressWarnings("unchecked")
private void writePart(String name, HttpEntity<?> partEntity, OutputStream os) throws IOException {
    Object partBody = partEntity.getBody();
    if (partBody == null) {
        throw new IllegalStateException("Empty body for part '" + name + "': " + partEntity);
    }/*from w ww  .j a  v  a 2 s. c o m*/
    Class<?> partType = partBody.getClass();
    HttpHeaders partHeaders = partEntity.getHeaders();
    MediaType partContentType = partHeaders.getContentType();
    for (HttpMessageConverter<?> messageConverter : this.partConverters) {
        if (messageConverter.canWrite(partType, partContentType)) {
            Charset charset = isFilenameCharsetSet() ? StandardCharsets.US_ASCII : this.charset;
            HttpOutputMessage multipartMessage = new MultipartHttpOutputMessage(os, charset);
            multipartMessage.getHeaders().setContentDispositionFormData(name, getFilename(partBody));
            if (!partHeaders.isEmpty()) {
                multipartMessage.getHeaders().putAll(partHeaders);
            }
            ((HttpMessageConverter<Object>) messageConverter).write(partBody, partContentType,
                    multipartMessage);
            return;
        }
    }
    throw new HttpMessageNotWritableException("Could not write request: no suitable HttpMessageConverter "
            + "found for request type [" + partType.getName() + "]");
}

From source file:org.springframework.security.oauth2.provider.error.DefaultOAuth2ExceptionRenderer.java

@SuppressWarnings({ "unchecked", "rawtypes" })
private void writeWithMessageConverters(Object returnValue, HttpInputMessage inputMessage,
        HttpOutputMessage outputMessage) throws IOException, HttpMediaTypeNotAcceptableException {
    List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
    if (acceptedMediaTypes.isEmpty()) {
        acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
    }//from  ww w  .ja v a 2s. c  o  m
    MediaType.sortByQualityValue(acceptedMediaTypes);
    Class<?> returnValueType = returnValue.getClass();
    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    for (MediaType acceptedMediaType : acceptedMediaTypes) {
        for (HttpMessageConverter messageConverter : messageConverters) {
            if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
                messageConverter.write(returnValue, acceptedMediaType, outputMessage);
                if (logger.isDebugEnabled()) {
                    MediaType contentType = outputMessage.getHeaders().getContentType();
                    if (contentType == null) {
                        contentType = acceptedMediaType;
                    }
                    logger.debug("Written [" + returnValue + "] as \"" + contentType + "\" using ["
                            + messageConverter + "]");
                }
                return;
            }
        }
    }
    for (HttpMessageConverter messageConverter : messageConverters) {
        allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
    }
    throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
}

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

@SuppressWarnings("unchecked")
protected <T> void writeWithMessageConverters(T returnValue, HttpInputMessage inputMessage,
        HttpOutputMessage outputMessage) throws IOException, HttpMediaTypeNotAcceptableException {

    List<MediaType> acceptedMediaTypes = getAcceptedMediaTypes(inputMessage);

    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
        for (MediaType acceptedMediaType : acceptedMediaTypes) {
            for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                if (!messageConverter.canWrite(returnValue.getClass(), acceptedMediaType)) {
                    continue;
                }//  w  w  w  .j a  v a  2  s  .  c  o m
                ((HttpMessageConverter<T>) messageConverter).write(returnValue, acceptedMediaType,
                        outputMessage);
                if (logger.isDebugEnabled()) {
                    MediaType contentType = outputMessage.getHeaders().getContentType();
                    if (contentType == null) {
                        contentType = acceptedMediaType;
                    }
                    logger.debug("Written [" + returnValue + "] as \"" + contentType + "\" using ["
                            + messageConverter + "]");
                }
                return;
            }
        }
        for (HttpMessageConverter<?> messageConverter : messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
        }
    }
    throw new HttpMediaTypeNotAcceptableException(allSupportedMediaTypes);
}