Spring Boot WebFlux中响应式流异常的统一处理指南

// 部分GlobalFilter代码片段
return webClient.get()
        .uri("http://uaa", uriBuilder -> uriBuilder
                .path("/validate-token")
                .queryParam("token", authToken).build()).retrieve()
        .bodyToMono(TokenValidationGetResource.class)
        .map(tokenValidationGetResource -> {
            if (!tokenValidationGetResource.isValid()) {
                log.debug("token is not valid");
                throw new AuthorizationForbiddenException(AuthorizationForbiddenExceptionTitleEnum.TOKEN_NOT_VALID, "Token is not valid"); // 此处抛出异常
            }
            // ... 其他逻辑
        }).flatMap(chain::filter);

import org.springframework.boot.web.error.ErrorAttributeOptions;
import org.springframework.boot.web.reactive.error.DefaultErrorAttributes;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;

import java.time.Instant;
import java.util.HashMap;
import java.util.Map;

@Component
public class GlobalErrorAttributes extends DefaultErrorAttributes {

    @Override
    public Map<String, Object> getErrorAttributes(ServerRequest request, ErrorAttributeOptions options) {
        // 获取原始错误信息
        Throwable error = getError(request);

        // 尝试将错误转换为我们自定义的BaseException类型
        AbstractBaseException baseException = null;
        try {
            if (error instanceof AbstractBaseException) {
                baseException = (AbstractBaseException) error;
            }
        } catch (Exception e) {
            // 如果转换失败，保留原始错误
            // 这里可以添加日志记录
        }

        Map<String, Object> errorResources = new HashMap<>();

        // 根据自定义异常或通用错误信息填充响应体
        // 示例：定义你希望在响应体中返回的属性
        errorResources.put("timestamp", Instant.now().toEpochMilli());
        errorResources.put("status", baseException != null ? baseException.getStatus().value() : HttpStatus.INTERNAL_SERVER_ERROR.value());
        errorResources.put("code", baseException != null ? baseException.getTitle().getCode() : "UNKNOWN_ERROR");
        errorResources.put("title", baseException != null ? baseException.getTitle().toString() : "Internal Server Error");
        errorResources.put("detail", baseException != null ? baseException.getMessage() : "An unexpected error occurred.");
        errorResources.put("developerMessage", error.getClass().getName());

        // 如果需要，可以添加更多信息，例如请求路径等
        // errorResources.put("path", request.path());

        return errorResources;
    }
}

import org.springframework.boot.web.reactive.error.AbstractErrorWebExceptionHandler;
import org.springframework.boot.web.error.ErrorAttributeOptions;
import org.springframework.boot.web.server.WebProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import java.util.Map;

@Component
@Order(-2) // 确保此处理器在Spring Boot默认错误处理器之前被执行
public class GlobalErrorWebExceptionHandler extends AbstractErrorWebExceptionHandler {

    public GlobalErrorWebExceptionHandler(GlobalErrorAttributes globalErrorAttributes,
                                          ApplicationContext applicationContext,
                                          ServerCodecConfigurer serverCodecConfigurer) {
        super(globalErrorAttributes, new WebProperties.Resources(), applicationContext);
        // 设置消息读写器，以便能够处理JSON等媒体类型
        super.setMessageWriters(serverCodecConfigurer.getWriters());
        super.setMessageReaders(serverCodecConfigurer.getReaders());
    }

    @Override
    protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
        // 定义路由函数，将所有请求（RequestPredicates.all()）路由到renderErrorResponse方法
        return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
    }

    private Mono<ServerResponse> renderErrorResponse(ServerRequest request) {
        // 从ErrorAttributes中获取错误属性，这些属性由GlobalErrorAttributes提供
        final Map<String, Object> errorPropertiesMap = getErrorAttributes(request, ErrorAttributeOptions.defaults());

        // 从错误属性中提取状态码，如果无法获取，则默认为500 Internal Server Error
        HttpStatus statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
        if (errorPropertiesMap.containsKey("status")) {
            Object statusObj = errorPropertiesMap.get("status");
            if (statusObj instanceof Integer) {
                statusCode = HttpStatus.valueOf((Integer) statusObj);
            } else if (statusObj instanceof String) {
                try {
                    statusCode = HttpStatus.valueOf(Integer.parseInt((String) statusObj));
                } catch (NumberFormatException e) {
                    // Ignore, use default
                }
            }
        }

        // 构建并返回ServerResponse
        return ServerResponse.status(statusCode)
                .contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue(errorPropertiesMap));
    }
}

{
    "timestamp": 1678886400000,
    "status": 403,
    "code": "AUTH_FORBIDDEN_TOKEN_NOT_VALID",
    "title": "TOKEN_NOT_VALID",
    "detail": "Token is not valid",
    "developerMessage": "com.example.exception.AuthorizationForbiddenException"
}