Refine encoding/decoding exception handling

Starting with removing a package cycle on the use of
ResponseStatusException in the codec package, this commit generally
refines codec exception handling.

The new [Encoding|Decoding]Exception mirror the existing
HttpMessageNot[Readable|Writable]Exception and are used similarly
especially to differentiate betwen 400 and 500 errors when parsing
server request body content.

The commit also aligns some of the exception handling of JSON and XML
on the WebFlux side with that on the Spring MVC side.

Issue: SPR-15516

Author: rstoyanchev

spring-core/src/main/java/org/springframework/core/codec/CodecException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2017 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.
@@ -19,18 +19,29 @@
 import org.springframework.core.NestedRuntimeException;
 
 /**
- * Codec related exception, usually used as a wrapper for a cause exception.
+ * General error that indicates a problem while encoding and decoding to and
+ * from an Object stream.
  *
  * @author Sebastien Deleuze
+ * @author Rossen Stoyanchev
  * @since 5.0
  */
 @SuppressWarnings("serial")
 public class CodecException extends NestedRuntimeException {
 
+	/**
+	 * Create a new CodecException.
+	 * @param msg the detail message
+	 */
 	public CodecException(String msg) {
 		super(msg);
 	}
 
+	/**
+	 * Create a new CodecException.
+	 * @param msg the detail message
+	 * @param cause root cause for the exception, if any
+	 */
 	public CodecException(String msg, Throwable cause) {
 		super(msg, cause);
 	}

spring-core/src/main/java/org/springframework/core/codec/DecodingException.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2017 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
+ *
+ *      http://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.core.codec;
+
+/**
+ * Indicates an issue with decoding the input stream with the focus on indicating
+ * a content issue such as a parse failure. As opposed to a more general I/O
+ * errors, illegal state, or a {@link CodecException} such as a configuration
+ * issue that a {@link Decoder} may choose to raise.
+ *
+ * <p>For example in a web application, a server side {@code DecodingException}
+ * would translate to a response with a 400 (bad input) status while
+ * {@code CodecException} would translate to 500 (server error) status.
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0
+ * @see Decoder
+ */
+@SuppressWarnings("serial")
+public class DecodingException extends CodecException {
+
+	/**
+	 * Create a new DecodingException.
+	 * @param msg the detail message
+	 */
+	public DecodingException(String msg) {
+		super(msg);
+	}
+
+	/**
+	 * Create a new DecodingException.
+	 * @param msg the detail message
+	 * @param cause root cause for the exception, if any
+	 */
+	public DecodingException(String msg, Throwable cause) {
+		super(msg, cause);
+	}
+
+}

spring-core/src/main/java/org/springframework/core/codec/InternalCodecException.java renamed to spring-core/src/main/java/org/springframework/core/codec/EncodingException.java

@@ -13,24 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.core.codec;
 
 /**
- * Codec exception suitable for internal errors, like those not related to invalid data. It can be used to make sure
- * such error will produce a 5xx status code and not a 4xx one when reading HTTP messages for example.
+ * Indicates an issue with encoding the input Object stream with a focus on
+ * indicating the Objects cannot be encoded. As opposed to a more general
+ * {@link CodecException} such as a configuration issue that an {@link Encoder}
+ * may also choose to raise.
  *
- * @author Sebastien Deleuze
+ * @author Rossen Stoyanchev
  * @since 5.0
+ * @see Encoder
  */
 @SuppressWarnings("serial")
-public class InternalCodecException extends CodecException {
+public class EncodingException extends CodecException {
 
-	public InternalCodecException(String msg) {
+	/**
+	 * Create a new EncodingException.
+	 * @param msg the detail message
+	 */
+	public EncodingException(String msg) {
 		super(msg);
 	}
 
-	public InternalCodecException(String msg, Throwable cause) {
+	/**
+	 * Create a new EncodingException.
+	 * @param msg the detail message
+	 * @param cause root cause for the exception, if any
+	 */
+	public EncodingException(String msg, Throwable cause) {
 		super(msg, cause);
 	}
 

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

@@ -21,9 +21,6 @@
 import java.util.List;
 import java.util.Map;
 
-import org.springframework.core.codec.InternalCodecException;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -88,36 +85,22 @@ public Flux<T> read(ResolvableType elementType, ReactiveHttpInputMessage message
 			Map<String, Object> hints) {
 
 		MediaType contentType = getContentType(message);
-		return this.decoder
-				.decode(message.getBody(), elementType, contentType, hints)
-				.onErrorMap(this::mapError);
+		return this.decoder.decode(message.getBody(), elementType, contentType, hints);
 	}
 
 	@Override
 	public Mono<T> readMono(ResolvableType elementType, ReactiveHttpInputMessage message,
 			Map<String, Object> hints) {
 
 		MediaType contentType = getContentType(message);
-		return this.decoder
-				.decodeToMono(message.getBody(), elementType, contentType, hints)
-				.onErrorMap(this::mapError);
+		return this.decoder.decodeToMono(message.getBody(), elementType, contentType, hints);
 	}
 
 	private MediaType getContentType(HttpMessage inputMessage) {
 		MediaType contentType = inputMessage.getHeaders().getContentType();
 		return (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM);
 	}
 
-	private Throwable mapError(Throwable ex) {
-		if (ex instanceof ResponseStatusException) {
-			return ex;
-		}
-		else if (ex instanceof InternalCodecException) {
-			return new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to decode HTTP message", ex);
-		}
-		return new ResponseStatusException(HttpStatus.BAD_REQUEST, "Failed to decode HTTP message", ex);
-	}
-
 
 	// Server-side only...
 

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

@@ -22,14 +22,13 @@
 import java.util.Map;
 
 import org.reactivestreams.Publisher;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.server.ResponseStatusException;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.Encoder;
 import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferFactory;
 import org.springframework.http.MediaType;
 import org.springframework.http.ReactiveHttpOutputMessage;
 import org.springframework.http.server.reactive.ServerHttpRequest;
@@ -97,10 +96,9 @@ public Mono<Void> write(Publisher<? extends T> inputStream, ResolvableType eleme
 			Map<String, Object> hints) {
 
 		MediaType contentType = updateContentType(message, mediaType);
+		DataBufferFactory factory = message.bufferFactory();
 
-		Flux<DataBuffer> body = this.encoder
-				.encode(inputStream, message.bufferFactory(), elementType, contentType, hints)
-				.onErrorMap(this::mapError);
+		Flux<DataBuffer> body = this.encoder.encode(inputStream, factory, elementType, contentType, hints);
 
 		return isStreamingMediaType(contentType) ?
 				message.writeAndFlushWith(body.map(Flux::just)) :
@@ -139,13 +137,6 @@ private boolean isStreamingMediaType(MediaType contentType) {
 						.anyMatch(contentType::isCompatibleWith);
 	}
 
-	private Throwable mapError(Throwable ex) {
-		if (ex instanceof ResponseStatusException) {
-			return ex;
-		}
-		return new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Failed to encode HTTP message", ex);
-	}
-
 
 	// Server side only...
 

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

@@ -21,6 +21,7 @@
 import java.util.List;
 import java.util.Map;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectReader;
@@ -32,10 +33,10 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.CodecException;
+import org.springframework.core.codec.DecodingException;
 import org.springframework.core.io.buffer.DataBuffer;
 import org.springframework.core.io.buffer.DataBufferUtils;
 import org.springframework.http.codec.HttpMessageDecoder;
-import org.springframework.core.codec.InternalCodecException;
 import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.http.server.reactive.ServerHttpResponse;
@@ -116,10 +117,13 @@ private Flux<Object> decodeInternal(JsonObjectDecoder objectDecoder, Publisher<D
 						return value;
 					}
 					catch (InvalidDefinitionException ex) {
-						throw new InternalCodecException("Error while reading the data", ex);
+						throw new CodecException("Type definition error: " + ex.getMessage(), ex);
+					}
+					catch (JsonProcessingException ex) {
+						throw new DecodingException("JSON parse error: " + ex.getMessage(), ex);
 					}
 					catch (IOException ex) {
-						throw new CodecException("Error while reading the data", ex);
+						throw new CodecException("I/O error while reading: " + ex.getMessage(), ex);
 					}
 				});
 	}

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

@@ -24,6 +24,7 @@
 import java.util.List;
 import java.util.Map;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.PrettyPrinter;
 import com.fasterxml.jackson.core.util.DefaultIndenter;
 import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
@@ -39,6 +40,7 @@
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.CodecException;
+import org.springframework.core.codec.EncodingException;
 import org.springframework.core.io.buffer.DataBuffer;
 import org.springframework.core.io.buffer.DataBufferFactory;
 import org.springframework.http.MediaType;
@@ -164,8 +166,11 @@ private DataBuffer encodeValue(Object value, MimeType mimeType, DataBufferFactor
 		try {
 			writer.writeValue(outputStream, value);
 		}
+		catch (JsonProcessingException ex) {
+			throw new EncodingException("JSON encoding error: " + ex.getMessage(), ex);
+		}
 		catch (IOException ex) {
-			throw new CodecException("Error while writing the data", ex);
+			throw new CodecException("I/O error while writing: " + ex.getMessage(), ex);
 		}
 
 		return buffer;

spring-web/src/main/java/org/springframework/http/codec/xml/Jaxb2XmlDecoder.java

@@ -37,7 +37,7 @@
 
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.AbstractDecoder;
-import org.springframework.core.codec.CodecException;
+import org.springframework.core.codec.DecodingException;
 import org.springframework.core.io.buffer.DataBuffer;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.MimeType;
@@ -216,7 +216,7 @@ private Object unmarshal(List<XMLEvent> events, Class<?> outputClass) {
 			}
 		}
 		catch (JAXBException ex) {
-			throw new CodecException(ex.getMessage(), ex);
+			throw new DecodingException(ex.getMessage(), ex);
 		}
 	}
 

spring-web/src/main/java/org/springframework/http/codec/xml/Jaxb2XmlEncoder.java

@@ -21,13 +21,16 @@
 import java.util.Map;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.Marshaller;
+import javax.xml.bind.UnmarshalException;
 import javax.xml.bind.annotation.XmlRootElement;
 import javax.xml.bind.annotation.XmlType;
 
 import reactor.core.publisher.Flux;
 
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.AbstractSingleValueEncoder;
+import org.springframework.core.codec.CodecException;
+import org.springframework.core.codec.EncodingException;
 import org.springframework.core.io.buffer.DataBuffer;
 import org.springframework.core.io.buffer.DataBufferFactory;
 import org.springframework.util.ClassUtils;
@@ -73,13 +76,16 @@ protected Flux<DataBuffer> encode(Object value, DataBufferFactory dataBufferFact
 			OutputStream outputStream = buffer.asOutputStream();
 			Class<?> clazz = ClassUtils.getUserClass(value);
 			Marshaller marshaller = jaxbContexts.createMarshaller(clazz);
-			marshaller
-					.setProperty(Marshaller.JAXB_ENCODING, StandardCharsets.UTF_8.name());
+			marshaller.setProperty(Marshaller.JAXB_ENCODING, StandardCharsets.UTF_8.name());
 			marshaller.marshal(value, outputStream);
 			return Flux.just(buffer);
 		}
+		catch (UnmarshalException ex) {
+			return Flux.error(new EncodingException(
+					"Could not unmarshal to [" + value.getClass() + "]: " + ex.getMessage(), ex));
+		}
 		catch (JAXBException ex) {
-			return Flux.error(ex);
+			return Flux.error(new CodecException("Could not instantiate JAXBContext: " + ex.getMessage(), ex));
 		}
 	}