Provide Gson/JSON-B MessageConverter for spring-messaging (aligned with spring-web)

Closes gh-21496

Author: jhoeller

spring-messaging/spring-messaging.gradle

@@ -12,6 +12,8 @@ dependencies {
 	optional("io.rsocket:rsocket-core")
 	optional("io.rsocket:rsocket-transport-netty")
 	optional("com.fasterxml.jackson.core:jackson-databind")
+	optional("com.google.code.gson:gson")
+	optional("javax.json.bind:javax.json.bind-api")
 	optional("javax.xml.bind:jaxb-api")
 	optional("com.google.protobuf:protobuf-java-util")
 	optional("org.jetbrains.kotlinx:kotlinx-coroutines-core")
@@ -31,8 +33,10 @@ dependencies {
 	testCompile("org.jetbrains.kotlin:kotlin-stdlib")
 	testCompile("org.xmlunit:xmlunit-assertj")
 	testCompile("org.xmlunit:xmlunit-matchers")
+	testRuntime("com.sun.activation:javax.activation")
 	testRuntime("com.sun.xml.bind:jaxb-core")
 	testRuntime("com.sun.xml.bind:jaxb-impl")
-	testRuntime("com.sun.activation:javax.activation")
+	testRuntime("javax.json:javax.json-api")
+	testRuntime("org.apache.johnzon:johnzon-jsonb")
 	testRuntime(project(":spring-context"))
 }

spring-messaging/src/main/java/org/springframework/messaging/converter/AbstractJsonMessageConverter.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2002-2020 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
+ *
+ *      https://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.messaging.converter;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.Type;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+import org.springframework.lang.Nullable;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.MimeType;
+
+/**
+ * Common base class for plain JSON converters, e.g. Gson and JSON-B.
+ *
+ * @author Juergen Hoeller
+ * @since 5.3
+ * @see GsonMessageConverter
+ * @see JsonbMessageConverter
+ * @see #fromJson(Reader, Type)
+ * @see #fromJson(String, Type)
+ * @see #toJson(Object, Type)
+ * @see #toJson(Object, Type, Writer)
+ */
+public abstract class AbstractJsonMessageConverter extends AbstractMessageConverter {
+
+	private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
+
+
+	protected AbstractJsonMessageConverter() {
+		super(new MimeType("application", "json"));
+	}
+
+
+	@Override
+	protected boolean supports(Class<?> clazz) {
+		return true;
+	}
+
+	@Override
+	@Nullable
+	protected Object convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint) {
+		try {
+			Type resolvedType = getResolvedType(targetClass, conversionHint);
+			Object payload = message.getPayload();
+			if (ClassUtils.isAssignableValue(targetClass, payload)) {
+				return payload;
+			}
+			else if (payload instanceof byte[]) {
+				return fromJson(getReader((byte[]) payload, message.getHeaders()), resolvedType);
+			}
+			else {
+				// Assuming a text-based source payload
+				return fromJson(payload.toString(), resolvedType);
+			}
+		}
+		catch (Exception ex) {
+			throw new MessageConversionException(message, "Could not read JSON: " + ex.getMessage(), ex);
+		}
+	}
+
+	@Override
+	@Nullable
+	protected Object convertToInternal(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) {
+		try {
+			Type resolvedType = getResolvedType(payload.getClass(), conversionHint);
+			if (byte[].class == getSerializedPayloadClass()) {
+				ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
+				Writer writer = getWriter(out, headers);
+				toJson(payload, resolvedType, writer);
+				writer.flush();
+				return out.toByteArray();
+			}
+			else {
+				// Assuming a text-based target payload
+				return toJson(payload, resolvedType);
+			}
+		}
+		catch (Exception ex) {
+			throw new MessageConversionException("Could not write JSON: " + ex.getMessage(), ex);
+		}
+	}
+
+
+	private Reader getReader(byte[] payload, @Nullable MessageHeaders headers) {
+		InputStream in = new ByteArrayInputStream(payload);
+		return new InputStreamReader(in, getCharsetToUse(headers));
+	}
+
+	private Writer getWriter(ByteArrayOutputStream out, @Nullable MessageHeaders headers) {
+		return new OutputStreamWriter(out, getCharsetToUse(headers));
+	}
+
+	private Charset getCharsetToUse(@Nullable MessageHeaders headers) {
+		MimeType mimeType = getMimeType(headers);
+		return (mimeType != null && mimeType.getCharset() != null ? mimeType.getCharset() : DEFAULT_CHARSET);
+	}
+
+
+	protected abstract Object fromJson(Reader reader, Type resolvedType);
+
+	protected abstract Object fromJson(String payload, Type resolvedType);
+
+	protected abstract void toJson(Object payload, Type resolvedType, Writer writer);
+
+	protected abstract String toJson(Object payload, Type resolvedType);
+
+}

spring-messaging/src/main/java/org/springframework/messaging/converter/AbstractMessageConverter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -16,6 +16,7 @@
 
 package org.springframework.messaging.converter;
 
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -25,6 +26,8 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
+import org.springframework.core.GenericTypeResolver;
+import org.springframework.core.MethodParameter;
 import org.springframework.lang.Nullable;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageHeaders;
@@ -92,7 +95,7 @@ public List<MimeType> getSupportedMimeTypes() {
 	}
 
 	/**
-	 * Allows sub-classes to add more supported mime types.
+	 * Allows subclasses to add more supported mime types.
 	 * @since 5.2.2
 	 */
 	protected void addSupportedMimeTypes(MimeType... supportedMimeTypes) {
@@ -167,21 +170,6 @@ public Class<?> getSerializedPayloadClass() {
 	}
 
 
-	/**
-	 * Returns the default content type for the payload. Called when
-	 * {@link #toMessage(Object, MessageHeaders)} is invoked without message headers or
-	 * without a content type header.
-	 * <p>By default, this returns the first element of the {@link #getSupportedMimeTypes()
-	 * supportedMimeTypes}, if any. Can be overridden in sub-classes.
-	 * @param payload the payload being converted to message
-	 * @return the content type, or {@code null} if not known
-	 */
-	@Nullable
-	protected MimeType getDefaultContentType(Object payload) {
-		List<MimeType> mimeTypes = getSupportedMimeTypes();
-		return (!mimeTypes.isEmpty() ? mimeTypes.get(0) : null);
-	}
-
 	@Override
 	@Nullable
 	public final Object fromMessage(Message<?> message, Class<?> targetClass) {
@@ -197,10 +185,6 @@ public final Object fromMessage(Message<?> message, Class<?> targetClass, @Nulla
 		return convertFromInternal(message, targetClass, conversionHint);
 	}
 
-	protected boolean canConvertFrom(Message<?> message, Class<?> targetClass) {
-		return (supports(targetClass) && supportsMimeType(message.getHeaders()));
-	}
-
 	@Override
 	@Nullable
 	public final Message<?> toMessage(Object payload, @Nullable MessageHeaders headers) {
@@ -240,6 +224,11 @@ public final Message<?> toMessage(Object payload, @Nullable MessageHeaders heade
 		return builder.build();
 	}
 
+
+	protected boolean canConvertFrom(Message<?> message, Class<?> targetClass) {
+		return (supports(targetClass) && supportsMimeType(message.getHeaders()));
+	}
+
 	protected boolean canConvertTo(Object payload, @Nullable MessageHeaders headers) {
 		return (supports(payload.getClass()) && supportsMimeType(headers));
 	}
@@ -265,6 +254,22 @@ protected MimeType getMimeType(@Nullable MessageHeaders headers) {
 		return (headers != null && this.contentTypeResolver != null ? this.contentTypeResolver.resolve(headers) : null);
 	}
 
+	/**
+	 * Return the default content type for the payload. Called when
+	 * {@link #toMessage(Object, MessageHeaders)} is invoked without
+	 * message headers or without a content type header.
+	 * <p>By default, this returns the first element of the
+	 * {@link #getSupportedMimeTypes() supportedMimeTypes}, if any.
+	 * Can be overridden in subclasses.
+	 * @param payload the payload being converted to a message
+	 * @return the content type, or {@code null} if not known
+	 */
+	@Nullable
+	protected MimeType getDefaultContentType(Object payload) {
+		List<MimeType> mimeTypes = getSupportedMimeTypes();
+		return (!mimeTypes.isEmpty() ? mimeTypes.get(0) : null);
+	}
+
 
 	/**
 	 * Whether the given class is supported by this converter.
@@ -307,4 +312,19 @@ protected Object convertToInternal(
 		return null;
 	}
 
+
+	static Type getResolvedType(Class<?> targetClass, @Nullable Object conversionHint) {
+		if (conversionHint instanceof MethodParameter) {
+			MethodParameter param = (MethodParameter) conversionHint;
+			param = param.nestedIfOptional();
+			if (Message.class.isAssignableFrom(param.getParameterType())) {
+				param = param.nested();
+			}
+			Type genericParameterType = param.getNestedGenericParameterType();
+			Class<?> contextClass = param.getContainingClass();
+			return GenericTypeResolver.resolveType(genericParameterType, contextClass);
+		}
+		return targetClass;
+	}
+
 }

spring-messaging/src/main/java/org/springframework/messaging/converter/GsonMessageConverter.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2002-2020 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
+ *
+ *      https://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.messaging.converter;
+
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+import com.google.gson.Gson;
+
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link MessageConverter} that can read and write JSON
+ * using <a href="https://code.google.com/p/google-gson/">Google Gson</a>.
+ *
+ * @author Juergen Hoeller
+ * @since 5.3
+ * @see com.google.gson.Gson
+ * @see com.google.gson.GsonBuilder
+ * @see #setGson
+ */
+public class GsonMessageConverter extends AbstractJsonMessageConverter {
+
+	private Gson gson;
+
+
+	/**
+	 * Construct a new {@code GsonMessageConverter} with default configuration.
+	 */
+	public GsonMessageConverter() {
+		this.gson = new Gson();
+	}
+
+	/**
+	 * Construct a new {@code GsonMessageConverter} with the given delegate.
+	 * @param gson the Gson instance to use
+	 */
+	public GsonMessageConverter(Gson gson) {
+		Assert.notNull(gson, "A Gson instance is required");
+		this.gson = gson;
+	}
+
+
+	/**
+	 * Set the {@code Gson} instance to use.
+	 * If not set, a default {@link Gson#Gson() Gson} instance will be used.
+	 * <p>Setting a custom-configured {@code Gson} is one way to take further
+	 * control of the JSON serialization process.
+	 * @see #GsonMessageConverter(Gson)
+	 */
+	public void setGson(Gson gson) {
+		Assert.notNull(gson, "A Gson instance is required");
+		this.gson = gson;
+	}
+
+	/**
+	 * Return the configured {@code Gson} instance for this converter.
+	 */
+	public Gson getGson() {
+		return this.gson;
+	}
+
+
+	@Override
+	protected Object fromJson(Reader reader, Type resolvedType) {
+		return getGson().fromJson(reader, resolvedType);
+	}
+
+	@Override
+	protected Object fromJson(String payload, Type resolvedType) {
+		return getGson().fromJson(payload, resolvedType);
+	}
+
+	@Override
+	protected void toJson(Object payload, Type resolvedType, Writer writer) {
+		if (resolvedType instanceof ParameterizedType) {
+			getGson().toJson(payload, resolvedType, writer);
+		}
+		else {
+			getGson().toJson(payload, writer);
+		}
+	}
+
+	@Override
+	protected String toJson(Object payload, Type resolvedType) {
+		if (resolvedType instanceof ParameterizedType) {
+			return getGson().toJson(payload, resolvedType);
+		}
+		else {
+			return getGson().toJson(payload);
+		}
+	}
+
+}