Introduce JacksonObjectReader and JacksonObjectWriter function interfaces to customize JSON (de)serialization.

We now encapsulate serialization and deserialization operations as JacksonObjectWriter and JacksonObjectReader functions to allow customization of Jackson serialization.

Closes: #2322
Original Pull Request: #2332

Author: mp911de

src/main/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializer.java

@@ -25,7 +25,6 @@
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
 import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
 import com.fasterxml.jackson.databind.SerializerProvider;
@@ -37,6 +36,9 @@
 
 /**
  * Generic Jackson 2-based {@link RedisSerializer} that maps {@link Object objects} to JSON using dynamic typing.
+ * <p>
+ * JSON reading and writing can be customized by configuring {@link JacksonObjectReader} respective
+ * {@link JacksonObjectWriter}.
  *
  * @author Christoph Strobl
  * @author Mark Paluch
@@ -47,6 +49,10 @@ public class GenericJackson2JsonRedisSerializer implements RedisSerializer<Objec
 
 	private final ObjectMapper mapper;
 
+	private final JacksonObjectReader reader;
+
+	private final JacksonObjectWriter writer;
+
 	/**
 	 * Creates {@link GenericJackson2JsonRedisSerializer} and configures {@link ObjectMapper} for default typing.
 	 */
@@ -59,13 +65,30 @@ public GenericJackson2JsonRedisSerializer() {
 	 * given {@literal name}. In case of an {@literal empty} or {@literal null} String the default
 	 * {@link JsonTypeInfo.Id#CLASS} will be used.
 	 *
-	 * @param classPropertyTypeName Name of the JSON property holding type information. Can be {@literal null}.
+	 * @param classPropertyTypeName name of the JSON property holding type information. Can be {@literal null}.
 	 * @see ObjectMapper#activateDefaultTypingAsProperty(PolymorphicTypeValidator, DefaultTyping, String)
 	 * @see ObjectMapper#activateDefaultTyping(PolymorphicTypeValidator, DefaultTyping, As)
 	 */
 	public GenericJackson2JsonRedisSerializer(@Nullable String classPropertyTypeName) {
+		this(classPropertyTypeName, JacksonObjectReader.create(), JacksonObjectWriter.create());
+	}
+
+	/**
+	 * Creates {@link GenericJackson2JsonRedisSerializer} and configures {@link ObjectMapper} for default typing using the
+	 * given {@literal name}. In case of an {@literal empty} or {@literal null} String the default
+	 * {@link JsonTypeInfo.Id#CLASS} will be used.
+	 *
+	 * @param classPropertyTypeName name of the JSON property holding type information. Can be {@literal null}.
+	 * @param reader the {@link JacksonObjectReader} function to read objects using {@link ObjectMapper}.
+	 * @param writer the {@link JacksonObjectWriter} function to write objects using {@link ObjectMapper}.
+	 * @see ObjectMapper#activateDefaultTypingAsProperty(PolymorphicTypeValidator, DefaultTyping, String)
+	 * @see ObjectMapper#activateDefaultTyping(PolymorphicTypeValidator, DefaultTyping, As)
+	 * @since 3.0
+	 */
+	public GenericJackson2JsonRedisSerializer(@Nullable String classPropertyTypeName, JacksonObjectReader reader,
+			JacksonObjectWriter writer) {
 
-		this(new ObjectMapper());
+		this(new ObjectMapper(), reader, writer);
 
 		// simply setting {@code mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)} does not help here since we need
 		// the type hint embedded for deserialization using the default typing feature.
@@ -87,9 +110,29 @@ public GenericJackson2JsonRedisSerializer(@Nullable String classPropertyTypeName
 	 * @param mapper must not be {@literal null}.
 	 */
 	public GenericJackson2JsonRedisSerializer(ObjectMapper mapper) {
+		this(mapper, JacksonObjectReader.create(), JacksonObjectWriter.create());
+	}
+
+	/**
+	 * Setting a custom-configured {@link ObjectMapper} is one way to take further control of the JSON serialization
+	 * process. For example, an extended {@link SerializerFactory} can be configured that provides custom serializers for
+	 * specific types.
+	 *
+	 * @param mapper must not be {@literal null}.
+	 * @param reader the {@link JacksonObjectReader} function to read objects using {@link ObjectMapper}.
+	 * @param writer the {@link JacksonObjectWriter} function to write objects using {@link ObjectMapper}.
+	 * @since 3.0
+	 */
+	public GenericJackson2JsonRedisSerializer(ObjectMapper mapper, JacksonObjectReader reader,
+			JacksonObjectWriter writer) {
 
 		Assert.notNull(mapper, "ObjectMapper must not be null");
+		Assert.notNull(reader, "Reader must not be null");
+		Assert.notNull(writer, "Writer must not be null");
+
 		this.mapper = mapper;
+		this.reader = reader;
+		this.writer = writer;
 	}
 
 	/**
@@ -116,8 +159,8 @@ public byte[] serialize(@Nullable Object source) throws SerializationException {
 		}
 
 		try {
-			return mapper.writeValueAsBytes(source);
-		} catch (JsonProcessingException e) {
+			return writer.write(mapper, source);
+		} catch (IOException e) {
 			throw new SerializationException("Could not write JSON: " + e.getMessage(), e);
 		}
 	}
@@ -134,6 +177,7 @@ public Object deserialize(@Nullable byte[] source) throws SerializationException
 	 * @throws SerializationException
 	 */
 	@Nullable
+	@SuppressWarnings("unchecked")
 	public <T> T deserialize(@Nullable byte[] source, Class<T> type) throws SerializationException {
 
 		Assert.notNull(type,
@@ -144,7 +188,7 @@ public <T> T deserialize(@Nullable byte[] source, Class<T> type) throws Serializ
 		}
 
 		try {
-			return mapper.readValue(source, type);
+			return (T) reader.read(mapper, source, mapper.getTypeFactory().constructType(type));
 		} catch (Exception ex) {
 			throw new SerializationException("Could not read JSON: " + ex.getMessage(), ex);
 		}
@@ -172,8 +216,7 @@ private static class NullValueSerializer extends StdSerializer<NullValue> {
 		}
 
 		@Override
-		public void serialize(NullValue value, JsonGenerator jgen, SerializerProvider provider)
-				throws IOException {
+		public void serialize(NullValue value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
 
 			jgen.writeStartObject();
 			jgen.writeStringField(classIdentifier, NullValue.class.getName());
@@ -186,4 +229,5 @@ public void serializeWithType(NullValue value, JsonGenerator gen, SerializerProv
 			serialize(value, gen, serializers);
 		}
 	}
+
 }

src/main/java/org/springframework/data/redis/serializer/Jackson2JsonRedisSerializer.java

@@ -31,10 +31,14 @@
  * <a href="https://github.com/FasterXML/jackson-core">Jackson's</a> and
  * <a href="https://github.com/FasterXML/jackson-databind">Jackson Databind</a> {@link ObjectMapper}.
  * <p>
- * This converter can be used to bind to typed beans, or untyped {@link java.util.HashMap HashMap} instances.
+ * This serializer can be used to bind to typed beans, or untyped {@link java.util.HashMap HashMap} instances.
  * <b>Note:</b>Null objects are serialized as empty arrays and vice versa.
+ * <p>
+ * JSON reading and writing can be customized by configuring {@link JacksonObjectReader} respective
+ * {@link JacksonObjectWriter}.
  *
  * @author Thomas Darimont
+ * @author Mark Paluch
  * @since 1.2
  */
 public class Jackson2JsonRedisSerializer<T> implements RedisSerializer<T> {
@@ -45,6 +49,10 @@ public class Jackson2JsonRedisSerializer<T> implements RedisSerializer<T> {
 
 	private ObjectMapper objectMapper = new ObjectMapper();
 
+	private JacksonObjectReader reader = JacksonObjectReader.create();
+
+	private JacksonObjectWriter writer = JacksonObjectWriter.create();
+
 	/**
 	 * Creates a new {@link Jackson2JsonRedisSerializer} for the given target {@link Class}.
 	 *
@@ -70,7 +78,7 @@ public T deserialize(@Nullable byte[] bytes) throws SerializationException {
 			return null;
 		}
 		try {
-			return (T) this.objectMapper.readValue(bytes, 0, bytes.length, javaType);
+			return (T) this.reader.read(this.objectMapper, bytes, javaType);
 		} catch (Exception ex) {
 			throw new SerializationException("Could not read JSON: " + ex.getMessage(), ex);
 		}
@@ -83,7 +91,7 @@ public byte[] serialize(@Nullable Object t) throws SerializationException {
 			return SerializationUtils.EMPTY_ARRAY;
 		}
 		try {
-			return this.objectMapper.writeValueAsBytes(t);
+			return this.writer.write(this.objectMapper, t);
 		} catch (Exception ex) {
 			throw new SerializationException("Could not write JSON: " + ex.getMessage(), ex);
 		}
@@ -104,6 +112,26 @@ public void setObjectMapper(ObjectMapper objectMapper) {
 		this.objectMapper = objectMapper;
 	}
 
+	/**
+	 * Sets the {@link JacksonObjectReader} for this serializer. Setting the reader allows customization of the JSON
+	 * deserialization.
+	 *
+	 * @since 3.0
+	 */
+	public void setReader(JacksonObjectReader reader) {
+		this.reader = reader;
+	}
+
+	/**
+	 * Sets the {@link JacksonObjectWriter} for this serializer. Setting the reader allows customization of the JSON
+	 * serialization.
+	 *
+	 * @since 3.0
+	 */
+	public void setWriter(JacksonObjectWriter writer) {
+		this.writer = writer;
+	}
+
 	/**
 	 * Returns the Jackson {@link JavaType} for the specific class.
 	 * <p>

src/main/java/org/springframework/data/redis/serializer/JacksonObjectReader.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.data.redis.serializer;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Defines the contract for Object Mapping readers. Implementations of this interface can deserialize a given byte array
+ * holding JSON to an Object considering the target type.
+ * <p>
+ * Reader functions can customize how the actual JSON is being deserialized by e.g. obtaining a customized
+ * {@link com.fasterxml.jackson.databind.ObjectReader} applying serialization features, date formats, or views.
+ *
+ * @author Mark Paluch
+ * @since 3.0
+ */
+@FunctionalInterface
+public interface JacksonObjectReader {
+
+	/**
+	 * Read an object graph from the given root JSON into a Java object considering the {@link JavaType}.
+	 *
+	 * @param mapper the object mapper to use.
+	 * @param source the JSON to deserialize.
+	 * @param type the Java target type
+	 * @return the deserialized Java object.
+	 * @throws IOException if an I/O error or JSON deserialization error occurs.
+	 */
+	Object read(ObjectMapper mapper, byte[] source, JavaType type) throws IOException;
+
+	/**
+	 * Create a default {@link JacksonObjectReader} delegating to {@link ObjectMapper#readValue(InputStream, JavaType)}.
+	 *
+	 * @return the default {@link JacksonObjectReader}.
+	 */
+	static JacksonObjectReader create() {
+		return (mapper, source, type) -> mapper.readValue(source, 0, source.length, type);
+	}
+
+}

src/main/java/org/springframework/data/redis/serializer/JacksonObjectWriter.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 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.data.redis.serializer;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Defines the contract for Object Mapping writers. Implementations of this interface can serialize a given Object to a
+ * {@code byte[]} containing JSON.
+ * <p>
+ * Writer functions can customize how the actual JSON is being written by e.g. obtaining a customized
+ * {@link com.fasterxml.jackson.databind.ObjectWriter} applying serialization features, date formats, or views.
+ *
+ * @author Mark Paluch
+ * @since 3.0
+ */
+@FunctionalInterface
+public interface JacksonObjectWriter {
+
+	/**
+	 * Write the object graph with the given root {@code source} as byte array.
+	 *
+	 * @param mapper the object mapper to use.
+	 * @param source the root of the object graph to marshal.
+	 * @return a byte array containing the serialized object graph.
+	 * @throws IOException if an I/O error or JSON serialization error occurs.
+	 */
+	byte[] write(ObjectMapper mapper, Object source) throws IOException;
+
+	/**
+	 * Create a default {@link JacksonObjectWriter} delegating to {@link ObjectMapper#writeValueAsBytes(Object)}.
+	 *
+	 * @return the default {@link JacksonObjectWriter}.
+	 */
+	static JacksonObjectWriter create() {
+		return ObjectMapper::writeValueAsBytes;
+	}
+
+}

src/test/java/org/springframework/data/redis/serializer/GenericJackson2JsonRedisSerializerUnitTests.java

@@ -26,11 +26,13 @@
 
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
+
 import org.springframework.beans.BeanUtils;
 import org.springframework.cache.support.NullValue;
 
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
+import com.fasterxml.jackson.annotation.JsonView;
 import com.fasterxml.jackson.core.JsonGenerationException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonMappingException;
@@ -162,6 +164,24 @@ void deserializeShouldBeAbleToRestoreFinalObjectAfterSerialization() {
 		assertThat(serializer.deserialize(serializer.serialize(source))).isEqualTo(source);
 	}
 
+	@Test // GH-2322
+	void shouldConsiderWriter() {
+
+		User user = new User();
+		user.email = "walter@heisenberg.com";
+		user.id = 42;
+		user.name = "Walter White";
+
+		GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer((String) null,
+				JacksonObjectReader.create(), (mapper, source) -> {
+					return mapper.writerWithView(Views.Basic.class).writeValueAsBytes(source);
+				});
+
+		byte[] result = serializer.serialize(user);
+
+		assertThat(new String(result)).contains("id").contains("name").doesNotContain("email");
+	}
+
 	private static void serializeAndDeserializeNullValue(GenericJackson2JsonRedisSerializer serializer) {
 
 		NullValue nv = BeanUtils.instantiateClass(NullValue.class);
@@ -252,4 +272,18 @@ public boolean equals(Object obj) {
 		}
 	}
 
+	public class User {
+		@JsonView(Views.Basic.class) public int id;
+		@JsonView(Views.Basic.class) public String name;
+		@JsonView(Views.Detailed.class) public String email;
+		@JsonView(Views.Detailed.class) public String mobile;
+	}
+
+	public class Views {
+		interface Basic {}
+
+		interface Detailed {}
+
+	}
+
 }