Java 类org.springframework.http.HttpInputMessage 实例源码

@Override
protected ApplicationLogs readInternal(Class<? extends ApplicationLogs> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {
    String boundary = getMessageBoundary(inputMessage);

    Multipart multipart = new Multipart(inputMessage.getBody(), boundary);

    ApplicationLogs logs = new ApplicationLogs();

    Multipart.Part part;
    while ((part = multipart.nextPart()) != null) {
        ApplicationLog log = messageParser.parseMessage(part.getContent());
        logs.add(log);
    }

    return logs;
}

public EmptyBodyCheckingHttpInputMessage(HttpInputMessage inputMessage) throws IOException {
    this.headers = inputMessage.getHeaders();
    InputStream inputStream = inputMessage.getBody();
    if (inputStream == null) {
        this.body = null;
    }
    else if (inputStream.markSupported()) {
        inputStream.mark(1);
        this.body = (inputStream.read() != -1 ? inputStream : null);
        inputStream.reset();
    }
    else {
        PushbackInputStream pushbackInputStream = new PushbackInputStream(inputStream);
        int b = pushbackInputStream.read();
        if (b == -1) {
            this.body = null;
        }
        else {
            this.body = pushbackInputStream;
            pushbackInputStream.unread(b);
        }
    }
    this.method = ((HttpRequest) inputMessage).getMethod();
}

/**
 * Unwrap a wrapped response created by Vault Response Wrapping
 *
 * @param wrappedResponse the wrapped response , must not be empty or {@literal null}.
 * @param responseType the type of the return value.
 * @return the unwrapped response.
 */
@SuppressWarnings("unchecked")
public static <T> T unwrap(final String wrappedResponse, Class<T> responseType) {

    Assert.hasText(wrappedResponse, "Wrapped response must not be empty");

    try {
        return (T) converter.read(responseType, new HttpInputMessage() {
            @Override
            public InputStream getBody() throws IOException {
                return new ByteArrayInputStream(wrappedResponse.getBytes());
            }

            @Override
            public HttpHeaders getHeaders() {
                return new HttpHeaders();
            }
        });
    }
    catch (IOException e) {
        throw new IllegalStateException(e);
    }
}

@SuppressWarnings("deprecation")
private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
    try {
        if (inputMessage instanceof MappingJacksonInputMessage) {
            Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
            if (deserializationView != null) {
                return this.objectMapper.readerWithView(deserializationView).withType(javaType).
                        readValue(inputMessage.getBody());
            }
        }
        return this.objectMapper.readValue(inputMessage.getBody(), javaType);
    }
    catch (IOException ex) {
        throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
    }
}

@Override
protected void doFilterInternal(final HttpServletRequest request, HttpServletResponse response,
        FilterChain filterChain) throws ServletException, IOException {

    if (("PUT".equals(request.getMethod()) || "PATCH".equals(request.getMethod())) && isFormContentType(request)) {
        HttpInputMessage inputMessage = new ServletServerHttpRequest(request) {
            @Override
            public InputStream getBody() throws IOException {
                return request.getInputStream();
            }
        };
        MultiValueMap<String, String> formParameters = formConverter.read(null, inputMessage);
        HttpServletRequest wrapper = new HttpPutFormContentRequestWrapper(request, formParameters);
        filterChain.doFilter(wrapper, response);
    }
    else {
        filterChain.doFilter(request, response);
    }
}

@Override
@SuppressWarnings("unchecked")
protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    WireFeedInput feedInput = new WireFeedInput();
    MediaType contentType = inputMessage.getHeaders().getContentType();
    Charset charset;
    if (contentType != null && contentType.getCharSet() != null) {
        charset = contentType.getCharSet();
    } else {
        charset = DEFAULT_CHARSET;
    }
    try {
        Reader reader = new InputStreamReader(inputMessage.getBody(), charset);
        return (T) feedInput.build(reader);
    }
    catch (FeedException ex) {
        throw new HttpMessageNotReadableException("Could not read WireFeed: " + ex.getMessage(), ex);
    }
}

@Override
@SuppressWarnings("unchecked")
protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    InputStream body = inputMessage.getBody();
    if (DOMSource.class.equals(clazz)) {
        return (T) readDOMSource(body);
    }
    else if (SAXSource.class.equals(clazz)) {
        return (T) readSAXSource(body);
    }
    else if (StAXSource.class.equals(clazz)) {
        return (T) readStAXSource(body);
    }
    else if (StreamSource.class.equals(clazz) || Source.class.equals(clazz)) {
        return (T) readStreamSource(body);
    }
    else {
        throw new HttpMessageConversionException("Could not read class [" + clazz +
                "]. Only DOMSource, SAXSource, StAXSource, and StreamSource are supported.");
    }
}

public void handleHttpEntityResponse(HttpEntity<?> responseEntity, ServletWebRequest webRequest) throws Exception {
    if (responseEntity == null) {
        return;
    }

    HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
    HttpOutputMessage outputMessage = createHttpOutputMessage(webRequest);
    if (responseEntity instanceof ResponseEntity && outputMessage instanceof ServerHttpResponse) {
        ((ServerHttpResponse) outputMessage).setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode());
    }

    HttpHeaders entityHeaders = responseEntity.getHeaders();
    if (!entityHeaders.isEmpty()) {
        outputMessage.getHeaders().putAll(entityHeaders);
    }

    Object body = responseEntity.getBody();
    if (body != null) {
        writeWithMessageConverters(body, inputMessage, outputMessage);
    }
    else {
        outputMessage.getBody();
    }
}

@Override
    protected Resource readInternal(Class<? extends Resource> clazz, HttpInputMessage inputMessage)
            throws IOException, HttpMessageNotReadableException {

        WxMediaResource wxMediaResource = new WxMediaResource(inputMessage);
        if (wxMediaResource.isUrlMedia() && !clazz.isAssignableFrom(WxMediaResource.class)) {
            throw new WxApiException("不支持的返回类型，接口返回了url");
        }
        if (InputStreamResource.class == clazz) {
            return new InputStreamResource(wxMediaResource.getInputStream());
        } else if (clazz.isAssignableFrom(WxMediaResource.class)) {
            return wxMediaResource;
        } else if (clazz.isAssignableFrom(ByteArrayResource.class)) {
            return new ByteArrayResource(wxMediaResource.getBody());
        } else if (clazz.isAssignableFrom(FileSystemResource.class)) {
            return new FileSystemResource(wxMediaResource.getFile());
        }
//      else if (clazz.isAssignableFrom(File.class)) {
//          return wxMediaResource.getFile();
//      }
        throw new WxApiException("不支持的返回类型");
    }

public <T> T extractData(ResponseEntity<HttpInputMessage> responseEntity, Class<T> returnType) {
    // 本来应该有response数据为空的判断的，其实这里已经被前一步的restTemplate获取中判断过了，这里只用判断body为空即可
    if (returnType == null || void.class == returnType || Void.class == returnType || responseEntity.getBody() == null) {
        return null;
    }
    /* 先不管文件
    if (WxWebUtils.isMutlipart(returnType)) {
        return null;
    }
    不是不管文件，而是可以被messageConverter处理了
    */
    WxApiMessageConverterExtractor<T> delegate = delegates.get(returnType);
    if (delegate == null) {
        delegate = new WxApiMessageConverterExtractor(returnType, converters);
        delegates.put(returnType, delegate);
    }
    // 这里遇到了个坑，很长时间没玩过IO了，这个坑就和IO相关，每次提取数据时都抛出IO异常，IO已关闭
    // 本来以为是我的error判断那里提前读了IO导致后来IO关闭了，调试后发现真正原因，因为
    // ResponseEntity<HttpInputMessage> responseEntity = wxApiInvoker.exchange(requestEntity, HttpInputMessage.class);
    // 上面代码执行结束后，有个finally，就是用于关闭response的，也就是说，一旦执行结束就无法再执行提取数据的操作了
    // 所以我只能把WxHttpInputMessageConverter里返回的inputStream包装一下了
    // 这里还涉及一个问题，是否有必要把所有消息都返回inputStream？当然没有必要，只要特定几种类型返回InputStream
    // 其他类型直接转换即可。
    try {
        return delegate.extractData(responseEntity);
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
        throw new WxApiResponseException("提取数据时发生IO异常", responseEntity);
    }
}

@Override
public T extractData(ResponseEntity<HttpInputMessage> responseEntity) throws IOException {
    MediaType contentType = getContentType(responseEntity);
    for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
        if (messageConverter instanceof GenericHttpMessageConverter) {
            GenericHttpMessageConverter<?> genericMessageConverter =
                    (GenericHttpMessageConverter<?>) messageConverter;
            if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
                return (T) genericMessageConverter.read(this.responseType, null, responseEntity.getBody());
            }
        }
        if (this.responseClass != null) {
            if (messageConverter.canRead(this.responseClass, contentType)) {
                return (T) messageConverter.read((Class) this.responseClass, responseEntity.getBody());
            }
        }
    }

    throw new WxApiResponseException("不能转换相应数据为类型：" + this.responseType, responseEntity);
}

@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (MEDIA_TYPE.isCompatibleWith(contentType)) {
        final Schema<?> schema = getSchema(clazz);
        final Object value = schema.newMessage();

        try (final InputStream stream = inputMessage.getBody()) {
            ProtobufIOUtil.mergeFrom(stream, value, (Schema<Object>) schema);
            return value;
        }
    }

    throw new HttpMessageNotReadableException(
            "Unrecognized HTTP media type " + inputMessage.getHeaders().getContentType().getType() + ".");
}

@Override
public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    InputStream in = inputMessage.getBody();
    byte[] buf = new byte[1024];
    for (; ; ) {
        int len = in.read(buf);
        if (len == -1) {
            break;
        }
        if (len > 0) {
            baos.write(buf, 0, len);
        }
    }
    byte[] bytes = baos.toByteArray();
    return readByBytes(type, bytes);
}

@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException,
        HttpMessageNotReadableException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    InputStream in = inputMessage.getBody();
    byte[] buf = new byte[1024];
    for (; ; ) {
        int len = in.read(buf);
        if (len == -1) {
            break;
        }
        if (len > 0) {
            baos.write(buf, 0, len);
        }
    }
    byte[] bytes = baos.toByteArray();
    return readByBytes(clazz, bytes);
}

private void handleHttpEntityResponse(HttpEntity<?> responseEntity, ServletWebRequest webRequest) throws Exception {
    if (responseEntity == null) {
        return;
    }
    HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
    HttpOutputMessage outputMessage = createHttpOutputMessage(webRequest);
    if (responseEntity instanceof ResponseEntity && outputMessage instanceof ServerHttpResponse) {
        ((ServerHttpResponse) outputMessage).setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode());
    }
    HttpHeaders entityHeaders = responseEntity.getHeaders();
    if (!entityHeaders.isEmpty()) {
        outputMessage.getHeaders().putAll(entityHeaders);
    }
    Object body = responseEntity.getBody();
    if (body != null) {
        writeWithMessageConverters(body, inputMessage, outputMessage);
    }
    else {
        // flush headers
        outputMessage.getBody();
    }
}

@SuppressWarnings("unchecked")
@Test
public void requestBodyAdvice() throws IOException {

    RequestBodyAdvice requestAdvice = Mockito.mock(RequestBodyAdvice.class);
    ResponseBodyAdvice<String> responseAdvice = Mockito.mock(ResponseBodyAdvice.class);
    List<Object> advice = Arrays.asList(requestAdvice, responseAdvice);
    RequestResponseBodyAdviceChain chain = new RequestResponseBodyAdviceChain(advice);

    HttpInputMessage wrapped = new ServletServerHttpRequest(new MockHttpServletRequest());
    given(requestAdvice.supports(this.paramType, String.class, this.converterType)).willReturn(true);
    given(requestAdvice.beforeBodyRead(eq(this.request), eq(this.paramType), eq(String.class),
            eq(this.converterType))).willReturn(wrapped);

    assertSame(wrapped, chain.beforeBodyRead(this.request, this.paramType, String.class, this.converterType));

    String modified = "body++";
    given(requestAdvice.afterBodyRead(eq(this.body), eq(this.request), eq(this.paramType),
            eq(String.class), eq(this.converterType))).willReturn(modified);

    assertEquals(modified, chain.afterBodyRead(this.body, this.request, this.paramType,
            String.class, this.converterType));
}

@Test
public void resolveArgument() throws Exception {
    MediaType contentType = MediaType.TEXT_PLAIN;
    servletRequest.addHeader("Content-Type", contentType.toString());

    String body = "Foo";
    servletRequest.setContent(body.getBytes(Charset.forName("UTF-8")));

    given(messageConverter.canRead(String.class, contentType)).willReturn(true);
    given(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).willReturn(body);

    Object result = processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory());

    assertEquals("Invalid argument", body, result);
    assertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}

@Test
public void resolveArgument() throws Exception {
    String body = "Foo";

    MediaType contentType = MediaType.TEXT_PLAIN;
    servletRequest.addHeader("Content-Type", contentType.toString());
    servletRequest.setContent(body.getBytes(Charset.forName("UTF-8")));

    given(messageConverter.canRead(String.class, contentType)).willReturn(true);
    given(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).willReturn(body);

    Object result = processor.resolveArgument(paramHttpEntity, mavContainer, webRequest, null);

    assertTrue(result instanceof HttpEntity);
    assertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
    assertEquals("Invalid argument", body, ((HttpEntity<?>) result).getBody());
}

@Test
public void resolveArgumentRequestEntity() throws Exception {
    String body = "Foo";

    MediaType contentType = MediaType.TEXT_PLAIN;
    servletRequest.addHeader("Content-Type", contentType.toString());
    servletRequest.setMethod("GET");
    servletRequest.setServerName("www.example.com");
    servletRequest.setServerPort(80);
    servletRequest.setRequestURI("/path");
    servletRequest.setContent(body.getBytes(Charset.forName("UTF-8")));

    given(messageConverter.canRead(String.class, contentType)).willReturn(true);
    given(messageConverter.read(eq(String.class), isA(HttpInputMessage.class))).willReturn(body);

    Object result = processor.resolveArgument(paramRequestEntity, mavContainer, webRequest, null);

    assertTrue(result instanceof RequestEntity);
    assertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
    RequestEntity<?> requestEntity = (RequestEntity<?>) result;
    assertEquals("Invalid method", HttpMethod.GET, requestEntity.getMethod());
    assertEquals("Invalid url", new URI("http", null, "www.example.com", 80, "/path", null, null), requestEntity.getUrl());
    assertEquals("Invalid argument", body, requestEntity.getBody());
}

@SuppressWarnings("deprecation")
private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
    try {
        if (inputMessage instanceof MappingJacksonInputMessage) {
            Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
            if (deserializationView != null) {
                return this.objectMapper.readerWithView(deserializationView).withType(javaType).
                        readValue(inputMessage.getBody());
            }
        }
        return this.objectMapper.readValue(inputMessage.getBody(), javaType);
    }
    catch (IOException ex) {
        throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
    }
}

@Override
@SuppressWarnings("unchecked")
protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    WireFeedInput feedInput = new WireFeedInput();
    MediaType contentType = inputMessage.getHeaders().getContentType();
    Charset charset =
            (contentType != null && contentType.getCharSet() != null? contentType.getCharSet() : DEFAULT_CHARSET);
    try {
        Reader reader = new InputStreamReader(inputMessage.getBody(), charset);
        return (T) feedInput.build(reader);
    }
    catch (FeedException ex) {
        throw new HttpMessageNotReadableException("Could not read WireFeed: " + ex.getMessage(), ex);
    }
}

@Override
@SuppressWarnings("unchecked")
protected T readInternal(Class<? extends T> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    InputStream body = inputMessage.getBody();
    if (DOMSource.class == clazz) {
        return (T) readDOMSource(body);
    }
    else if (SAXSource.class == clazz) {
        return (T) readSAXSource(body);
    }
    else if (StAXSource.class == clazz) {
        return (T) readStAXSource(body);
    }
    else if (StreamSource.class == clazz || Source.class == clazz) {
        return (T) readStreamSource(body);
    }
    else {
        throw new HttpMessageConversionException("Could not read class [" + clazz +
                "]. Only DOMSource, SAXSource, StAXSource, and StreamSource are supported.");
    }
}

@Test
@SuppressWarnings("unchecked")
public void normal() throws IOException {
    HttpMessageConverter<String> converter = mock(HttpMessageConverter.class);
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>();
    converters.add(converter);
    HttpHeaders responseHeaders = new HttpHeaders();
    MediaType contentType = MediaType.TEXT_PLAIN;
    responseHeaders.setContentType(contentType);
    String expected = "Foo";
    extractor = new HttpMessageConverterExtractor<String>(String.class, converters);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(expected.getBytes()));
    given(converter.canRead(String.class, contentType)).willReturn(true);
    given(converter.read(eq(String.class), any(HttpInputMessage.class))).willReturn(expected);

    Object result = extractor.extractData(response);

    assertEquals(expected, result);
}

@Test
@SuppressWarnings("unchecked")
public void generics() throws IOException {
    GenericHttpMessageConverter<String> converter = mock(GenericHttpMessageConverter.class);
    List<HttpMessageConverter<?>> converters = createConverterList(converter);
    HttpHeaders responseHeaders = new HttpHeaders();
    MediaType contentType = MediaType.TEXT_PLAIN;
    responseHeaders.setContentType(contentType);
    String expected = "Foo";
    ParameterizedTypeReference<List<String>> reference = new ParameterizedTypeReference<List<String>>() {};
    Type type = reference.getType();
    extractor = new HttpMessageConverterExtractor<List<String>>(type, converters);
    given(response.getStatusCode()).willReturn(HttpStatus.OK);
    given(response.getHeaders()).willReturn(responseHeaders);
    given(response.getBody()).willReturn(new ByteArrayInputStream(expected.getBytes()));
    given(converter.canRead(type, null, contentType)).willReturn(true);
    given(converter.read(eq(type), eq(null), any(HttpInputMessage.class))).willReturn(expected);

    Object result = extractor.extractData(response);

    assertEquals(expected, result);
}

/**
 * Unwrap a wrapped response created by Vault Response Wrapping
 *
 * @param wrappedResponse the wrapped response , must not be empty or {@literal null}.
 * @param responseType the type of the return value.
 * @return the unwrapped response.
 */
@SuppressWarnings("unchecked")
public static <T> T unwrap(final String wrappedResponse, Class<T> responseType) {

    Assert.hasText(wrappedResponse, "Wrapped response must not be empty");

    try {
        return (T) converter.read(responseType, new HttpInputMessage() {
            @Override
            public InputStream getBody() throws IOException {
                return new ByteArrayInputStream(wrappedResponse.getBytes());
            }

            @Override
            public HttpHeaders getHeaders() {
                return new HttpHeaders();
            }
        });
    }
    catch (IOException e) {
        throw new IllegalStateException(e);
    }
}

@Override
public Site read(final Class<? extends Site> clazz, final HttpInputMessage inputMessage) throws IOException {

    final Site siteStructure = new Site();

    final HierarchicalStreamReader reader = MarshallingUtils.createReader(inputMessage);
    while (reader.hasMoreChildren()) {
        reader.moveDown();
        final Domain domain = new Domain(reader.getAttribute("Name"));

        reader.moveDown();
        while (reader.hasMoreChildren()) {
            reader.moveDown();
            domain.addProject(new Project(domain.getName(), reader.getAttribute("Name")));
            reader.moveUp();
        }
        reader.moveUp();

        siteStructure.addDomain(domain);
        reader.moveUp();
    }

    return siteStructure;
}

/**
 * Return the {@link HttpTunnelPayload} for the given message or {@code null} if there
 * is no payload.
 * @param message the HTTP message
 * @return the payload or {@code null}
 * @throws IOException in case of I/O errors
 */
public static HttpTunnelPayload get(HttpInputMessage message) throws IOException {
    long length = message.getHeaders().getContentLength();
    if (length <= 0) {
        return null;
    }
    String seqHeader = message.getHeaders().getFirst(SEQ_HEADER);
    Assert.state(StringUtils.hasLength(seqHeader), "Missing sequence header");
    ReadableByteChannel body = Channels.newChannel(message.getBody());
    ByteBuffer payload = ByteBuffer.allocate((int) length);
    while (payload.hasRemaining()) {
        body.read(payload);
    }
    body.close();
    payload.flip();
    return new HttpTunnelPayload(Long.valueOf(seqHeader), payload);
}

@Override
protected Object readInternal( Class<?> clazz, HttpInputMessage inputMessage ) throws IOException, HttpMessageNotReadableException
{
    MediaType mediaType = inputMessage.getHeaders().getContentType();

    if ( isJson( mediaType ) )
    {
        return renderService.fromJson( inputMessage.getBody(), clazz );
    }
    else if ( isXml( mediaType ) )
    {
        return renderService.fromXml( inputMessage.getBody(), clazz );
    }

    return null;
}

@Override
public Object read(Class<? extends Object> clazz,
    HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
  MessageBodyClientHttpResponseWrapper respWrapper = (MessageBodyClientHttpResponseWrapper) inputMessage;
  CseClientHttpResponse resp =
      (CseClientHttpResponse) ReflectionUtils.getField(RESPONSE_FIELD, respWrapper);
  return resp.getResult();
}

@Override
protected DemoObj readInternal(Class<? extends DemoObj> aClass, HttpInputMessage httpInputMessage) throws IOException, HttpMessageNotReadableException {
    String temp = StreamUtils.copyToString(httpInputMessage.getBody(),Charset.forName("UTF-8"));
    String[] tempArr = temp.split("-");
    return new DemoObj(new Long(tempArr[0]),tempArr[1]);

}

@Override
public MultiValueMap<String, String> read(Class<? extends MultiValueMap<String, ?>> clazz,
        HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    Charset charset = (contentType.getCharset() != null ? contentType.getCharset() : this.charset);
    String body = StreamUtils.copyToString(inputMessage.getBody(), charset);

    MultiValueMap<String, String> result = new LinkedMultiValueMap<String, String>();
    result.add("body", body);
    return result;
}

@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int i;
    while ((i = inputMessage.getBody().read()) != -1) {
        baos.write(i);
    }
    return JSON.parseArray(baos.toString(), clazz);
}

@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    JavaType javaType = getJavaType(clazz, null);
    return readJavaType(javaType, inputMessage);
}

@Override
public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    JavaType javaType = getJavaType(type, contextClass);
    return readJavaType(javaType, inputMessage);
}

private Object readTypeToken(TypeToken<?> token, HttpInputMessage inputMessage) throws IOException {
  InputStreamReader json = new InputStreamReader(inputMessage.getBody(), this.getCharset(inputMessage.getHeaders()));
  try {
    return this.gson.fromJson(json, token.getType());
  } catch (JsonParseException var5) {
    throw new HttpMessageNotReadableException("JSON parse error: " + var5.getMessage(), var5);
  }
}

@Override
public OAuth2AccessToken read(Type type, Class<?> contextClass, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
    Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
    String tokenResult = StreamUtils.copyToString(inputMessage.getBody(), charset);
    log.info("tokenResult:{}", tokenResult);
    String[] results = tokenResult.split("&");
    if (results.length == 3) {
        Map<String, String> tokenParams = new HashMap<>();
        tokenParams.put(ACCESS_TOKEN, results[0].replace("access_token=", ""));
        tokenParams.put(EXPIRES_IN, results[1].replace("expires_in=", ""));
        tokenParams.put(REFRESH_TOKEN, results[2].replace("refresh_token=", ""));
        return DefaultOAuth2AccessToken.valueOf(tokenParams);
    }
    return null;
}

private HttpEntity<?> resolveHttpEntityRequest(MethodParameter methodParam, NativeWebRequest webRequest)
        throws Exception {

    HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
    Class<?> paramType = getHttpEntityType(methodParam);
    Object body = readWithMessageConverters(methodParam, inputMessage, paramType);
    return new HttpEntity<Object>(body, inputMessage.getHeaders());
}

@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);
        }
        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);
}

@Override
public byte[] readInternal(Class<? extends byte[]> clazz, HttpInputMessage inputMessage) throws IOException {
    long contentLength = inputMessage.getHeaders().getContentLength();
    ByteArrayOutputStream bos =
            new ByteArrayOutputStream(contentLength >= 0 ? (int) contentLength : StreamUtils.BUFFER_SIZE);
    StreamUtils.copy(inputMessage.getBody(), bos);
    return bos.toByteArray();
}

@Override
protected Resource readInternal(Class<? extends Resource> clazz, HttpInputMessage inputMessage)
        throws IOException, HttpMessageNotReadableException {

    byte[] body = StreamUtils.copyToByteArray(inputMessage.getBody());
    return new ByteArrayResource(body);
}