Use ResponseEntity Content-Type as producible media type

rstoyanchev · rstoyanchev · commit 9a894ab61e46 · 2017-11-10T15:05:03.000-05:00
Issue: SPR-16172
diff --git a/spring-webflux/src/main/java/org/springframework/web/reactive/result/HandlerResultHandlerSupport.java b/spring-webflux/src/main/java/org/springframework/web/reactive/result/HandlerResultHandlerSupport.java
@@ -152,6 +152,10 @@ private List<MediaType> getAcceptableTypes(ServerWebExchange exchange) {
 	private List<MediaType> getProducibleTypes(ServerWebExchange exchange,
 			Supplier<List<MediaType>> producibleTypesSupplier) {
 
+		MediaType contentType = exchange.getResponse().getHeaders().getContentType();
+		if (contentType != null && contentType.isConcrete()) {
+			return Collections.singletonList(contentType);
+		}
 		Set<MediaType> mediaTypes = exchange.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
 		return (mediaTypes != null ? new ArrayList<>(mediaTypes) : producibleTypesSupplier.get());
 	}
diff --git a/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractMessageWriterResultHandler.java b/spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractMessageWriterResultHandler.java
@@ -111,7 +111,7 @@ protected Mono<Void> writeBody(@Nullable Object body, MethodParameter bodyParame
 
 		ServerHttpRequest request = exchange.getRequest();
 		ServerHttpResponse response = exchange.getResponse();
-		MediaType bestMediaType = selectMediaType(exchange, () -> getProducibleMediaTypes(elementType));
+		MediaType bestMediaType = selectMediaType(exchange, () -> getMediaTypesFor(elementType));
 		if (bestMediaType != null) {
 			for (HttpMessageWriter<?> writer : getMessageWriters()) {
 				if (writer.canWrite(elementType, bestMediaType)) {
@@ -121,12 +121,12 @@ protected Mono<Void> writeBody(@Nullable Object body, MethodParameter bodyParame
 			}
 		}
 		else {
-			if (getProducibleMediaTypes(elementType).isEmpty()) {
-				return Mono.error(new IllegalStateException("No converter for return value type: " + elementType));
+			if (getMediaTypesFor(elementType).isEmpty()) {
+				return Mono.error(new IllegalStateException("No writer for : " + elementType));
 			}
 		}
 
-		return Mono.error(new NotAcceptableStatusException(getProducibleMediaTypes(elementType)));
+		return Mono.error(new NotAcceptableStatusException(getMediaTypesFor(elementType)));
 	}
 
 	private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType genericType) {
@@ -141,7 +141,7 @@ else if (genericType != ResolvableType.NONE) {
 		}
 	}
 
-	private List<MediaType> getProducibleMediaTypes(ResolvableType elementType) {
+	private List<MediaType> getMediaTypesFor(ResolvableType elementType) {
 		return getMessageWriters().stream()
 				.filter(converter -> converter.canWrite(elementType, null))
 				.flatMap(converter -> converter.getWritableMediaTypes().stream())
diff --git a/spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/RequestMappingMessageConversionIntegrationTests.java b/spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/RequestMappingMessageConversionIntegrationTests.java
@@ -155,6 +155,16 @@ public void personResponseBodyWithMonoResponseEntity() throws Exception {
 		assertEquals(expected, performGet("/person-response/mono-response-entity", JSON, Person.class).getBody());
 	}
 
+	@Test // SPR-16172
+	public void personResponseBodyWithMonoResponseEntityXml() throws Exception {
+
+		String actual = performGet("/person-response/mono-response-entity-xml",
+				new HttpHeaders(), String.class).getBody();
+
+		assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" +
+				"<person><name>Robert</name></person>", actual);
+	}
+
 	@Test
 	public void personResponseBodyWithList() throws Exception {
 		List<?> expected = asList(new Person("Robert"), new Person("Marie"));
@@ -465,6 +475,12 @@ public ResponseEntity<Mono<Person>> getMonoResponseEntity() {
 			return ResponseEntity.ok(body);
 		}
 
+		@GetMapping("/mono-response-entity-xml")
+		public ResponseEntity<Mono<Person>> getMonoResponseEntityXml() {
+			Mono<Person> body = Mono.just(new Person("Robert"));
+			return ResponseEntity.ok().contentType(MediaType.APPLICATION_XML).body(body);
+		}
+
 		@GetMapping("/list")
 		public List<Person> getList() {
 			return asList(new Person("Robert"), new Person("Marie"));
diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMessageConverterMethodProcessor.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMessageConverterMethodProcessor.java
@@ -212,7 +212,10 @@ protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter
 
 		HttpServletRequest request = inputMessage.getServletRequest();
 		List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
-		List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request, valueType, declaredType);
+
+		MediaType contentType = outputMessage.getHeaders().getContentType();
+		List<MediaType> producibleMediaTypes = (contentType != null && contentType.isConcrete() ?
+				Collections.singletonList(contentType) : getProducibleMediaTypes(request, valueType, declaredType));
 
 		if (outputValue != null && producibleMediaTypes.isEmpty()) {
 			throw new HttpMessageNotWritableException("No converter found for return value of type: " + valueType);
diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodTests.java
@@ -83,6 +83,8 @@
 import org.springframework.http.converter.HttpMessageNotReadableException;
 import org.springframework.http.converter.HttpMessageNotWritableException;
 import org.springframework.http.converter.StringHttpMessageConverter;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+import org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter;
 import org.springframework.http.converter.xml.MarshallingHttpMessageConverter;
 import org.springframework.lang.Nullable;
 import org.springframework.mock.web.test.MockHttpServletRequest;
@@ -934,6 +936,26 @@ public void httpEntity() throws Exception {
 		assertEquals(404, response.getStatus());
 	}
 
+	@Test // SPR-16172
+	public void httpEntityWithContentType() throws Exception {
+		initServlet(wac -> {
+			RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
+			List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
+			messageConverters.add(new MappingJackson2HttpMessageConverter());
+			messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
+			adapterDef.getPropertyValues().add("messageConverters", messageConverters);
+			wac.registerBeanDefinition("handlerAdapter", adapterDef);
+		}, ResponseEntityController.class);
+
+		MockHttpServletRequest request = new MockHttpServletRequest("GET", "/test-entity");
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		getServlet().service(request, response);
+		assertEquals(200, response.getStatus());
+		assertEquals("application/xml", response.getHeader("Content-Type"));
+		assertEquals("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" +
+						"<testEntity><name>Foo Bar</name></testEntity>", response.getContentAsString());
+	}
+
 	@Test  // SPR-6877
 	public void overlappingMessageConvertersRequestBody() throws Exception {
 		initServlet(wac -> {
@@ -3210,7 +3232,7 @@ public void templatePath(Writer writer) throws IOException {
 	@Controller
 	public static class ResponseEntityController {
 
-		@RequestMapping(path = "/foo", method = RequestMethod.POST)
+		@PostMapping("/foo")
 		public ResponseEntity<String> foo(HttpEntity<byte[]> requestEntity) throws Exception {
 			assertNotNull(requestEntity);
 			assertEquals("MyValue", requestEntity.getHeaders().getFirst("MyRequestHeader"));
@@ -3222,12 +3244,12 @@ public ResponseEntity<String> foo(HttpEntity<byte[]> requestEntity) throws Excep
 			return ResponseEntity.created(location).header("MyResponseHeader", "MyValue").body(body);
 		}
 
-		@RequestMapping(path = "/bar", method = RequestMethod.GET)
+		@GetMapping("/bar")
 		public ResponseEntity<Void> bar() {
 			return ResponseEntity.notFound().header("MyResponseHeader", "MyValue").build();
 		}
 
-		@RequestMapping(path = "/baz", method = RequestMethod.GET)
+		@GetMapping("/baz")
 		public ResponseEntity<String> baz() {
 			return ResponseEntity.ok().header("MyResponseHeader", "MyValue").body("body");
 		}
@@ -3237,10 +3259,32 @@ public ResponseEntity<Void> headResource() {
 			return ResponseEntity.ok().header("h1", "v1").build();
 		}
 
-		@RequestMapping(path = "/stores", method = RequestMethod.GET)
+		@GetMapping("/stores")
 		public ResponseEntity<String> getResource() {
 			return ResponseEntity.ok().body("body");
 		}
+
+		@GetMapping("/test-entity")
+		public ResponseEntity<TestEntity> testEntity() {
+			TestEntity entity = new TestEntity();
+			entity.setName("Foo Bar");
+			return ResponseEntity.ok().contentType(MediaType.APPLICATION_XML).body(entity);
+		}
+	}
+
+	@XmlRootElement
+	static class TestEntity {
+
+		private String name;
+
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
 	}
 
 	@Controller

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ protected Mono<Void> writeBody(@Nullable Object body, MethodParameter bodyParame`
`111`	`111`
`112`	`112`	`ServerHttpRequest request = exchange.getRequest();`
`113`	`113`	`ServerHttpResponse response = exchange.getResponse();`
`114`		`- MediaType bestMediaType = selectMediaType(exchange, () -> getProducibleMediaTypes(elementType));`
	`114`	`+ MediaType bestMediaType = selectMediaType(exchange, () -> getMediaTypesFor(elementType));`
`115`	`115`	`if (bestMediaType != null) {`
`116`	`116`	`for (HttpMessageWriter<?> writer : getMessageWriters()) {`
`117`	`117`	`if (writer.canWrite(elementType, bestMediaType)) {`
`@@ -121,12 +121,12 @@ protected Mono<Void> writeBody(@Nullable Object body, MethodParameter bodyParame`
`121`	`121`	`}`
`122`	`122`	`}`
`123`	`123`	`else {`
`124`		`- if (getProducibleMediaTypes(elementType).isEmpty()) {`
`125`		`- return Mono.error(new IllegalStateException("No converter for return value type: " + elementType));`
	`124`	`+ if (getMediaTypesFor(elementType).isEmpty()) {`
	`125`	`+ return Mono.error(new IllegalStateException("No writer for : " + elementType));`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`		`- return Mono.error(new NotAcceptableStatusException(getProducibleMediaTypes(elementType)));`
	`129`	`+ return Mono.error(new NotAcceptableStatusException(getMediaTypesFor(elementType)));`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType genericType) {`
`@@ -141,7 +141,7 @@ else if (genericType != ResolvableType.NONE) {`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
`144`		`- private List<MediaType> getProducibleMediaTypes(ResolvableType elementType) {`
	`144`	`+ private List<MediaType> getMediaTypesFor(ResolvableType elementType) {`
`145`	`145`	`return getMessageWriters().stream()`
`146`	`146`	`.filter(converter -> converter.canWrite(elementType, null))`
`147`	`147`	`.flatMap(converter -> converter.getWritableMediaTypes().stream())`