diff --git a/spring-web/src/main/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.java b/spring-web/src/main/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.java index 46234d2fefd..4e65da0e540 100644 --- a/spring-web/src/main/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.java +++ b/spring-web/src/main/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.java @@ -249,15 +249,27 @@ public class MappingJackson2HttpMessageConverter extends AbstractHttpMessageConv if (this.jsonPrefix != null) { jsonGenerator.writeRaw(this.jsonPrefix); } + Class serializationView = null; + String jsonpFunction = null; if (object instanceof MappingJacksonValue) { - MappingJacksonValue valueHolder = (MappingJacksonValue) object; - object = valueHolder.getValue(); - Class serializationView = valueHolder.getSerializationView(); + MappingJacksonValue container = (MappingJacksonValue) object; + object = container.getValue(); + serializationView = container.getSerializationView(); + jsonpFunction = container.getJsonpFunction(); + } + if (jsonpFunction != null) { + jsonGenerator.writeRaw(jsonpFunction + "(" ); + } + if (serializationView != null) { this.objectMapper.writerWithView(serializationView).writeValue(jsonGenerator, object); } else { this.objectMapper.writeValue(jsonGenerator, object); } + if (jsonpFunction != null) { + jsonGenerator.writeRaw(");"); + jsonGenerator.flush(); + } } catch (JsonProcessingException ex) { throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex); diff --git a/spring-web/src/main/java/org/springframework/http/converter/json/MappingJacksonValue.java b/spring-web/src/main/java/org/springframework/http/converter/json/MappingJacksonValue.java index 1e293e66b06..c184ac310a1 100644 --- a/spring-web/src/main/java/org/springframework/http/converter/json/MappingJacksonValue.java +++ b/spring-web/src/main/java/org/springframework/http/converter/json/MappingJacksonValue.java @@ -17,44 +17,83 @@ package org.springframework.http.converter.json; /** - * Holds an Object to be serialized via Jackson together with a serialization - * view to be applied. + * A simple holder for the POJO to serialize via + * {@link org.springframework.http.converter.json.MappingJackson2HttpMessageConverter + * MappingJackson2HttpMessageConverter} along with further serialization + * instructions to be passed in to the converter. + * + *

On the server side this wrapper is added with a + * {@code ResponseBodyInterceptor} after content negotiation selects the + * converter to use but before the write. + * + *

On the client side, simply wrap the POJO and pass it in to the + * {@code RestTemplate}. * * @author Rossen Stoyanchev * @since 4.1 - * - * @see com.fasterxml.jackson.annotation.JsonView */ public class MappingJacksonValue { - private final Object value; + private Object value; - private final Class serializationView; + private Class serializationView; + + private String jsonpFunction; /** - * Create a new instance. + * Create a new instance wrapping the given POJO to be serialized. * @param value the Object to be serialized - * @param serializationView the view to be applied */ - public MappingJacksonValue(Object value, Class serializationView) { + public MappingJacksonValue(Object value) { this.value = value; - this.serializationView = serializationView; } /** - * Return the value to be serialized. + * Modify the POJO to serialize. + */ + public void setValue(Object value) { + this.value = value; + } + + /** + * Return the POJO that needs to be serialized. */ public Object getValue() { return this.value; } + /** + * Set the serialization view to serialize the POJO with. + * @see com.fasterxml.jackson.databind.ObjectMapper#writerWithView(Class) + * @see com.fasterxml.jackson.annotation.JsonView + */ + public void setSerializationView(Class serializationView) { + this.serializationView = serializationView; + } + /** * Return the serialization view to use. + * @see com.fasterxml.jackson.databind.ObjectMapper#writerWithView(Class) + * @see com.fasterxml.jackson.annotation.JsonView */ public Class getSerializationView() { return this.serializationView; } + /** + * Set the name of the JSONP function name. + */ + public void setJsonpFunction(String functionName) { + this.jsonpFunction = functionName; + } + + /** + * Return the configured JSONP function name. + */ + public String getJsonpFunction() { + return this.jsonpFunction; + } + } diff --git a/spring-web/src/test/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverterTests.java b/spring-web/src/test/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverterTests.java index b206fa0cfca..f00f7d1ccac 100644 --- a/spring-web/src/test/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverterTests.java +++ b/spring-web/src/test/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverterTests.java @@ -27,6 +27,7 @@ import java.util.Map; import com.fasterxml.jackson.annotation.JsonView; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.ObjectMapper; +import org.hamcrest.CoreMatchers; import org.junit.Test; import org.springframework.core.ParameterizedTypeReference; @@ -35,6 +36,7 @@ import org.springframework.http.MockHttpInputMessage; import org.springframework.http.MockHttpOutputMessage; import org.springframework.http.converter.HttpMessageNotReadableException; +import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.*; /** @@ -245,13 +247,48 @@ public class MappingJackson2HttpMessageConverterTests { bean.setWithView1("with"); bean.setWithView2("with"); bean.setWithoutView("without"); - MappingJacksonValue jsv = new MappingJacksonValue(bean, MyJacksonView1.class); - this.converter.writeInternal(jsv, outputMessage); + + MappingJacksonValue jacksonValue = new MappingJacksonValue(bean); + jacksonValue.setSerializationView(MyJacksonView1.class); + this.converter.writeInternal(jacksonValue, outputMessage); String result = outputMessage.getBodyAsString(Charset.forName("UTF-8")); - assertTrue(result.contains("\"withView1\":\"with\"")); - assertFalse(result.contains("\"withView2\":\"with\"")); - assertTrue(result.contains("\"withoutView\":\"without\"")); + assertThat(result, containsString("\"withView1\":\"with\"")); + assertThat(result, containsString("\"withoutView\":\"without\"")); + assertThat(result, not(containsString("\"withView2\":\"with\""))); + } + + @Test + public void jsonp() throws Exception { + MappingJacksonValue jacksonValue = new MappingJacksonValue("foo"); + jacksonValue.setSerializationView(MyJacksonView1.class); + jacksonValue.setJsonpFunction("callback"); + + MockHttpOutputMessage outputMessage = new MockHttpOutputMessage(); + this.converter.writeInternal(jacksonValue, outputMessage); + + assertEquals("callback(\"foo\");", outputMessage.getBodyAsString(Charset.forName("UTF-8"))); + } + + @Test + public void jsonpAndJsonView() throws Exception { + MockHttpOutputMessage outputMessage = new MockHttpOutputMessage(); + JacksonViewBean bean = new JacksonViewBean(); + bean.setWithView1("with"); + bean.setWithView2("with"); + bean.setWithoutView("without"); + + MappingJacksonValue jacksonValue = new MappingJacksonValue(bean); + jacksonValue.setSerializationView(MyJacksonView1.class); + jacksonValue.setJsonpFunction("callback"); + this.converter.writeInternal(jacksonValue, outputMessage); + + String result = outputMessage.getBodyAsString(Charset.forName("UTF-8")); + assertThat(result, startsWith("callback(")); + assertThat(result, endsWith(");")); + assertThat(result, containsString("\"withView1\":\"with\"")); + assertThat(result, containsString("\"withoutView\":\"without\"")); + assertThat(result, not(containsString("\"withView2\":\"with\""))); } diff --git a/spring-web/src/test/java/org/springframework/web/client/RestTemplateIntegrationTests.java b/spring-web/src/test/java/org/springframework/web/client/RestTemplateIntegrationTests.java index 1595cd6ed87..07bc0420186 100644 --- a/spring-web/src/test/java/org/springframework/web/client/RestTemplateIntegrationTests.java +++ b/spring-web/src/test/java/org/springframework/web/client/RestTemplateIntegrationTests.java @@ -220,8 +220,9 @@ public class RestTemplateIntegrationTests extends AbstractJettyServerTestCase { HttpHeaders entityHeaders = new HttpHeaders(); entityHeaders.setContentType(new MediaType("application", "json", Charset.forName("UTF-8"))); MySampleBean bean = new MySampleBean("with", "with", "without"); - MappingJacksonValue jsv = new MappingJacksonValue(bean, MyJacksonView1.class); - HttpEntity entity = new HttpEntity(jsv); + MappingJacksonValue jacksonValue = new MappingJacksonValue(bean); + jacksonValue.setSerializationView(MyJacksonView1.class); + HttpEntity entity = new HttpEntity(jacksonValue); String s = template.postForObject(baseUrl + "/jsonpost", entity, String.class, "post"); assertTrue(s.contains("\"with1\":\"with\"")); assertFalse(s.contains("\"with2\":\"with\"")); diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractJsonpResponseBodyInterceptor.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractJsonpResponseBodyInterceptor.java new file mode 100644 index 00000000000..128c4172037 --- /dev/null +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractJsonpResponseBodyInterceptor.java @@ -0,0 +1,86 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.web.servlet.mvc.method.annotation; + +import org.springframework.core.MethodParameter; +import org.springframework.http.MediaType; +import org.springframework.http.converter.json.MappingJacksonValue; +import org.springframework.http.server.ServerHttpRequest; +import org.springframework.http.server.ServerHttpResponse; +import org.springframework.http.server.ServletServerHttpRequest; +import org.springframework.util.Assert; +import org.springframework.util.CollectionUtils; + +import javax.servlet.http.HttpServletRequest; +import java.util.Collection; + +/** + * A convenient base class for a {@code ResponseBodyInterceptor} to instruct the + * {@link org.springframework.http.converter.json.MappingJackson2HttpMessageConverter + * MappingJackson2HttpMessageConverter} to serialize with JSONP formatting. + * + *

Sub-classes must specify the query parameter name(s) to check for the name + * of the JSONP callback function. + * + *

Sub-classes are likely to be annotated with the {@code @ControllerAdvice} + * annotation and auto-detected or otherwise must be registered directly with the + * {@code RequestMappingHandlerAdapter} and {@code ExceptionHandlerExceptionResolver}. + * + * @author Rossen Stoyanchev + * @since 4.1 + */ +public abstract class AbstractJsonpResponseBodyInterceptor extends AbstractMappingJacksonResponseBodyInterceptor { + + private final String[] jsonpQueryParamNames; + + + protected AbstractJsonpResponseBodyInterceptor(Collection queryParamNames) { + Assert.isTrue(!CollectionUtils.isEmpty(queryParamNames), "At least one query param name is required"); + this.jsonpQueryParamNames = queryParamNames.toArray(new String[queryParamNames.size()]); + } + + + @Override + protected void beforeBodyWriteInternal(MappingJacksonValue bodyContainer, MediaType contentType, + MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) { + + HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest(); + + for (String name : this.jsonpQueryParamNames) { + String value = servletRequest.getParameter(name); + if (value != null) { + MediaType contentTypeToUse = getContentType(contentType, request, response); + response.getHeaders().setContentType(contentTypeToUse); + bodyContainer.setJsonpFunction(value); + return; + } + } + } + + /** + * Return the content type to set the response to. + * This implementation always returns "application/javascript". + * @param contentType the content type selected through content negotiation + * @param request the current request + * @param response the current response + * @return the content type to set the response to + */ + protected MediaType getContentType(MediaType contentType, ServerHttpRequest request, ServerHttpResponse response) { + return new MediaType("application", "javascript"); + } + +} diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMappingJacksonResponseBodyInterceptor.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMappingJacksonResponseBodyInterceptor.java new file mode 100644 index 00000000000..030b6c76dd6 --- /dev/null +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/AbstractMappingJacksonResponseBodyInterceptor.java @@ -0,0 +1,72 @@ +/* + * Copyright 2002-2014 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.web.servlet.mvc.method.annotation; + +import org.springframework.core.MethodParameter; +import org.springframework.http.MediaType; +import org.springframework.http.converter.HttpMessageConverter; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.http.converter.json.MappingJacksonValue; +import org.springframework.http.server.ServerHttpRequest; +import org.springframework.http.server.ServerHttpResponse; + +/** + * A convenient base class for {@code ResponseBodyInterceptor} implementations + * that customize the response before JSON serialization with + * {@link org.springframework.http.converter.json.MappingJackson2HttpMessageConverter + * MappingJackson2HttpMessageConverter}. + * + * @author Rossen Stoyanchev + * @since 4.1 + */ +public abstract class AbstractMappingJacksonResponseBodyInterceptor implements ResponseBodyInterceptor { + + + protected AbstractMappingJacksonResponseBodyInterceptor() { + } + + + @SuppressWarnings("unchecked") + @Override + public final T beforeBodyWrite(T body, MediaType contentType, + Class> converterType, + MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) { + + if (!MappingJackson2HttpMessageConverter.class.equals(converterType)) { + return body; + } + MappingJacksonValue container = getOrCreateContainer(body); + beforeBodyWriteInternal(container, contentType, returnType, request, response); + return (T) container; + } + + /** + * Wrap the body in a {@link MappingJacksonValue} value container (for providing + * additional serialization instructions) or simply cast it if already wrapped. + */ + protected MappingJacksonValue getOrCreateContainer(Object body) { + return (body instanceof MappingJacksonValue) ? (MappingJacksonValue) body : new MappingJacksonValue(body); + } + + /** + * Invoked only if the converter type is {@code MappingJackson2HttpMessageConverter}. + */ + protected abstract void beforeBodyWriteInternal(MappingJacksonValue bodyContainer, MediaType contentType, + MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response); + + +} diff --git a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/JsonViewResponseBodyInterceptor.java b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/JsonViewResponseBodyInterceptor.java index 7713f12f03b..634b8d9c82e 100644 --- a/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/JsonViewResponseBodyInterceptor.java +++ b/spring-webmvc/src/main/java/org/springframework/web/servlet/mvc/method/annotation/JsonViewResponseBodyInterceptor.java @@ -19,42 +19,40 @@ package org.springframework.web.servlet.mvc.method.annotation; import com.fasterxml.jackson.annotation.JsonView; import org.springframework.core.MethodParameter; import org.springframework.http.MediaType; -import org.springframework.http.converter.HttpMessageConverter; -import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; import org.springframework.http.converter.json.MappingJacksonValue; import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpResponse; import org.springframework.util.Assert; /** - * A {@code ResponseBodyInterceptor} implementation that adds support for the - * Jackson {@code @JsonView} annotation on a Spring MVC {@code @RequestMapping} - * or {@code @ExceptionHandler} method. + * A {@code ResponseBodyInterceptor} implementation that adds support for + * Jackson's {@code @JsonView} annotation declared on a Spring MVC + * {@code @RequestMapping} or {@code @ExceptionHandler} method. The serialization + * view specified in the annotation will be passed in to the + * {@code MappingJackson2HttpMessageConverter} which will then use it to + * serialize the response body with. * * @author Rossen Stoyanchev * @since 4.1 + * + * @see com.fasterxml.jackson.databind.ObjectMapper#writerWithView(Class) */ -public class JsonViewResponseBodyInterceptor implements ResponseBodyInterceptor { +public class JsonViewResponseBodyInterceptor extends AbstractMappingJacksonResponseBodyInterceptor { @Override - @SuppressWarnings("unchecked") - public T beforeBodyWrite(T body, MediaType contentType, Class> converterType, + protected void beforeBodyWriteInternal(MappingJacksonValue bodyContainer, MediaType contentType, MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) { - if (!MappingJackson2HttpMessageConverter.class.equals(converterType)) { - return body; - } - JsonView annotation = returnType.getMethodAnnotation(JsonView.class); if (annotation == null) { - return body; + return; } Assert.isTrue(annotation.value().length != 0, "Expected at least one serialization view class in JsonView annotation on " + returnType); - return (T) new MappingJacksonValue(body, annotation.value()[0]); + bodyContainer.setSerializationView(annotation.value()[0]); } } diff --git a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerAdapterTests.java b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerAdapterTests.java index 9a8174bde4a..d615f40c2f1 100644 --- a/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerAdapterTests.java +++ b/spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestMappingHandlerAdapterTests.java @@ -17,7 +17,12 @@ package org.springframework.web.servlet.mvc.method.annotation; import java.lang.reflect.Method; +import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; import org.junit.Before; import org.junit.BeforeClass; @@ -28,6 +33,8 @@ import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.http.converter.HttpMessageConverter; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.http.converter.json.MappingJacksonValue; import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpResponse; import org.springframework.http.server.ServletServerHttpResponse; @@ -229,15 +236,23 @@ public class RequestMappingHandlerAdapterTests { @Test public void responseBodyInterceptor() throws Exception { + List> converters = new ArrayList<>(); + converters.add(new MappingJackson2HttpMessageConverter()); + this.handlerAdapter.setMessageConverters(converters); + this.webAppContext.registerSingleton("rba", ResponseCodeSuppressingAdvice.class); + this.webAppContext.registerSingleton("ja", JsonpAdvice.class); this.webAppContext.refresh(); + this.request.addHeader("Accept", MediaType.APPLICATION_JSON_VALUE); + this.request.setParameter("c", "callback"); + HandlerMethod handlerMethod = handlerMethod(new SimpleController(), "handleWithResponseEntity"); this.handlerAdapter.afterPropertiesSet(); this.handlerAdapter.handle(this.request, this.response, handlerMethod); assertEquals(200, this.response.getStatus()); - assertEquals("status=400, message=body", this.response.getContentAsString()); + assertEquals("callback({\"status\":400,\"message\":\"body\"});", this.response.getContentAsString()); } @@ -324,17 +339,28 @@ public class RequestMappingHandlerAdapterTests { } @ControllerAdvice - private static class ResponseCodeSuppressingAdvice implements ResponseBodyInterceptor { + private static class ResponseCodeSuppressingAdvice extends AbstractMappingJacksonResponseBodyInterceptor { @SuppressWarnings("unchecked") @Override - public T beforeBodyWrite(T body, MediaType contentType, - Class> converterType, + protected void beforeBodyWriteInternal(MappingJacksonValue bodyContainer, MediaType contentType, MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) { int status = ((ServletServerHttpResponse) response).getServletResponse().getStatus(); response.setStatusCode(HttpStatus.OK); - return (T) ("status=" + status + ", message=" + body); + + Map map = new LinkedHashMap<>(); + map.put("status", status); + map.put("message", bodyContainer.getValue()); + bodyContainer.setValue(map); + } + } + + @ControllerAdvice + private static class JsonpAdvice extends AbstractJsonpResponseBodyInterceptor { + + public JsonpAdvice() { + super(Arrays.asList("c")); } }