Polishing contribution

Closes gh-28401

Author: rstoyanchev

spring-web/src/main/java/org/springframework/http/codec/json/AbstractJackson2Decoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2021 the original author or authors.
+ * Copyright 2002-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.
@@ -33,6 +33,7 @@
 import org.reactivestreams.Publisher;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import reactor.util.context.ContextView;
 
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ResolvableType;
@@ -46,7 +47,6 @@
 import org.springframework.http.codec.HttpMessageDecoder;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.http.server.reactive.ServerHttpResponse;
-import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.MimeType;
@@ -139,22 +139,26 @@ public Flux<Object> decode(Publisher<DataBuffer> input, ResolvableType elementTy
 		Flux<TokenBuffer> tokens = Jackson2Tokenizer.tokenize(processed, mapper.getFactory(), mapper,
 				true, forceUseOfBigDecimal, getMaxInMemorySize());
 
-		ObjectReader objectReader = getObjectReader(mapper, elementType, hints);
-
-		return customizeReaderFromStream(objectReader, mimeType, elementType, hints)
-				.flatMapMany(reader -> tokens.handle((tokenBuffer, sink) -> {
-						try {
-							Object value = reader.readValue(tokenBuffer.asParser(mapper));
-							logValue(value, hints);
-							if (value != null) {
-								sink.next(value);
-							}
-						}
-						catch (IOException ex) {
-							sink.error(processException(ex));
-						}
-					})
-				);
+		return Flux.deferContextual(contextView -> {
+
+			Map<String, Object> hintsToUse = contextView.isEmpty() ? hints :
+					Hints.merge(hints, ContextView.class.getName(), contextView);
+
+			ObjectReader reader = createObjectReader(mapper, elementType, hintsToUse);
+
+			return tokens.handle((tokenBuffer, sink) -> {
+				try {
+					Object value = reader.readValue(tokenBuffer.asParser(mapper));
+					logValue(value, hints);
+					if (value != null) {
+						sink.next(value);
+					}
+				}
+				catch (IOException ex) {
+					sink.error(processException(ex));
+				}
+			});
+		});
 	}
 
 	/**
@@ -169,45 +173,36 @@ public Flux<Object> decode(Publisher<DataBuffer> input, ResolvableType elementTy
 	 * @since 5.1.14
 	 */
 	protected Flux<DataBuffer> processInput(Publisher<DataBuffer> input, ResolvableType elementType,
-				@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
+			@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
 
 		return Flux.from(input);
 	}
 
 	@Override
 	public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType,
 			@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {
-		return DataBufferUtils.join(input, this.maxInMemorySize)
-				.flatMap(dataBuffer -> {
-							try {
-								ObjectReader objectReader = getObjectReader(elementType, mimeType, hints);
-								return customizeReaderFromStream(objectReader, mimeType, elementType, hints)
-										.flatMap(reader -> {
-											try {
-												return Mono.justOrEmpty(decode(dataBuffer, reader, hints));
-											}
-											catch (DecodingException ex) {
-												return Mono.error(ex);
-											}
-										});
-							}
-							catch (IllegalStateException ex) {
-								return Mono.error(ex);
-							}
-						});
+
+		return Mono.deferContextual(contextView -> {
+
+			Map<String, Object> hintsToUse = contextView.isEmpty() ? hints :
+					Hints.merge(hints, ContextView.class.getName(), contextView);
+
+			return DataBufferUtils.join(input, this.maxInMemorySize).flatMap(dataBuffer ->
+					Mono.justOrEmpty(decode(dataBuffer, elementType, mimeType, hintsToUse)));
+		});
 	}
 
 	@Override
 	public Object decode(DataBuffer dataBuffer, ResolvableType targetType,
 			@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) throws DecodingException {
-		ObjectReader reader = getObjectReader(targetType, mimeType, hints);
-		reader = customizeReader(reader, mimeType, targetType, hints);
-		return decode(dataBuffer, reader, hints);
-	}
 
-	private Object decode(@NonNull DataBuffer dataBuffer, @NonNull ObjectReader objectReader,
-			@Nullable Map<String, Object> hints) throws DecodingException {
+		ObjectMapper mapper = selectObjectMapper(targetType, mimeType);
+		if (mapper == null) {
+			throw new IllegalStateException("No ObjectMapper for " + targetType);
+		}
+
 		try {
+			ObjectReader objectReader = createObjectReader(mapper, targetType, hints);
 			Object value = objectReader.readValue(dataBuffer.asInputStream());
 			logValue(value, hints);
 			return value;
@@ -220,16 +215,7 @@ private Object decode(@NonNull DataBuffer dataBuffer, @NonNull ObjectReader obje
 		}
 	}
 
-	private ObjectReader getObjectReader(ResolvableType targetType, @Nullable MimeType mimeType,
-			@Nullable Map<String, Object> hints) {
-		ObjectMapper mapper = selectObjectMapper(targetType, mimeType);
-		if (mapper == null) {
-			throw new IllegalStateException("No ObjectMapper for " + targetType);
-		}
-		return getObjectReader(mapper, targetType, hints);
-	}
-
-	private ObjectReader getObjectReader(
+	private ObjectReader createObjectReader(
 			ObjectMapper mapper, ResolvableType elementType, @Nullable Map<String, Object> hints) {
 
 		Assert.notNull(elementType, "'elementType' must not be null");
@@ -239,34 +225,28 @@ private ObjectReader getObjectReader(
 		}
 		JavaType javaType = getJavaType(elementType.getType(), contextClass);
 		Class<?> jsonView = (hints != null ? (Class<?>) hints.get(Jackson2CodecSupport.JSON_VIEW_HINT) : null);
-		return jsonView != null ?
+
+		ObjectReader objectReader = (jsonView != null ?
 				mapper.readerWithView(jsonView).forType(javaType) :
-				mapper.readerFor(javaType);
-	}
+				mapper.readerFor(javaType));
 
-	/**
-	 * Provides the ability for subclasses to customize the {@link ObjectReader} for deserialization from a stream.
-	 * @param reader the {@link ObjectReader} available for customization
-	 * @param mimeType the MIME type associated with the input stream
-	 * @param elementType the expected type of elements in the output stream
-	 * @param hints additional information about how to do encode
-	 * @return the customized {@link ObjectReader}
-	 */
-	protected Mono<ObjectReader> customizeReaderFromStream(@NonNull ObjectReader reader, @Nullable MimeType mimeType,
-			ResolvableType elementType, @Nullable Map<String, Object> hints) {
-		return Mono.just(customizeReader(reader, mimeType, elementType, hints));
+		return customizeReader(objectReader, elementType, hints);
 	}
 
 	/**
-	 * Provides the ability for subclasses to customize the {@link ObjectReader} for deserialization.
-	 * @param reader the {@link ObjectReader} available for customization
-	 * @param mimeType the MIME type associated with the input stream
-	 * @param elementType the expected type of elements in the output stream
-	 * @param hints additional information about how to do encode
-	 * @return the customized {@link ObjectReader}
+	 * Subclasses can use this method to customize {@link ObjectReader} used
+	 * for reading values.
+	 * @param reader the reader instance to customize
+	 * @param elementType the target type of element values to read to
+	 * @param hints a map with serialization hints;
+	 * the Reactor Context, when available, may be accessed under the key
+	 * {@code ContextView.class.getName()}
+	 * @return the customized {@code ObjectReader} to use
+	 * @since 6.0
 	 */
-	protected ObjectReader customizeReader(@NonNull ObjectReader reader, @Nullable MimeType mimeType,
-			ResolvableType elementType, @Nullable Map<String, Object> hints) {
+	protected ObjectReader customizeReader(
+			ObjectReader reader, ResolvableType elementType, @Nullable Map<String, Object> hints) {
+
 		return reader;
 	}
 
@@ -312,10 +292,6 @@ public List<MimeType> getDecodableMimeTypes() {
 		return getMimeTypes();
 	}
 
-	@Override
-	public List<MimeType> getDecodableMimeTypes(ResolvableType targetType) {
-		return getMimeTypes(targetType);
-	}
 
 	// Jackson2CodecSupport