@SuppressWarnings("unchecked") private <T> void sendInternal(T data, @Nullable MediaType mediaType) throws IOException { for (HttpMessageConverter<?> converter : ResponseBodyEmitterReturnValueHandler.this.messageConverters) { if (converter.canWrite(data.getClass(), mediaType)) { ((HttpMessageConverter<T>) converter).write(data, mediaType, this.outputMessage); this.outputMessage.flush(); return; } } throw new IllegalArgumentException("No suitable converter for " + data.getClass()); }
@SuppressWarnings("unchecked") @Override public void handleError(ClientHttpResponse response) throws IOException { for (HttpMessageConverter<?> converter : messageConverters) { if (converter.canRead(OAuth2Exception.class, response.getHeaders().getContentType())) { OAuth2Exception ex; try { ex = ((HttpMessageConverter<OAuth2Exception>) converter).read(OAuth2Exception.class, response); } catch (Exception e) { // ignore continue; } throw ex; } } super.handleError(response); }
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(); allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
if (converter instanceof GenericHttpMessageConverter && targetType != null) { if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) { result.addAll(converter.getSupportedMediaTypes()); else if (converter.canWrite(valueClass, null)) { result.addAll(converter.getSupportedMediaTypes());
@Override protected ExceptionReport readInternal(Class<? extends ExceptionReport> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException { for (HttpMessageConverter<?> converter : messageConverters) { for (MediaType mediaType : converter.getSupportedMediaTypes()) { if (converter.canRead(Map.class, mediaType)) { @SuppressWarnings({ "rawtypes", "unchecked" }) HttpMessageConverter<Map> messageConverter = (HttpMessageConverter<Map>) converter; @SuppressWarnings("unchecked") Map<String, String> map = messageConverter.read(Map.class, inputMessage); return new ExceptionReport(getException(map)); } } } return null; }
private void mockHttpMessageConverter(MediaType mediaType, Class type) { given(converter.canRead(type, null)).willReturn(true); given(converter.canRead(type, mediaType)).willReturn(true); given(converter.getSupportedMediaTypes()) .willReturn(Collections.singletonList(mediaType)); given(converter.canRead(type, mediaType)).willReturn(true); given(converter.canWrite(type, null)).willReturn(true); given(converter.canWrite(type, mediaType)).willReturn(true); }
private boolean canReadResponse(Type responseType, HttpMessageConverter<?> converter) { Class<?> responseClass = (responseType instanceof Class ? (Class<?>) responseType : null); if (responseClass != null) { return converter.canRead(responseClass, null); } else if (converter instanceof GenericHttpMessageConverter) { GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter; return genericConverter.canRead(responseType, null, null); } return false; }
@Test public void shouldFailResolvingWhenConverterCannotRead() throws Exception { MediaType contentType = TEXT_PLAIN; servletRequest.setMethod("POST"); servletRequest.addHeader("Content-Type", contentType.toString()); given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(contentType)); given(stringHttpMessageConverter.canRead(String.class, contentType)).willReturn(false); this.thrown.expect(HttpMediaTypeNotSupportedException.class); processor.resolveArgument(paramHttpEntity, mavContainer, webRequest, null); }
private void assertResponseBody(String body) throws IOException { ArgumentCaptor<HttpOutputMessage> outputMessage = ArgumentCaptor.forClass(HttpOutputMessage.class); verify(stringHttpMessageConverter).write(eq(body), eq(TEXT_PLAIN), outputMessage.capture()); }
private void mockResponseBody(String expectedBody, MediaType mediaType) throws Exception { HttpHeaders responseHeaders = new HttpHeaders(); responseHeaders.setContentType(mediaType); responseHeaders.setContentLength(expectedBody.length()); given(response.getHeaders()).willReturn(responseHeaders); given(response.getBody()).willReturn(new ByteArrayInputStream(expectedBody.getBytes())); given(converter.read(eq(String.class), any(HttpInputMessage.class))).willReturn(expectedBody); }
/** * Return the media types supported by all provided message converters sorted * by specificity via {@link MediaType#sortBySpecificity(List)}. */ private static List<MediaType> getAllSupportedMediaTypes(List<HttpMessageConverter<?>> messageConverters) { Set<MediaType> allSupportedMediaTypes = new LinkedHashSet<>(); for (HttpMessageConverter<?> messageConverter : messageConverters) { allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes()); } List<MediaType> result = new ArrayList<>(allSupportedMediaTypes); MediaType.sortBySpecificity(result); return Collections.unmodifiableList(result); }
@Test public void canWrite() { MediaType mediaType = new MediaType("foo", "bar"); HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType); assertTrue(converter.canWrite(MyType.class, mediaType)); assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "*"))); assertTrue(converter.canWrite(MyType.class, MediaType.ALL)); }
if (converter instanceof GenericHttpMessageConverter && targetType != null) { if (((GenericHttpMessageConverter<?>) converter).canWrite(targetType, valueClass, null)) { result.addAll(converter.getSupportedMediaTypes()); else if (converter.canWrite(valueClass, null)) { result.addAll(converter.getSupportedMediaTypes());
private void testResolveArgumentWithValidation(SimpleBean simpleBean) throws Exception { MediaType contentType = MediaType.TEXT_PLAIN; servletRequest.addHeader("Content-Type", contentType.toString()); servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8)); @SuppressWarnings("unchecked") HttpMessageConverter<SimpleBean> beanConverter = mock(HttpMessageConverter.class); given(beanConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN)); given(beanConverter.canRead(SimpleBean.class, contentType)).willReturn(true); given(beanConverter.read(eq(SimpleBean.class), isA(HttpInputMessage.class))).willReturn(simpleBean); processor = new RequestResponseBodyMethodProcessor(Collections.singletonList(beanConverter)); processor.resolveArgument(paramValidBean, mavContainer, webRequest, new ValidatingBinderFactory()); }
private boolean canReadResponse(Type responseType, HttpMessageConverter<?> converter) { Class<?> responseClass = (responseType instanceof Class ? (Class<?>) responseType : null); if (responseClass != null) { return converter.canRead(responseClass, null); } else if (converter instanceof GenericHttpMessageConverter) { GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter; return genericConverter.canRead(responseType, null, null); } return false; }
@Test public void requestAvoidsDuplicateAcceptHeaderValues() throws Exception { HttpMessageConverter firstConverter = mock(HttpMessageConverter.class); given(firstConverter.canRead(any(), any())).willReturn(true); given(firstConverter.getSupportedMediaTypes()) .willReturn(Collections.singletonList(MediaType.TEXT_PLAIN)); HttpMessageConverter secondConverter = mock(HttpMessageConverter.class); given(secondConverter.canRead(any(), any())).willReturn(true); given(secondConverter.getSupportedMediaTypes()) .willReturn(Collections.singletonList(MediaType.TEXT_PLAIN)); HttpHeaders requestHeaders = new HttpHeaders(); mockSentRequest(GET, "http://example.com/", requestHeaders); mockResponseStatus(HttpStatus.OK); mockTextResponseBody("Hello World"); template.setMessageConverters(Arrays.asList(firstConverter, secondConverter)); template.getForObject("http://example.com/", String.class); assertEquals("Sent duplicate Accept header values", 1, requestHeaders.getAccept().size()); }
@Test public void testWriteInternal() throws Exception { ExceptionReport report = new ExceptionReport(new Exception("oh noes!")); exceptionReportHttpMessageConverter.writeInternal(report, httpOutputMessage); Map<String, String> expectedFields = new HashMap<>(); expectedFields.put("error", "exception"); expectedFields.put("message", "oh noes!"); expectedFields.put("error_description", "oh noes!"); verify(httpMessageConverter).write(eq(expectedFields), eq(APPLICATION_JSON), eq(httpOutputMessage)); }
@Test public void postForObjectNull() throws Exception { mockTextPlainHttpMessageConverter(); HttpHeaders requestHeaders = new HttpHeaders(); mockSentRequest(POST, "http://example.com", requestHeaders); mockResponseStatus(HttpStatus.OK); HttpHeaders responseHeaders = new HttpHeaders(); responseHeaders.setContentType(MediaType.TEXT_PLAIN); responseHeaders.setContentLength(10); given(response.getHeaders()).willReturn(responseHeaders); given(response.getBody()).willReturn(StreamUtils.emptyInput()); given(converter.read(String.class, response)).willReturn(null); String result = template.postForObject("http://example.com", null, String.class); assertNull("Invalid POST result", result); assertEquals("Invalid content length", 0, requestHeaders.getContentLength()); verify(response).close(); }
@Override public List<MediaType> getSupportedMediaTypes() { Set<MediaType> list = new LinkedHashSet<MediaType>(); for (HttpMessageConverter<?> converter : messageConverters) { list.addAll(converter.getSupportedMediaTypes()); } return new ArrayList<MediaType>(list); }
@Test public void canWriteWithWildcardInSupportedSubtype() { MediaType mediaType = new MediaType("foo"); HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType); assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "bar"))); assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "*"))); assertTrue(converter.canWrite(MyType.class, MediaType.ALL)); }