feat: add custom NullValueSerializer initializer

Author: AnneMayor

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

@@ -134,6 +134,36 @@ public GenericJackson2JsonRedisSerializer(@Nullable String classPropertyTypeName
 		this.mapper.setDefaultTyping(typer);
 	}
 
+	/**
+	 * Creates {@link GenericJackson2JsonRedisSerializer} initialized with an {@link ObjectMapper} configured for default
+	 * typing using the given {@link String name} along with the given, required {@link JacksonObjectReader} and
+	 * {@link JacksonObjectWriter} used to read/write {@link Object Objects} de/serialized as JSON,
+	 * optionally customized {@link NullValueSerializer}.
+	 * <p>
+	 * In case {@link String name} is {@literal empty} or {@literal null}, then {@link JsonTypeInfo.Id#CLASS} will be
+	 * used.
+	 * <p>
+	 * In case {@link StdSerializer} is {@literal null}, then a default {@link NullValueSerializer} will be registered.
+	 *
+	 * @param classPropertyTypeName {@link String name} of the JSON property holding type information; can be
+	 *          {@literal null}.
+	 * @param reader {@link JacksonObjectReader} function to read objects using {@link ObjectMapper}.
+	 * @param writer {@link JacksonObjectWriter} function to write objects using {@link ObjectMapper}.
+	 * @param nullValueSerializer {@link StdSerializer} to serialize {@link NullValue} instances.
+	 * @see ObjectMapper#activateDefaultTypingAsProperty(PolymorphicTypeValidator, DefaultTyping, String)
+	 * @see ObjectMapper#activateDefaultTyping(PolymorphicTypeValidator, DefaultTyping, As)
+	 * @since 3.3
+	 */
+	public GenericJackson2JsonRedisSerializer(@Nullable String classPropertyTypeName, JacksonObjectReader reader,
+			JacksonObjectWriter writer, @Nullable StdSerializer<NullValue> nullValueSerializer) {
+
+		this(classPropertyTypeName, reader, writer);
+
+		if (nullValueSerializer != null) {
+			registerCustomNullValueSerializer(nullValueSerializer);
+		}
+	}
+
 	/**
 	 * 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
@@ -231,6 +261,10 @@ public static void registerNullValueSerializer(ObjectMapper objectMapper, @Nulla
 		objectMapper.registerModule(new SimpleModule().addSerializer(new NullValueSerializer(classPropertyTypeName)));
 	}
 
+	private void registerCustomNullValueSerializer(StdSerializer<NullValue> nullValueSerializer) {
+		this.mapper.registerModule(new SimpleModule().addSerializer(nullValueSerializer));
+	}
+
 	/**
 	 * Gets the configured {@link ObjectMapper} used internally by this {@link GenericJackson2JsonRedisSerializer} to
 	 * de/serialize {@link Object objects} as {@literal JSON}.

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

@@ -40,6 +40,10 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
@@ -420,7 +424,7 @@ void deserializesJavaTimeFrimBytes() {
 	}
 
 	@Test // GH-2601
-	public void internalObjectMapperCustomization() {
+	void internalObjectMapperCustomization() {
 
 		GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();
 
@@ -438,14 +442,49 @@ public void internalObjectMapperCustomization() {
 	}
 
 	@Test // GH-2601
-	public void configureWithNullConsumerThrowsIllegalArgumentException() {
+	void configureWithNullConsumerThrowsIllegalArgumentException() {
 
 		assertThatIllegalArgumentException()
 			.isThrownBy(() -> new GenericJackson2JsonRedisSerializer().configure(null))
 			.withMessage("Consumer used to configure and customize ObjectMapper must not be null")
 			.withNoCause();
 	}
 
+	@Test
+	void customSerializeAndDeserializeNullValue() {
+
+		GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer(
+				null,
+				(mapper, source, type) -> {
+					if (type.getRawClass() == User.class) {
+						return mapper.readerWithView(Views.Basic.class).forType(type).readValue(source);
+					}
+					return mapper.readValue(source, type);
+				}, JacksonObjectWriter.create(), new StdSerializer<>(NullValue.class) {
+			@Override
+			public void serialize(NullValue nullValue,
+								  JsonGenerator jsonGenerator,
+								  SerializerProvider serializerProvider) throws IOException {
+				jsonGenerator.writeNull();
+			}
+
+			@Override
+			public void serializeWithType(NullValue value, JsonGenerator jsonGenerator, SerializerProvider serializers,
+			                              TypeSerializer typeSerializer) throws IOException {
+
+				serialize(value, jsonGenerator, serializers);
+			}
+		});
+
+		NullValue nv = BeanUtils.instantiateClass(NullValue.class);
+
+		byte[] serializedValue = serializer.serialize(nv);
+		assertThat(serializedValue).isNotNull();
+
+		Object deserializedValue = serializer.deserialize(serializedValue);
+		assertThat(deserializedValue).isNull();
+	}
+
 	private static void serializeAndDeserializeNullValue(GenericJackson2JsonRedisSerializer serializer) {
 
 		NullValue nv = BeanUtils.instantiateClass(NullValue.class);