DispatcherHandler maps errors to ResponseStatusException

The DispatcherHandler now has an errorMapper property that is a
function for transforming errors. By default this property is set to an
instance of DispatcherHandlerExceptionMapper which wraps "standard"
framework exceptions and @ResponseStatus-annotated exceptions as
ResponseStatusException.

This makes it easy to handle the exceptions downstream uniformly.

spring-web-reactive/src/main/java/org/springframework/web/reactive/DispatcherHandler.java

@@ -19,11 +19,14 @@ package org.springframework.web.reactive;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
 import reactor.Publishers;
+import reactor.fn.BiConsumer;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactoryUtils;
@@ -63,12 +66,30 @@ public class DispatcherHandler implements HttpHandler, ApplicationContextAware {
 
 	private List<HandlerResultHandler> resultHandlers;
 
+	private Function<Throwable, Throwable> errorMapper = new DispatcherHandlerExceptionMapper();
+
 
 	@Override
 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 		initStrategies(applicationContext);
 	}
 
+	/**
+	 * Configure a function to map error signals from the {@code DispatcherHandler}.
+	 * <p>By default this is set to {@link DispatcherHandlerExceptionMapper}.
+	 * @param errorMapper the function
+	 */
+	public void setErrorMapper(Function<Throwable, Throwable> errorMapper) {
+		this.errorMapper = errorMapper;
+	}
+
+	/**
+	 * Return the configured function for mapping exceptions.
+	 */
+	public Function<Throwable, Throwable> getErrorMapper() {
+		return this.errorMapper;
+	}
+
 	protected void initStrategies(ApplicationContext context) {
 
 		Map<String, HandlerMapping> mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
@@ -107,10 +128,12 @@ public class DispatcherHandler implements HttpHandler, ApplicationContextAware {
 			return handlerAdapter.handle(request, response, handler);
 		});
 
-		return Publishers.concatMap(resultPublisher, result -> {
+		Publisher<Void> completionPublisher = Publishers.concatMap(resultPublisher, result -> {
 			HandlerResultHandler handler = getResultHandler(result);
 			return handler.handleResult(request, response, result);
 		});
+
+		return mapError(completionPublisher, this.errorMapper);
 	}
 
 	protected HandlerAdapter getHandlerAdapter(Object handler) {
@@ -139,6 +162,15 @@ public class DispatcherHandler implements HttpHandler, ApplicationContextAware {
 		});
 	}
 
+	private static <E> Publisher<E> mapError(Publisher<E> source, Function<Throwable, Throwable> function) {
+		return Publishers.lift(source, null, new BiConsumer<Throwable, Subscriber<? super E>>() {
+			@Override
+			public void accept(Throwable throwable, Subscriber<? super E> subscriber) {
+				subscriber.onError(function.apply(throwable));
+			}
+		}, null);
+	}
+
 	private static class NotFoundHandlerMapping implements HandlerMapping {
 
 		@Override

spring-web-reactive/src/main/java/org/springframework/web/reactive/DispatcherHandlerExceptionMapper.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2002-2015 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.web.reactive;
+
+import java.util.function.Function;
+
+import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.ResponseStatusException;
+import org.springframework.web.HttpMediaTypeNotAcceptableException;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+/**
+ * Map "standard" framework exceptions and
+ * {@link ResponseStatus @ResponseStatus}-annotated exceptions to a
+ * {@link ResponseStatusException}.
+ *
+ * @author Rossen Stoyanchev
+ */
+public class DispatcherHandlerExceptionMapper implements Function<Throwable, Throwable> {
+
+
+	@Override
+	public Throwable apply(Throwable ex) {
+		if (ex instanceof HandlerNotFoundException) {
+			ex = new ResponseStatusException(HttpStatus.NOT_FOUND, ex);
+		}
+		else if (ex instanceof HttpMediaTypeNotAcceptableException) {
+			ex = new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, ex);
+		}
+		else {
+			ResponseStatus status = findStatus(ex);
+			if (status != null) {
+				ex = new ResponseStatusException(status.code(), ex);
+			}
+		}
+		return ex;
+	}
+
+	private ResponseStatus findStatus(Throwable ex) {
+		Class<? extends Throwable> type = ex.getClass();
+		ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(type, ResponseStatus.class);
+		if (status != null) {
+			return status;
+		}
+		else if (ex.getCause() != null) {
+			return findStatus(ex.getCause());
+		}
+		return null;
+	}
+
+}