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