springboot webflux 异常处理（WebExceptionHandler）

亦凉 2023-02-19 12:28 27阅读 0赞

--------------------

### springboot webflux 异常处理（WebExceptionHandler） ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类及接口**

**WebExceptionHandler**

public interface WebExceptionHandler {
        Mono<Void> handle(ServerWebExchange var1, Throwable var2);
    }

**ErrorWebExceptionHandler**

@FunctionalInterface
    public interface ErrorWebExceptionHandler extends WebExceptionHandler {
    }

**AbstractErrorWebExceptionHandler**

public abstract class AbstractErrorWebExceptionHandler implements ErrorWebExceptionHandler, InitializingBean {
        private static final Set<String> DISCONNECTED_CLIENT_EXCEPTIONS;
        private static final Log logger;
        private final ApplicationContext applicationContext;
        private final ErrorAttributes errorAttributes;
        private final ResourceProperties resourceProperties;
        private final TemplateAvailabilityProviders templateAvailabilityProviders;
        private List<HttpMessageReader<?>> messageReaders = Collections.emptyList();
        private List<HttpMessageWriter<?>> messageWriters = Collections.emptyList();
        private List<ViewResolver> viewResolvers = Collections.emptyList();
    
        public AbstractErrorWebExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties, ApplicationContext applicationContext) {
            Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
            Assert.notNull(resourceProperties, "ResourceProperties must not be null");
            Assert.notNull(applicationContext, "ApplicationContext must not be null");
            this.errorAttributes = errorAttributes;
            this.resourceProperties = resourceProperties;
            this.applicationContext = applicationContext;
            this.templateAvailabilityProviders = new TemplateAvailabilityProviders(applicationContext);
        }
    
        public void setMessageWriters(List<HttpMessageWriter<?>> messageWriters) {
            Assert.notNull(messageWriters, "'messageWriters' must not be null");
            this.messageWriters = messageWriters;
        }
    
        public void setMessageReaders(List<HttpMessageReader<?>> messageReaders) {
            Assert.notNull(messageReaders, "'messageReaders' must not be null");
            this.messageReaders = messageReaders;
        }
    
        public void setViewResolvers(List<ViewResolver> viewResolvers) {
            this.viewResolvers = viewResolvers;
        }
    
        /** @deprecated */
        @Deprecated
        protected Map<String, Object> getErrorAttributes(ServerRequest request, boolean includeStackTrace) {
            return this.getErrorAttributes(request, includeStackTrace ? ErrorAttributeOptions.of(new Include[]{Include.STACK_TRACE}) : ErrorAttributeOptions.defaults());
        }
    
        protected Map<String, Object> getErrorAttributes(ServerRequest request, ErrorAttributeOptions options) {
            return this.errorAttributes.getErrorAttributes(request, options);
        }
    
        protected Throwable getError(ServerRequest request) {
            return this.errorAttributes.getError(request);
        }
    
        protected boolean isTraceEnabled(ServerRequest request) {
            return this.getBooleanParameter(request, "trace");
        }
    
        protected boolean isMessageEnabled(ServerRequest request) {
            return this.getBooleanParameter(request, "message");
        }
    
        protected boolean isBindingErrorsEnabled(ServerRequest request) {
            return this.getBooleanParameter(request, "errors");
        }
    
        private boolean getBooleanParameter(ServerRequest request, String parameterName) {
            String parameter = (String)request.queryParam(parameterName).orElse("false");
            return !"false".equalsIgnoreCase(parameter);
        }
    
        protected Mono<ServerResponse> renderErrorView(String viewName, BodyBuilder responseBody, Map<String, Object> error) {
            if (this.isTemplateAvailable(viewName)) {
                return responseBody.render(viewName, error);
            } else {
                Resource resource = this.resolveResource(viewName);
                return resource != null ? responseBody.body(BodyInserters.fromResource(resource)) : Mono.empty();
            }
        }
    
        private boolean isTemplateAvailable(String viewName) {
            return this.templateAvailabilityProviders.getProvider(viewName, this.applicationContext) != null;
        }
    
        private Resource resolveResource(String viewName) {
            String[] var2 = this.resourceProperties.getStaticLocations();
            int var3 = var2.length;
    
            for(int var4 = 0; var4 < var3; ++var4) {
                String location = var2[var4];
    
                try {
                    Resource resource = this.applicationContext.getResource(location);
                    resource = resource.createRelative(viewName + ".html");
                    if (resource.exists()) {
                        return resource;
                    }
                } catch (Exception var7) {
                }
            }
    
            return null;
        }
    
        protected Mono<ServerResponse> renderDefaultErrorView(BodyBuilder responseBody, Map<String, Object> error) {
            StringBuilder builder = new StringBuilder();
            Date timestamp = (Date)error.get("timestamp");
            Object message = error.get("message");
            Object trace = error.get("trace");
            Object requestId = error.get("requestId");
            builder.append("<html><body><h1>Whitelabel Error Page</h1>").append("<p>This application has no configured error view, so you are seeing this as a fallback.</p>").append("<div id='created'>").append(timestamp).append("</div>").append("<div>[").append(requestId).append("] There was an unexpected error (type=").append(this.htmlEscape(error.get("error"))).append(", status=").append(this.htmlEscape(error.get("status"))).append(").</div>");
            if (message != null) {
                builder.append("<div>").append(this.htmlEscape(message)).append("</div>");
            }
    
            if (trace != null) {
                builder.append("<div style='white-space:pre-wrap;'>").append(this.htmlEscape(trace)).append("</div>");
            }
    
            builder.append("</body></html>");
            return responseBody.bodyValue(builder.toString());
        }
    
        private String htmlEscape(Object input) {
            return input != null ? HtmlUtils.htmlEscape(input.toString()) : null;
        }
    
        public void afterPropertiesSet() throws Exception {
            if (CollectionUtils.isEmpty(this.messageWriters)) {
                throw new IllegalArgumentException("Property 'messageWriters' is required");
            }
        }
    
        protected abstract RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes);
                                                          //路由函数抽象方法
    
        public Mono<Void> handle(ServerWebExchange exchange, Throwable throwable) {
            if (!exchange.getResponse().isCommitted() && !this.isDisconnectedClientError(throwable)) {
                this.errorAttributes.storeErrorInformation(throwable, exchange);
                ServerRequest request = ServerRequest.create(exchange, this.messageReaders);
                return this.getRoutingFunction(this.errorAttributes).route(request).switchIfEmpty(Mono.error(throwable)).flatMap((handler) -> {
                    return handler.handle(request);
                }).doOnNext((response) -> {
                    this.logError(request, response, throwable);
                }).flatMap((response) -> {
                    return this.write(exchange, response);
                });
            } else {
                return Mono.error(throwable);
            }
        }
    
        private boolean isDisconnectedClientError(Throwable ex) {
            return DISCONNECTED_CLIENT_EXCEPTIONS.contains(ex.getClass().getSimpleName()) || this.isDisconnectedClientErrorMessage(NestedExceptionUtils.getMostSpecificCause(ex).getMessage());
        }
    
        private boolean isDisconnectedClientErrorMessage(String message) {
            message = message != null ? message.toLowerCase() : "";
            return message.contains("broken pipe") || message.contains("connection reset by peer");
        }
    
        protected void logError(ServerRequest request, ServerResponse response, Throwable throwable) {
            if (logger.isDebugEnabled()) {
                logger.debug(request.exchange().getLogPrefix() + this.formatError(throwable, request));
            }
    
            if (HttpStatus.resolve(response.rawStatusCode()) != null && response.statusCode().equals(HttpStatus.INTERNAL_SERVER_ERROR)) {
                logger.error(LogMessage.of(() -> {
                    return String.format("%s 500 Server Error for %s", request.exchange().getLogPrefix(), this.formatRequest(request));
                }), throwable);
            }
    
        }
    
        private String formatError(Throwable ex, ServerRequest request) {
            String reason = ex.getClass().getSimpleName() + ": " + ex.getMessage();
            return "Resolved [" + reason + "] for HTTP " + request.methodName() + " " + request.path();
        }
    
        private String formatRequest(ServerRequest request) {
            String rawQuery = request.uri().getRawQuery();
            String query = StringUtils.hasText(rawQuery) ? "?" + rawQuery : "";
            return "HTTP " + request.methodName() + " \"" + request.path() + query + "\"";
        }
    
        private Mono<? extends Void> write(ServerWebExchange exchange, ServerResponse response) {
            exchange.getResponse().getHeaders().setContentType(response.headers().getContentType());
            return response.writeTo(exchange, new AbstractErrorWebExceptionHandler.ResponseContext());
        }
    
        static {
            Set<String> exceptions = new HashSet();
            exceptions.add("AbortedException");
            exceptions.add("ClientAbortException");
            exceptions.add("EOFException");
            exceptions.add("EofException");
            DISCONNECTED_CLIENT_EXCEPTIONS = Collections.unmodifiableSet(exceptions);
            logger = HttpLogging.forLogName(AbstractErrorWebExceptionHandler.class);
        }
    
        private class ResponseContext implements Context {
            private ResponseContext() {
            }
    
            public List<HttpMessageWriter<?>> messageWriters() {
                return AbstractErrorWebExceptionHandler.this.messageWriters;
            }
    
            public List<ViewResolver> viewResolvers() {
                return AbstractErrorWebExceptionHandler.this.viewResolvers;
            }
        }
    }

**DefaultErrorWebExceptionHandler：默认异常处理类**

public class DefaultErrorWebExceptionHandler extends AbstractErrorWebExceptionHandler {
        private static final MediaType TEXT_HTML_UTF8;
        private static final Map<Series, String> SERIES_VIEWS;
        private final ErrorProperties errorProperties;
    
        public DefaultErrorWebExceptionHandler(ErrorAttributes errorAttributes, ResourceProperties resourceProperties, ErrorProperties errorProperties, ApplicationContext applicationContext) {
            super(errorAttributes, resourceProperties, applicationContext);
            this.errorProperties = errorProperties;
        }
    
        protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
            return RouterFunctions.route(this.acceptsTextHtml(), this::renderErrorView).andRoute(RequestPredicates.all(), this::renderErrorResponse);
        }
    
        protected Mono<ServerResponse> renderErrorView(ServerRequest request) {
            Map<String, Object> error = this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.TEXT_HTML));
            int errorStatus = this.getHttpStatus(error);
            BodyBuilder responseBody = ServerResponse.status(errorStatus).contentType(TEXT_HTML_UTF8);
            return Flux.just(this.getData(errorStatus).toArray(new String[0])).flatMap((viewName) -> {
                return this.renderErrorView(viewName, responseBody, error);
            }).switchIfEmpty(this.errorProperties.getWhitelabel().isEnabled() ? this.renderDefaultErrorView(responseBody, error) : Mono.error(this.getError(request))).next();
        }  //异常页面默认定向到： error/errorStatus
    
        private List<String> getData(int errorStatus) {
            List<String> data = new ArrayList();
            data.add("error/" + errorStatus);
            Series series = Series.resolve(errorStatus);
            if (series != null) {
                data.add("error/" + (String)SERIES_VIEWS.get(series));
            }
    
            data.add("error/error");
            return data;
        }
    
        protected Mono<ServerResponse> renderErrorResponse(ServerRequest request) {
            Map<String, Object> error = this.getErrorAttributes(request, this.getErrorAttributeOptions(request, MediaType.ALL));
            return ServerResponse.status(this.getHttpStatus(error)).contentType(MediaType.APPLICATION_JSON).body(BodyInserters.fromValue(error));
        }
    
        protected ErrorAttributeOptions getErrorAttributeOptions(ServerRequest request, MediaType mediaType) {
            ErrorAttributeOptions options = ErrorAttributeOptions.defaults();
            if (this.errorProperties.isIncludeException()) {
                options = options.including(new Include[]{Include.EXCEPTION});
            }
    
            if (this.isIncludeStackTrace(request, mediaType)) {
                options = options.including(new Include[]{Include.STACK_TRACE});
            }
    
            if (this.isIncludeMessage(request, mediaType)) {
                options = options.including(new Include[]{Include.MESSAGE});
            }
    
            if (this.isIncludeBindingErrors(request, mediaType)) {
                options = options.including(new Include[]{Include.BINDING_ERRORS});
            }
    
            return options;
        }
    
        protected boolean isIncludeStackTrace(ServerRequest request, MediaType produces) {
            switch(this.errorProperties.getIncludeStacktrace()) {
            case ALWAYS:
                return true;
            case ON_PARAM:
            case ON_TRACE_PARAM:
                return this.isTraceEnabled(request);
            default:
                return false;
            }
        }
    
        protected boolean isIncludeMessage(ServerRequest request, MediaType produces) {
            switch(this.errorProperties.getIncludeMessage()) {
            case ALWAYS:
                return true;
            case ON_PARAM:
                return this.isMessageEnabled(request);
            default:
                return false;
            }
        }
    
        protected boolean isIncludeBindingErrors(ServerRequest request, MediaType produces) {
            switch(this.errorProperties.getIncludeBindingErrors()) {
            case ALWAYS:
                return true;
            case ON_PARAM:
                return this.isBindingErrorsEnabled(request);
            default:
                return false;
            }
        }
    
        protected int getHttpStatus(Map<String, Object> errorAttributes) {
            return (Integer)errorAttributes.get("status");
        }
    
        protected RequestPredicate acceptsTextHtml() {
            return (serverRequest) -> {
                try {
                    List<MediaType> acceptedMediaTypes = serverRequest.headers().accept();
                    acceptedMediaTypes.remove(MediaType.ALL);
                    MediaType.sortBySpecificityAndQuality(acceptedMediaTypes);
                    Stream var10000 = acceptedMediaTypes.stream();
                    MediaType var10001 = MediaType.TEXT_HTML;
                    var10001.getClass();
                    return var10000.anyMatch(var10001::isCompatibleWith);
                } catch (InvalidMediaTypeException var2) {
                    return false;
                }
            };
        }
    
        static {
            TEXT_HTML_UTF8 = new MediaType("text", "html", StandardCharsets.UTF_8);
            Map<Series, String> views = new EnumMap(Series.class);
            views.put(Series.CLIENT_ERROR, "4xx");
            views.put(Series.SERVER_ERROR, "5xx");
            SERIES_VIEWS = Collections.unmodifiableMap(views);
        }
    }

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**示例**

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**controller 层**

**HelloController**

@RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public void hello(){
            System.out.println("hello world");
    
            throw new ResponseStatusException(HttpStatus.NOT_FOUND);
        }
    
        @RequestMapping("/hello2")
        public void hello2(){
            System.out.println("hello world2");
    
            throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**前端页面**

![2020062022070715.png][]

**4xx.html**

<!DOCTYPE html>
    <html lang="en" xmlns="http://www.w3.org/1999/xhtml"
          xmlns:th="http://www.thymeleaf.org" xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div align="center" style="color: greenyellow">
        页面找不到了:4xx
    </div>
    </body>
    </html>

**404.html**

<!DOCTYPE html>
    <html lang="en" xmlns="http://www.w3.org/1999/xhtml"
          xmlns:th="http://www.thymeleaf.org" xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div th:align="center" style="color: green">
        页面丢失了:404
    </div>
    </body>
    </html>

**500.html**

<!DOCTYPE html>
    <html lang="en" xmlns="http://www.w3.org/1999/xhtml"
          xmlns:th="http://www.thymeleaf.org" xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div align="center" style="color: aquamarine">
        出错了：500
    </div>
    </body>
    </html>

## ##

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**使用测试**

**localhost:8080/hello**

![20200620221257918.png][]

**localhost:8080/hello2**

![20200620221335836.png][]

[2020062022070715.png]: https://img-blog.csdnimg.cn/2020062022070715.png
[20200620221257918.png]: https://img-blog.csdnimg.cn/20200620221257918.png
[20200620221335836.png]: https://img-blog.csdnimg.cn/20200620221335836.png