Split HttpMessageConverter into ~Reader and ~Writer

Author: rstoyanchev

spring-web-reactive/src/main/java/org/springframework/web/reactive/config/ViewResolverRegistry.java

@@ -25,6 +25,7 @@
 import org.springframework.core.Ordered;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
+import org.springframework.web.reactive.result.view.HttpMessageWriterView;
 import org.springframework.web.reactive.result.view.UrlBasedViewResolver;
 import org.springframework.web.reactive.result.view.View;
 import org.springframework.web.reactive.result.view.ViewResolver;
@@ -97,9 +98,9 @@ public void viewResolver(ViewResolver viewResolver) {
 	/**
 	 * Set default views associated with any view name and selected based on the
 	 * best match for the requested content type.
-	 * <p>Use {@link org.springframework.web.reactive.result.view.HttpMessageConverterView
-	 * HttpMessageConverterView} to adapt and use any existing
-	 * {@code HttpMessageConverter} (e.g. JSON, XML) as a {@code View}.
+	 * <p>Use {@link HttpMessageWriterView
+	 * HttpMessageWriterView} to adapt and use any existing
+	 * {@code HttpMessageWriter} (e.g. JSON, XML) as a {@code View}.
 	 */
 	public void defaultViews(View... defaultViews) {
 		this.defaultViews.addAll(Arrays.asList(defaultViews));

spring-web-reactive/src/main/java/org/springframework/web/reactive/config/WebReactiveConfiguration.java

@@ -28,8 +28,8 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.codec.ByteBufferDecoder;
 import org.springframework.core.codec.ByteBufferEncoder;
-import org.springframework.core.codec.Decoder;
 import org.springframework.core.codec.Encoder;
+import org.springframework.core.codec.ResourceDecoder;
 import org.springframework.core.codec.StringDecoder;
 import org.springframework.core.codec.StringEncoder;
 import org.springframework.core.convert.converter.Converter;
@@ -45,9 +45,11 @@
 import org.springframework.http.codec.json.JacksonJsonEncoder;
 import org.springframework.http.codec.xml.Jaxb2Decoder;
 import org.springframework.http.codec.xml.Jaxb2Encoder;
-import org.springframework.http.converter.reactive.CodecHttpMessageConverter;
-import org.springframework.http.converter.reactive.HttpMessageConverter;
-import org.springframework.http.converter.reactive.ResourceHttpMessageConverter;
+import org.springframework.http.converter.reactive.DecoderHttpMessageReader;
+import org.springframework.http.converter.reactive.EncoderHttpMessageWriter;
+import org.springframework.http.converter.reactive.HttpMessageReader;
+import org.springframework.http.converter.reactive.HttpMessageWriter;
+import org.springframework.http.converter.reactive.ResourceHttpMessageWriter;
 import org.springframework.util.ClassUtils;
 import org.springframework.validation.Errors;
 import org.springframework.validation.Validator;
@@ -87,7 +89,9 @@ public class WebReactiveConfiguration implements ApplicationContextAware {
 
 	private PathMatchConfigurer pathMatchConfigurer;
 
-	private List<HttpMessageConverter<?>> messageConverters;
+	private List<HttpMessageReader<?>> messageReaders;
+
+	private List<HttpMessageWriter<?>> messageWriters;
 
 	private ApplicationContext applicationContext;
 
@@ -189,7 +193,7 @@ public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
 			adapter.setCustomArgumentResolvers(resolvers);
 		}
 
-		adapter.setMessageConverters(getMessageConverters());
+		adapter.setMessageReaders(getMessageReaders());
 		adapter.setConversionService(mvcConversionService());
 		adapter.setValidator(mvcValidator());
 
@@ -210,65 +214,54 @@ protected void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolver
 	}
 
 	/**
-	 * Main method to access message converters to use for decoding
-	 * controller method arguments and encoding return values.
-	 * <p>Use {@link #configureMessageConverters} to configure the list or
-	 * {@link #extendMessageConverters} to add in addition to the default ones.
+	 * Main method to access message readers to use for decoding
+	 * controller method arguments with.
+	 * <p>Use {@link #configureMessageReaders} to configure the list or
+	 * {@link #extendMessageReaders} to add in addition to the default ones.
 	 */
-	protected final List<HttpMessageConverter<?>> getMessageConverters() {
-		if (this.messageConverters == null) {
-			this.messageConverters = new ArrayList<>();
-			configureMessageConverters(this.messageConverters);
-			if (this.messageConverters.isEmpty()) {
-				addDefaultHttpMessageConverters(this.messageConverters);
+	protected final List<HttpMessageReader<?>> getMessageReaders() {
+		if (this.messageReaders == null) {
+			this.messageReaders = new ArrayList<>();
+			configureMessageReaders(this.messageReaders);
+			if (this.messageReaders.isEmpty()) {
+				addDefaultHttpMessageReaders(this.messageReaders);
 			}
-			extendMessageConverters(this.messageConverters);
+			extendMessageReaders(this.messageReaders);
 		}
-		return this.messageConverters;
+		return this.messageReaders;
 	}
 
 	/**
-	 * Override to configure the message converters to use for decoding
-	 * controller method arguments and encoding return values.
-	 * <p>If no converters are specified, default will be added via
-	 * {@link #addDefaultHttpMessageConverters}.
-	 * @param converters a list to add converters to, initially an empty
+	 * Override to configure the message readers to use for decoding
+	 * controller method arguments.
+	 * <p>If no message readres are specified, default will be added via
+	 * {@link #addDefaultHttpMessageReaders}.
+	 * @param messageReaders a list to add message readers to, initially an empty
 	 */
-	protected void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+	protected void configureMessageReaders(List<HttpMessageReader<?>> messageReaders) {
 	}
 
 	/**
 	 * Adds default converters that sub-classes can call from
-	 * {@link #configureMessageConverters(List)}.
+	 * {@link #configureMessageReaders(List)}.
 	 */
-	protected final void addDefaultHttpMessageConverters(List<HttpMessageConverter<?>> converters) {
-		List<Encoder<?>> sseDataEncoders = new ArrayList<>();
-		converters.add(converter(new ByteBufferEncoder(), new ByteBufferDecoder()));
-		converters.add(converter(new StringEncoder(), new StringDecoder()));
-		converters.add(new ResourceHttpMessageConverter());
+	protected final void addDefaultHttpMessageReaders(List<HttpMessageReader<?>> readers) {
+		readers.add(new DecoderHttpMessageReader<>(new ByteBufferDecoder()));
+		readers.add(new DecoderHttpMessageReader<>(new StringDecoder()));
+		readers.add(new DecoderHttpMessageReader<>(new ResourceDecoder()));
 		if (jaxb2Present) {
-			converters.add(converter(new Jaxb2Encoder(), new Jaxb2Decoder()));
+			readers.add(new DecoderHttpMessageReader<>(new Jaxb2Decoder()));
 		}
 		if (jackson2Present) {
-			JacksonJsonEncoder jacksonEncoder = new JacksonJsonEncoder();
-			JacksonJsonDecoder jacksonDecoder = new JacksonJsonDecoder();
-			converters.add(converter(jacksonEncoder, jacksonDecoder));
-			sseDataEncoders.add(jacksonEncoder);
-		} else {
-
+			readers.add(new DecoderHttpMessageReader<>(new JacksonJsonDecoder()));
 		}
-		converters.add(converter(new SseEventEncoder(sseDataEncoders), null));
-	}
-
-	private static <T> HttpMessageConverter<T> converter(Encoder<T> encoder, Decoder<T> decoder) {
-		return new CodecHttpMessageConverter<>(encoder, decoder);
 	}
 
 	/**
-	 * Override this to modify the list of converters after it has been
+	 * Override this to modify the list of message readers after it has been
 	 * configured, for example to add some in addition to the default ones.
 	 */
-	protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
+	protected void extendMessageReaders(List<HttpMessageReader<?>> messageReaders) {
 	}
 
 	@Bean
@@ -345,16 +338,67 @@ public SimpleResultHandler simpleResultHandler() {
 
 	@Bean
 	public ResponseEntityResultHandler responseEntityResultHandler() {
-		return new ResponseEntityResultHandler(getMessageConverters(), mvcConversionService(),
+		return new ResponseEntityResultHandler(getMessageWriters(), mvcConversionService(),
 				mvcContentTypeResolver());
 	}
 
 	@Bean
 	public ResponseBodyResultHandler responseBodyResultHandler() {
-		return new ResponseBodyResultHandler(getMessageConverters(), mvcConversionService(),
+		return new ResponseBodyResultHandler(getMessageWriters(), mvcConversionService(),
 				mvcContentTypeResolver());
 	}
 
+	/**
+	 * Main method to access message writers to use for encoding return values.
+	 * <p>Use {@link #configureMessageWriters(List)} to configure the list or
+	 * {@link #extendMessageWriters(List)} to add in addition to the default ones.
+	 */
+	protected final List<HttpMessageWriter<?>> getMessageWriters() {
+		if (this.messageWriters == null) {
+			this.messageWriters = new ArrayList<>();
+			configureMessageWriters(this.messageWriters);
+			if (this.messageWriters.isEmpty()) {
+				addDefaultHttpMessageWriters(this.messageWriters);
+			}
+			extendMessageWriters(this.messageWriters);
+		}
+		return this.messageWriters;
+	}
+	/**
+	 * Override to configure the message writers to use for encoding
+	 * return values.
+	 * <p>If no message readers are specified, default will be added via
+	 * {@link #addDefaultHttpMessageWriters}.
+	 * @param messageWriters a list to add message writers to, initially an empty
+	 */
+	protected void configureMessageWriters(List<HttpMessageWriter<?>> messageWriters) {
+	}
+	/**
+	 * Adds default converters that sub-classes can call from
+	 * {@link #configureMessageWriters(List)}.
+	 */
+	protected final void addDefaultHttpMessageWriters(List<HttpMessageWriter<?>> writers) {
+		List<Encoder<?>> sseDataEncoders = new ArrayList<>();
+		writers.add(new EncoderHttpMessageWriter<>(new ByteBufferEncoder()));
+		writers.add(new EncoderHttpMessageWriter<>(new StringEncoder()));
+		writers.add(new ResourceHttpMessageWriter());
+		if (jaxb2Present) {
+			writers.add(new EncoderHttpMessageWriter<>(new Jaxb2Encoder()));
+		}
+		if (jackson2Present) {
+			JacksonJsonEncoder jacksonEncoder = new JacksonJsonEncoder();
+			writers.add(new EncoderHttpMessageWriter<>(jacksonEncoder));
+			sseDataEncoders.add(jacksonEncoder);
+		}
+		writers.add(new EncoderHttpMessageWriter<>(new SseEventEncoder(sseDataEncoders)));
+	}
+	/**
+	 * Override this to modify the list of message writers after it has been
+	 * configured, for example to add some in addition to the default ones.
+	 */
+	protected void extendMessageWriters(List<HttpMessageWriter<?>> messageWriters) {
+	}
+
 	@Bean
 	public ViewResolutionResultHandler viewResolutionResultHandler() {
 		ViewResolverRegistry registry = new ViewResolverRegistry(this.applicationContext);

spring-web-reactive/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractMessageConverterArgumentResolver.java renamed to spring-web-reactive/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractMessageReaderArgumentResolver.java

@@ -30,7 +30,7 @@
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.http.MediaType;
-import org.springframework.http.converter.reactive.HttpMessageConverter;
+import org.springframework.http.converter.reactive.HttpMessageReader;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
@@ -45,7 +45,7 @@
 
 /**
  * Abstract base class for argument resolvers that resolve method arguments
- * by reading the request body with an {@link HttpMessageConverter}.
+ * by reading the request body with an {@link HttpMessageReader}.
  *
  * <p>Applies validation if the method argument is annotated with
  * {@code @javax.validation.Valid} or
@@ -55,14 +55,14 @@
  * @author Rossen Stoyanchev
  * @since 5.0
  */
-public abstract class AbstractMessageConverterArgumentResolver {
+public abstract class AbstractMessageReaderArgumentResolver {
 
 	private static final TypeDescriptor MONO_TYPE = TypeDescriptor.valueOf(Mono.class);
 
 	private static final TypeDescriptor FLUX_TYPE = TypeDescriptor.valueOf(Flux.class);
 
 
-	private final List<HttpMessageConverter<?>> messageConverters;
+	private final List<HttpMessageReader<?>> messageReaders;
 
 	private final ConversionService conversionService;
 
@@ -73,19 +73,19 @@ public abstract class AbstractMessageConverterArgumentResolver {
 
 	/**
 	 * Constructor with message converters and a ConversionService.
-	 * @param converters converters for reading the request body with
+	 * @param messageReaders readers to convert from the request body
 	 * @param service for converting to other reactive types from Flux and Mono
 	 * @param validator validator to validate decoded objects with
 	 */
-	protected AbstractMessageConverterArgumentResolver(List<HttpMessageConverter<?>> converters,
+	protected AbstractMessageReaderArgumentResolver(List<HttpMessageReader<?>> messageReaders,
 			ConversionService service, Validator validator) {
 
-		Assert.notEmpty(converters, "At least one message converter is required.");
+		Assert.notEmpty(messageReaders, "At least one message reader is required.");
 		Assert.notNull(service, "'conversionService' is required.");
-		this.messageConverters = converters;
+		this.messageReaders = messageReaders;
 		this.conversionService = service;
 		this.validator = validator;
-		this.supportedMediaTypes = converters.stream()
+		this.supportedMediaTypes = messageReaders.stream()
 				.flatMap(converter -> converter.getReadableMediaTypes().stream())
 				.collect(Collectors.toList());
 	}
@@ -94,8 +94,8 @@ protected AbstractMessageConverterArgumentResolver(List<HttpMessageConverter<?>>
 	/**
 	 * Return the configured message converters.
 	 */
-	public List<HttpMessageConverter<?>> getMessageConverters() {
-		return this.messageConverters;
+	public List<HttpMessageReader<?>> getMessageReaders() {
+		return this.messageReaders;
 	}
 
 	/**
@@ -124,10 +124,10 @@ protected Mono<Object> readBody(MethodParameter bodyParameter, boolean isBodyReq
 			mediaType = MediaType.APPLICATION_OCTET_STREAM;
 		}
 
-		for (HttpMessageConverter<?> converter : getMessageConverters()) {
-			if (converter.canRead(elementType, mediaType)) {
+		for (HttpMessageReader<?> reader : getMessageReaders()) {
+			if (reader.canRead(elementType, mediaType)) {
 				if (convertFromFlux) {
-					Flux<?> flux = converter.read(elementType, request)
+					Flux<?> flux = reader.read(elementType, request)
 							.onErrorResumeWith(ex -> Flux.error(getReadError(ex, bodyParameter)));
 					if (checkRequired(bodyParameter, isBodyRequired)) {
 						flux = flux.switchIfEmpty(Flux.error(getRequiredBodyError(bodyParameter)));
@@ -138,7 +138,7 @@ protected Mono<Object> readBody(MethodParameter bodyParameter, boolean isBodyReq
 					return Mono.just(getConversionService().convert(flux, FLUX_TYPE, typeDescriptor));
 				}
 				else {
-					Mono<?> mono = converter.readMono(elementType, request)
+					Mono<?> mono = reader.readMono(elementType, request)
 							.otherwise(ex -> Mono.error(getReadError(ex, bodyParameter)));
 					if (checkRequired(bodyParameter, isBodyRequired)) {
 						mono = mono.otherwiseIfEmpty(Mono.error(getRequiredBodyError(bodyParameter)));