Support Jackson based XML serialization/deserialization

This commit adds support for XML serialization/deserialization based on
the jackson-dataformat-xml extension. When using @EnableWebMvc or
<mvc:annotation-driven/>, Jackson will be used  by default instead of JAXB2
if jackson-dataformat-xml classes are found in the classpath.

This commit introduces MappingJackson2XmlHttpMessageConverter and
MappingJackson2XmlView classes, and common parts between JSON
and XML processing have been moved to AbstractJackson2HttpMessageConverter
and AbstractJackson2View classes.

MappingJackson2XmlView supports serialization of a single object. If the model
contains multiple entries, MappingJackson2XmlView.setModelKey() should be
used to specify the entry to serialize.

Pretty print works in XML, but tests are not included since a Woodstox dependency
is needed, and it is better to continue testing spring-web and spring-webmvc
against JAXB2.

Issue: SPR-11785

spring-web/src/main/java/org/springframework/http/converter/json/AbstractJackson2HttpMessageConverter.java

@@ -0,0 +1,315 @@
+/*
+ * 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.http.converter.json;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.fasterxml.jackson.core.JsonEncoding;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+
+import org.springframework.http.HttpInputMessage;
+import org.springframework.http.HttpOutputMessage;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.AbstractHttpMessageConverter;
+import org.springframework.http.converter.GenericHttpMessageConverter;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.http.converter.HttpMessageNotWritableException;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Abstract base class for Jackson based and content type independent
+ * {@link HttpMessageConverter} implementations.
+ *
+ * <p>Compatible with Jackson 2.1 and higher.
+ *
+ * @author Arjen Poutsma
+ * @author Keith Donald
+ * @author Rossen Stoyanchev
+ * @author Juergen Hoeller
+ * @author Sebastien Deleuze
+ * @since 4.1
+ */
+public abstract class AbstractJackson2HttpMessageConverter extends
+		AbstractHttpMessageConverter<Object> implements GenericHttpMessageConverter<Object> {
+
+	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+
+	// Check for Jackson 2.3's overloaded canDeserialize/canSerialize variants with cause reference
+	private static final boolean jackson23Available = ClassUtils.hasMethod(ObjectMapper.class,
+			"canDeserialize", JavaType.class, AtomicReference.class);
+
+
+	protected ObjectMapper objectMapper;
+
+	private Boolean prettyPrint;
+
+
+	protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper) {
+		this.objectMapper = objectMapper;
+	}
+
+	protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType supportedMediaType) {
+		super(supportedMediaType);
+		this.objectMapper = objectMapper;
+	}
+
+	protected AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType... supportedMediaTypes) {
+		super(supportedMediaTypes);
+		this.objectMapper = objectMapper;
+	}
+
+	/**
+	 * Set the {@code ObjectMapper} for this view.
+	 * If not set, a default {@link ObjectMapper#ObjectMapper() ObjectMapper} is used.
+	 * <p>Setting a custom-configured {@code ObjectMapper} is one way to take further
+	 * control of the JSON serialization process. For example, an extended
+	 * {@link com.fasterxml.jackson.databind.ser.SerializerFactory}
+	 * can be configured that provides custom serializers for specific types.
+	 * The other option for refining the serialization process is to use Jackson's
+	 * provided annotations on the types to be serialized, in which case a
+	 * custom-configured ObjectMapper is unnecessary.
+	 */
+	public void setObjectMapper(ObjectMapper objectMapper) {
+		Assert.notNull(objectMapper, "ObjectMapper must not be null");
+		this.objectMapper = objectMapper;
+		configurePrettyPrint();
+	}
+
+	/**
+	 * Return the underlying {@code ObjectMapper} for this view.
+	 */
+	public ObjectMapper getObjectMapper() {
+		return this.objectMapper;
+	}
+
+	/**
+	 * Whether to use the {@link DefaultPrettyPrinter} when writing JSON.
+	 * This is a shortcut for setting up an {@code ObjectMapper} as follows:
+	 * <pre class="code">
+	 * ObjectMapper mapper = new ObjectMapper();
+	 * mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
+	 * converter.setObjectMapper(mapper);
+	 * </pre>
+	 */
+	public void setPrettyPrint(boolean prettyPrint) {
+		this.prettyPrint = prettyPrint;
+		configurePrettyPrint();
+	}
+
+	private void configurePrettyPrint() {
+		if (this.prettyPrint != null) {
+			this.objectMapper.configure(SerializationFeature.INDENT_OUTPUT, this.prettyPrint);
+		}
+	}
+
+	@Override
+	public boolean canRead(Class<?> clazz, MediaType mediaType) {
+		return canRead(clazz, null, mediaType);
+	}
+
+	@Override
+	public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) {
+		JavaType javaType = getJavaType(type, contextClass);
+		if (!jackson23Available || !logger.isWarnEnabled()) {
+			return (this.objectMapper.canDeserialize(javaType) && canRead(mediaType));
+		}
+		AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
+		if (this.objectMapper.canDeserialize(javaType, causeRef) && canRead(mediaType)) {
+			return true;
+		}
+		Throwable cause = causeRef.get();
+		if (cause != null) {
+			String msg = "Failed to evaluate deserialization for type " + javaType;
+			if (logger.isDebugEnabled()) {
+				logger.warn(msg, cause);
+			}
+			else {
+				logger.warn(msg + ": " + cause);
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
+		if (!jackson23Available || !logger.isWarnEnabled()) {
+			return (this.objectMapper.canSerialize(clazz) && canWrite(mediaType));
+		}
+		AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
+		if (this.objectMapper.canSerialize(clazz, causeRef) && canWrite(mediaType)) {
+			return true;
+		}
+		Throwable cause = causeRef.get();
+		if (cause != null) {
+			String msg = "Failed to evaluate serialization for type [" + clazz + "]";
+			if (logger.isDebugEnabled()) {
+				logger.warn(msg, cause);
+			}
+			else {
+				logger.warn(msg + ": " + cause);
+			}
+		}
+		return false;
+	}
+
+	@Override
+	protected boolean supports(Class<?> clazz) {
+		// should not be called, since we override canRead/Write instead
+		throw new UnsupportedOperationException();
+	}
+
+	@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 readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
+		try {
+			return this.objectMapper.readValue(inputMessage.getBody(), javaType);
+		}
+		catch (IOException ex) {
+			throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
+		}
+	}
+
+	@Override
+	protected void writeInternal(Object object, HttpOutputMessage outputMessage)
+			throws IOException, HttpMessageNotWritableException {
+
+		JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
+		JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
+		try {
+			writePrefix(generator, object);
+			Class<?> serializationView = null;
+			Object value = object;
+			if (value instanceof MappingJacksonValue) {
+				MappingJacksonValue container = (MappingJacksonValue) object;
+				value = container.getValue();
+				serializationView = container.getSerializationView();
+			}
+			if (serializationView != null) {
+				this.objectMapper.writerWithView(serializationView).writeValue(generator, value);
+			}
+			else {
+				this.objectMapper.writeValue(generator, value);
+			}
+			writeSuffix(generator, object);
+			generator.flush();
+
+		}
+		catch (JsonProcessingException ex) {
+			throw new HttpMessageNotWritableException("Could not write content: " + ex.getMessage(), ex);
+		}
+	}
+
+	/**
+	 * Write a prefix before the main content.
+	 * @param generator the generator to use for writing content.
+	 * @param object the object to write to the output message.
+	 */
+	protected void writePrefix(JsonGenerator generator, Object object) throws IOException {
+
+	}
+
+	/**
+	 * Write a suffix after the main content.
+	 * @param generator the generator to use for writing content.
+	 * @param object the object to write to the output message.
+	 */
+	protected void writeSuffix(JsonGenerator generator, Object object) throws IOException {
+
+	}
+
+	/**
+	 * Return the Jackson {@link JavaType} for the specified type and context class.
+	 * <p>The default implementation returns {@code typeFactory.constructType(type, contextClass)},
+	 * but this can be overridden in subclasses, to allow for custom generic collection handling.
+	 * For instance:
+	 * <pre class="code">
+	 * protected JavaType getJavaType(Type type) {
+	 *   if (type instanceof Class && List.class.isAssignableFrom((Class)type)) {
+	 *     return TypeFactory.collectionType(ArrayList.class, MyBean.class);
+	 *   } else {
+	 *     return super.getJavaType(type);
+	 *   }
+	 * }
+	 * </pre>
+	 * @param type the type to return the java type for
+	 * @param contextClass a context class for the target type, for example a class
+	 * in which the target type appears in a method signature, can be {@code null}
+	 * signature, can be {@code null}
+	 * @return the java type
+	 */
+	protected JavaType getJavaType(Type type, Class<?> contextClass) {
+		return this.objectMapper.getTypeFactory().constructType(type, contextClass);
+	}
+
+	/**
+	 * Determine the JSON encoding to use for the given content type.
+	 * @param contentType the media type as requested by the caller
+	 * @return the JSON encoding to use (never {@code null})
+	 */
+	protected JsonEncoding getJsonEncoding(MediaType contentType) {
+		if (contentType != null && contentType.getCharSet() != null) {
+			Charset charset = contentType.getCharSet();
+			for (JsonEncoding encoding : JsonEncoding.values()) {
+				if (charset.name().equals(encoding.getJavaName())) {
+					return encoding;
+				}
+			}
+		}
+		return JsonEncoding.UTF8;
+	}
+
+	@Override
+	protected MediaType getDefaultContentType(Object object) throws IOException {
+		if (object instanceof MappingJacksonValue) {
+			object = ((MappingJacksonValue) object).getValue();
+		}
+		return super.getDefaultContentType(object);
+	}
+
+	@Override
+	protected Long getContentLength(Object object, MediaType contentType) throws IOException {
+		if (object instanceof MappingJacksonValue) {
+			object = ((MappingJacksonValue) object).getValue();
+		}
+		return super.getContentLength(object, contentType);
+	}
+
+}

spring-web/src/main/java/org/springframework/http/converter/json/Jackson2ObjectMapperFactoryBean.java

@@ -51,7 +51,7 @@ import org.springframework.util.ClassUtils;
  * to enable or disable Jackson features from within XML configuration.
  *
  * <p>Example usage with
- * {@link org.springframework.http.converter.json.MappingJackson2HttpMessageConverter}:
+ * {@link MappingJackson2HttpMessageConverter}:
  *
  * <pre class="code">
  * &lt;bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
@@ -486,7 +486,8 @@ public class Jackson2ObjectMapperFactoryBean implements FactoryBean<ObjectMapper
 
 	@Override
 	public Class<?> getObjectType() {
-		return ObjectMapper.class;
+		Assert.notNull(this.objectMapper, "ObjectMapper must not be null");
+		return this.objectMapper.getClass();
 	}
 
 	@Override

spring-web/src/main/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverter.java

@@ -17,27 +17,11 @@
 package org.springframework.http.converter.json;
 
 import java.io.IOException;
-import java.lang.reflect.Type;
-import java.nio.charset.Charset;
-import java.util.concurrent.atomic.AtomicReference;
 
-import com.fasterxml.jackson.core.JsonEncoding;
 import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
-import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
 
-import org.springframework.http.HttpInputMessage;
-import org.springframework.http.HttpOutputMessage;
 import org.springframework.http.MediaType;
-import org.springframework.http.converter.AbstractHttpMessageConverter;
-import org.springframework.http.converter.GenericHttpMessageConverter;
-import org.springframework.http.converter.HttpMessageNotReadableException;
-import org.springframework.http.converter.HttpMessageNotWritableException;
-import org.springframework.util.Assert;
-import org.springframework.util.ClassUtils;
 
 /**
  * Implementation of {@link org.springframework.http.converter.HttpMessageConverter HttpMessageConverter} that
@@ -54,58 +38,22 @@ import org.springframework.util.ClassUtils;
  * @author Keith Donald
  * @author Rossen Stoyanchev
  * @author Juergen Hoeller
+ * @author Sebastien Deleuze
  * @since 3.1.2
  */
-public class MappingJackson2HttpMessageConverter extends AbstractHttpMessageConverter<Object>
-		implements GenericHttpMessageConverter<Object> {
-
-	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
-
-	// Check for Jackson 2.3's overloaded canDeserialize/canSerialize variants with cause reference
-	private static final boolean jackson23Available =
-			ClassUtils.hasMethod(ObjectMapper.class, "canDeserialize", JavaType.class, AtomicReference.class);
-
-
-	private ObjectMapper objectMapper = new ObjectMapper();
+public class MappingJackson2HttpMessageConverter extends AbstractJackson2HttpMessageConverter {
 
 	private String jsonPrefix;
 
-	private Boolean prettyPrint;
-
 
 	/**
 	 * Construct a new {@code MappingJackson2HttpMessageConverter}.
 	 */
 	public MappingJackson2HttpMessageConverter() {
-		super(new MediaType("application", "json", DEFAULT_CHARSET),
+		super(new ObjectMapper(), new MediaType("application", "json", DEFAULT_CHARSET),
 				new MediaType("application", "*+json", DEFAULT_CHARSET));
 	}
 
-
-	/**
-	 * Set the {@code ObjectMapper} for this view.
-	 * If not set, a default {@link ObjectMapper#ObjectMapper() ObjectMapper} is used.
-	 * <p>Setting a custom-configured {@code ObjectMapper} is one way to take further
-	 * control of the JSON serialization process. For example, an extended
-	 * {@link com.fasterxml.jackson.databind.ser.SerializerFactory}
-	 * can be configured that provides custom serializers for specific types.
-	 * The other option for refining the serialization process is to use Jackson's
-	 * provided annotations on the types to be serialized, in which case a
-	 * custom-configured ObjectMapper is unnecessary.
-	 */
-	public void setObjectMapper(ObjectMapper objectMapper) {
-		Assert.notNull(objectMapper, "ObjectMapper must not be null");
-		this.objectMapper = objectMapper;
-		configurePrettyPrint();
-	}
-
-	/**
-	 * Return the underlying {@code ObjectMapper} for this view.
-	 */
-	public ObjectMapper getObjectMapper() {
-		return this.objectMapper;
-	}
-
 	/**
 	 * Specify a custom prefix to use for this view's JSON output.
 	 * Default is none.
@@ -127,199 +75,29 @@ public class MappingJackson2HttpMessageConverter extends AbstractHttpMessageConv
 		this.jsonPrefix = (prefixJson ? "{} && " : null);
 	}
 
-	/**
-	 * Whether to use the {@link DefaultPrettyPrinter} when writing JSON.
-	 * This is a shortcut for setting up an {@code ObjectMapper} as follows:
-	 * <pre class="code">
-	 * ObjectMapper mapper = new ObjectMapper();
-	 * mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
-	 * converter.setObjectMapper(mapper);
-	 * </pre>
-	 */
-	public void setPrettyPrint(boolean prettyPrint) {
-		this.prettyPrint = prettyPrint;
-		configurePrettyPrint();
-	}
-
-	private void configurePrettyPrint() {
-		if (this.prettyPrint != null) {
-			this.objectMapper.configure(SerializationFeature.INDENT_OUTPUT, this.prettyPrint);
-		}
-	}
-
 	@Override
-	public boolean canRead(Class<?> clazz, MediaType mediaType) {
-		return canRead(clazz, null, mediaType);
-	}
-
-	@Override
-	public boolean canRead(Type type, Class<?> contextClass, MediaType mediaType) {
-		JavaType javaType = getJavaType(type, contextClass);
-		if (!jackson23Available || !logger.isWarnEnabled()) {
-			return (this.objectMapper.canDeserialize(javaType) && canRead(mediaType));
+	protected void writePrefix(JsonGenerator generator, Object object) throws IOException {
+		if (this.jsonPrefix != null) {
+			generator.writeRaw(this.jsonPrefix);
 		}
-		AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
-		if (this.objectMapper.canDeserialize(javaType, causeRef) && canRead(mediaType)) {
-			return true;
-		}
-		Throwable cause = causeRef.get();
-		if (cause != null) {
-			String msg = "Failed to evaluate deserialization for type " + javaType;
-			if (logger.isDebugEnabled()) {
-				logger.warn(msg, cause);
-			}
-			else {
-				logger.warn(msg + ": " + cause);
-			}
-		}
-		return false;
-	}
-
-	@Override
-	public boolean canWrite(Class<?> clazz, MediaType mediaType) {
-		if (!jackson23Available || !logger.isWarnEnabled()) {
-			return (this.objectMapper.canSerialize(clazz) && canWrite(mediaType));
-		}
-		AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
-		if (this.objectMapper.canSerialize(clazz, causeRef) && canWrite(mediaType)) {
-			return true;
-		}
-		Throwable cause = causeRef.get();
-		if (cause != null) {
-			String msg = "Failed to evaluate serialization for type [" + clazz + "]";
-			if (logger.isDebugEnabled()) {
-				logger.warn(msg, cause);
-			}
-			else {
-				logger.warn(msg + ": " + cause);
-			}
-		}
-		return false;
-	}
-
-	@Override
-	protected boolean supports(Class<?> clazz) {
-		// should not be called, since we override canRead/Write instead
-		throw new UnsupportedOperationException();
-	}
-
-	@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 readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
-		try {
-			return this.objectMapper.readValue(inputMessage.getBody(), javaType);
-		}
-		catch (IOException ex) {
-			throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
-		}
-	}
-
-	@Override
-	protected void writeInternal(Object object, HttpOutputMessage outputMessage)
-			throws IOException, HttpMessageNotWritableException {
-
-		JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
-		JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
-		try {
-			if (this.jsonPrefix != null) {
-				generator.writeRaw(this.jsonPrefix);
-			}
-			Class<?> serializationView = null;
-			String jsonpFunction = null;
-			if (object instanceof MappingJacksonValue) {
-				MappingJacksonValue container = (MappingJacksonValue) object;
-				object = container.getValue();
-				serializationView = container.getSerializationView();
-				jsonpFunction = container.getJsonpFunction();
-			}
-			if (jsonpFunction != null) {
-				generator.writeRaw(jsonpFunction + "(");
-			}
-			if (serializationView != null) {
-				this.objectMapper.writerWithView(serializationView).writeValue(generator, object);
-			}
-			else {
-				this.objectMapper.writeValue(generator, object);
-			}
-			if (jsonpFunction != null) {
-				generator.writeRaw(");");
-				generator.flush();
-			}
-		}
-		catch (JsonProcessingException ex) {
-			throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
-		}
-	}
-
-	/**
-	 * Return the Jackson {@link JavaType} for the specified type and context class.
-	 * <p>The default implementation returns {@code typeFactory.constructType(type, contextClass)},
-	 * but this can be overridden in subclasses, to allow for custom generic collection handling.
-	 * For instance:
-	 * <pre class="code">
-	 * protected JavaType getJavaType(Type type) {
-	 *   if (type instanceof Class && List.class.isAssignableFrom((Class)type)) {
-	 *     return TypeFactory.collectionType(ArrayList.class, MyBean.class);
-	 *   } else {
-	 *     return super.getJavaType(type);
-	 *   }
-	 * }
-	 * </pre>
-	 * @param type the type to return the java type for
-	 * @param contextClass a context class for the target type, for example a class
-	 * in which the target type appears in a method signature, can be {@code null}
-	 * signature, can be {@code null}
-	 * @return the java type
-	 */
-	protected JavaType getJavaType(Type type, Class<?> contextClass) {
-		return this.objectMapper.getTypeFactory().constructType(type, contextClass);
-	}
-
-	/**
-	 * Determine the JSON encoding to use for the given content type.
-	 * @param contentType the media type as requested by the caller
-	 * @return the JSON encoding to use (never {@code null})
-	 */
-	protected JsonEncoding getJsonEncoding(MediaType contentType) {
-		if (contentType != null && contentType.getCharSet() != null) {
-			Charset charset = contentType.getCharSet();
-			for (JsonEncoding encoding : JsonEncoding.values()) {
-				if (charset.name().equals(encoding.getJavaName())) {
-					return encoding;
-				}
-			}
-		}
-		return JsonEncoding.UTF8;
-	}
-
-	@Override
-	protected MediaType getDefaultContentType(Object object) throws IOException {
+		String jsonpFunction = null;
 		if (object instanceof MappingJacksonValue) {
-			object = ((MappingJacksonValue) object).getValue();
+			jsonpFunction = ((MappingJacksonValue)object).getJsonpFunction();
+		}
+		if (jsonpFunction != null) {
+			generator.writeRaw(jsonpFunction + "(");
 		}
-		return super.getDefaultContentType(object);
 	}
 
 	@Override
-	protected Long getContentLength(Object object, MediaType contentType) throws IOException {
+	protected void writeSuffix(JsonGenerator generator, Object object) throws IOException {
+		String jsonpFunction = null;
 		if (object instanceof MappingJacksonValue) {
-			object = ((MappingJacksonValue) object).getValue();
+			jsonpFunction = ((MappingJacksonValue)object).getJsonpFunction();
+		}
+		if (jsonpFunction != null) {
+			generator.writeRaw(");");
 		}
-		return super.getContentLength(object, contentType);
 	}
 
 }

spring-web/src/main/java/org/springframework/http/converter/json/MappingJacksonValue.java

@@ -18,9 +18,8 @@ package org.springframework.http.converter.json;
 
 /**
  * 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.
+ * {@link MappingJackson2HttpMessageConverter} along with further
+ * serialization instructions to be passed in to the converter.
  *
  * <p>On the server side this wrapper is added with a
  * {@code ResponseBodyInterceptor} after content negotiation selects the

spring-web/src/main/java/org/springframework/http/converter/xml/MappingJackson2XmlHttpMessageConverter.java

@@ -0,0 +1,40 @@
+/*
+ * 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.http.converter.xml;
+
+import com.fasterxml.jackson.dataformat.xml.XmlMapper;
+
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter;
+import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
+
+/**
+ * Implementation of {@link org.springframework.http.converter.HttpMessageConverter HttpMessageConverter} that
+ * can read and write XML using <a href="https://github.com/FasterXML/jackson-dataformat-xml">Jackson 2.x extension component for
+ * reading and writing XML encoded data</a>.
+ *
+ * @author Sebastien Deleuze
+ * @since 4.1
+ */
+public class MappingJackson2XmlHttpMessageConverter extends AbstractJackson2HttpMessageConverter {
+
+	public MappingJackson2XmlHttpMessageConverter() {
+		super(new XmlMapper(),
+				new MediaType("application", "xml", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET));
+	}
+
+}

spring-web/src/test/java/org/springframework/http/converter/json/Jackson2ObjectMapperFactoryBeanTests.java

@@ -45,6 +45,7 @@ import com.fasterxml.jackson.databind.ser.Serializers;
 import com.fasterxml.jackson.databind.ser.std.ClassSerializer;
 import com.fasterxml.jackson.databind.ser.std.NumberSerializer;
 import com.fasterxml.jackson.databind.type.SimpleType;
+import com.fasterxml.jackson.dataformat.xml.XmlMapper;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -70,7 +71,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSettersWithNullValues() {
+	public void settersWithNullValues() {
 		// Should not crash:
 		factory.setSerializers((JsonSerializer<?>[]) null);
 		factory.setSerializersByType(null);
@@ -80,13 +81,13 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test(expected = FatalBeanException.class)
-	public void testUnknownFeature() {
+	public void unknownFeature() {
 		this.factory.setFeaturesToEnable(Boolean.TRUE);
 		this.factory.afterPropertiesSet();
 	}
 
 	@Test
-	public void testBooleanSetters() {
+	public void booleanSetters() {
 		this.factory.setAutoDetectFields(false);
 		this.factory.setAutoDetectGettersSetters(false);
 		this.factory.setDefaultViewInclusion(false);
@@ -107,7 +108,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSetNotNullSerializationInclusion() {
+	public void setNotNullSerializationInclusion() {
 		factory.afterPropertiesSet();
 		assertTrue(factory.getObject().getSerializationConfig().getSerializationInclusion() == JsonInclude.Include.ALWAYS);
 
@@ -117,7 +118,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSetNotDefaultSerializationInclusion() {
+	public void setNotDefaultSerializationInclusion() {
 		factory.afterPropertiesSet();
 		assertTrue(factory.getObject().getSerializationConfig().getSerializationInclusion() == JsonInclude.Include.ALWAYS);
 
@@ -127,7 +128,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSetNotEmptySerializationInclusion() {
+	public void setNotEmptySerializationInclusion() {
 		factory.afterPropertiesSet();
 		assertTrue(factory.getObject().getSerializationConfig().getSerializationInclusion() == JsonInclude.Include.ALWAYS);
 
@@ -137,7 +138,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testDateTimeFormatSetter() {
+	public void dateTimeFormatSetter() {
 		SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
 
 		this.factory.setDateFormat(dateFormat);
@@ -148,7 +149,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSimpleDateFormatStringSetter() {
+	public void simpleDateFormatStringSetter() {
 		SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
 
 		this.factory.setSimpleDateFormat(DATE_FORMAT);
@@ -159,7 +160,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSetModules() {
+	public void setModules() {
 		NumberSerializer serializer1 = new NumberSerializer();
 		SimpleModule module = new SimpleModule();
 		module.addSerializer(Integer.class, serializer1);
@@ -173,7 +174,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testSimpleSetup() {
+	public void simpleSetup() {
 		this.factory.afterPropertiesSet();
 
 		assertNotNull(this.factory.getObject());
@@ -190,7 +191,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testPropertyNamingStrategy() {
+	public void propertyNamingStrategy() {
 		PropertyNamingStrategy strategy = new PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy();
 		this.factory.setPropertyNamingStrategy(strategy);
 		this.factory.afterPropertiesSet();
@@ -200,18 +201,17 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 	}
 
 	@Test
-	public void testCompleteSetup() {
+	public void completeSetup() {
 		NopAnnotationIntrospector annotationIntrospector = NopAnnotationIntrospector.instance;
 		ObjectMapper objectMapper = new ObjectMapper();
 
+		factory.setObjectMapper(objectMapper);
 		assertTrue(this.factory.isSingleton());
 		assertEquals(ObjectMapper.class, this.factory.getObjectType());
 
 		Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<Class<?>, JsonDeserializer<?>>();
 		deserializers.put(Date.class, new DateDeserializer());
 
-		factory.setObjectMapper(objectMapper);
-
 		JsonSerializer<Class<?>> serializer1 = new ClassSerializer();
 		JsonSerializer<Number> serializer2 = new NumberSerializer();
 
@@ -261,4 +261,14 @@ public class Jackson2ObjectMapperFactoryBeanTests {
 		assertTrue(objectMapper.getSerializationConfig().getSerializationInclusion() == JsonInclude.Include.NON_NULL);
 	}
 
+	@Test
+	public void xmlMapper() {
+		this.factory.setObjectMapper(new XmlMapper());
+		this.factory.afterPropertiesSet();
+
+		assertNotNull(this.factory.getObject());
+		assertTrue(this.factory.isSingleton());
+		assertEquals(XmlMapper.class, this.factory.getObjectType());
+	}
+
 }

spring-web/src/test/java/org/springframework/http/converter/xml/MappingJackson2XmlHttpMessageConverterTests.java

@@ -0,0 +1,241 @@
+/*
+ * 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.http.converter.xml;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+
+import com.fasterxml.jackson.annotation.JsonView;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+import org.springframework.http.HttpOutputMessage;
+import org.springframework.http.MediaType;
+import org.springframework.http.MockHttpInputMessage;
+import org.springframework.http.MockHttpOutputMessage;
+import org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.http.converter.json.MappingJacksonValue;
+
+/**
+ * Jackson 2.x XML converter tests.
+ *
+ * @author Sebastien Deleuze
+ */
+public class MappingJackson2XmlHttpMessageConverterTests {
+
+	private final MappingJackson2XmlHttpMessageConverter converter = new MappingJackson2XmlHttpMessageConverter();
+
+
+	@Test
+	public void canRead() {
+		assertTrue(converter.canRead(MyBean.class, new MediaType("application", "xml")));
+	}
+
+	@Test
+	public void canWrite() {
+		assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "xml")));
+	}
+
+	@Test
+	public void read() throws IOException {
+		String body =
+				"<MyBean><string>Foo</string><number>42</number><fraction>42.0</fraction><array><array>Foo</array><array>Bar</array></array><bool>true</bool><bytes>AQI=</bytes></MyBean>";
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		MyBean result = (MyBean) converter.read(MyBean.class, inputMessage);
+		assertEquals("Foo", result.getString());
+		assertEquals(42, result.getNumber());
+		assertEquals(42F, result.getFraction(), 0F);
+		assertArrayEquals(new String[]{"Foo", "Bar"}, result.getArray());
+		assertTrue(result.isBool());
+		assertArrayEquals(new byte[]{0x1, 0x2}, result.getBytes());
+	}
+
+	@Test
+	public void write() throws IOException {
+		MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
+		MyBean body = new MyBean();
+		body.setString("Foo");
+		body.setNumber(42);
+		body.setFraction(42F);
+		body.setArray(new String[]{"Foo", "Bar"});
+		body.setBool(true);
+		body.setBytes(new byte[]{0x1, 0x2});
+		converter.write(body, null, outputMessage);
+		Charset utf8 = Charset.forName("UTF-8");
+		String result = outputMessage.getBodyAsString(utf8);
+		assertTrue(result.contains("<string>Foo</string>"));
+		assertTrue(result.contains("<number>42</number>"));
+		assertTrue(result.contains("<fraction>42.0</fraction>"));
+		assertTrue(result.contains("<array><array>Foo</array><array>Bar</array></array>"));
+		assertTrue(result.contains("<bool>true</bool>"));
+		assertTrue(result.contains("<bytes>AQI=</bytes>"));
+		assertEquals("Invalid content-type", new MediaType("application", "xml", utf8),
+				outputMessage.getHeaders().getContentType());
+	}
+
+	@Test(expected = HttpMessageNotReadableException.class)
+	public void readInvalidXml() throws IOException {
+		String body = "FooBar";
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		converter.read(MyBean.class, inputMessage);
+	}
+
+	@Test(expected = HttpMessageNotReadableException.class)
+	public void readValidXmlWithUnknownProperty() throws IOException {
+		String body = "<MyBean><string>string</string><unknownProperty>value</unknownProperty></MyBean>";
+		MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
+		inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
+		converter.read(MyBean.class, inputMessage);
+	}
+
+	@Test
+	public void jsonView() 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);
+		this.writeInternal(jacksonValue, outputMessage);
+
+		String result = outputMessage.getBodyAsString(Charset.forName("UTF-8"));
+		assertThat(result, containsString("<withView1>with</withView1>"));
+		assertThat(result, containsString("<withoutView>without</withoutView>"));
+		assertThat(result, not(containsString("<withView2>with</withView2>")));
+	}
+
+	private void writeInternal(Object object, HttpOutputMessage outputMessage)
+			throws NoSuchMethodException, InvocationTargetException,
+			IllegalAccessException {
+		Method method = AbstractJackson2HttpMessageConverter.class.getDeclaredMethod(
+				"writeInternal", Object.class, HttpOutputMessage.class);
+		method.setAccessible(true);
+		method.invoke(this.converter, object, outputMessage);
+	}
+
+
+	public static class MyBean {
+
+		private String string;
+
+		private int number;
+
+		private float fraction;
+
+		private String[] array;
+
+		private boolean bool;
+
+		private byte[] bytes;
+
+		public byte[] getBytes() {
+			return bytes;
+		}
+
+		public void setBytes(byte[] bytes) {
+			this.bytes = bytes;
+		}
+
+		public boolean isBool() {
+			return bool;
+		}
+
+		public void setBool(boolean bool) {
+			this.bool = bool;
+		}
+
+		public String getString() {
+			return string;
+		}
+
+		public void setString(String string) {
+			this.string = string;
+		}
+
+		public int getNumber() {
+			return number;
+		}
+
+		public void setNumber(int number) {
+			this.number = number;
+		}
+
+		public float getFraction() {
+			return fraction;
+		}
+
+		public void setFraction(float fraction) {
+			this.fraction = fraction;
+		}
+
+		public String[] getArray() {
+			return array;
+		}
+
+		public void setArray(String[] array) {
+			this.array = array;
+		}
+	}
+
+	private interface MyJacksonView1 {};
+	private interface MyJacksonView2 {};
+
+	private static class JacksonViewBean {
+
+		@JsonView(MyJacksonView1.class)
+		private String withView1;
+
+		@JsonView(MyJacksonView2.class)
+		private String withView2;
+
+		private String withoutView;
+
+		public String getWithView1() {
+			return withView1;
+		}
+
+		public void setWithView1(String withView1) {
+			this.withView1 = withView1;
+		}
+
+		public String getWithView2() {
+			return withView2;
+		}
+
+		public void setWithView2(String withView2) {
+			this.withView2 = withView2;
+		}
+
+		public String getWithoutView() {
+			return withoutView;
+		}
+
+		public void setWithoutView(String withoutView) {
+			this.withoutView = withoutView;
+		}
+	}
+
+}