Spring WebClient 错误响应体转换为 Java POJO 教程

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

public class CustomErrorResponse {
    private String code;
    private String message;

    // 默认构造函数（Jackson需要）
    public CustomErrorResponse() {
    }

    // 全参构造函数（可选，但推荐）
    @JsonCreator
    public CustomErrorResponse(@JsonProperty("code") String code, 
                               @JsonProperty("message") String message) {
        this.code = code;
        this.message = message;
    }

    // Getters and Setters
    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "CustomErrorResponse{" +
               "code='" + code + '\'' +
               ", message='" + message + '\'' +
               '}';
    }
}

import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import org.springframework.http.HttpStatus;

public class WebClientErrorConverterService {

    private final WebClient webClient;
    private final ObjectMapper objectMapper;

    // 通常通过构造器注入WebClient和ObjectMapper
    public WebClientErrorConverterService(WebClient webClient, ObjectMapper objectMapper) {
        this.webClient = webClient;
        this.objectMapper = objectMapper;
    }

    /**
     * 发起一个HTTP GET请求并处理错误响应体。
     *
     * @param url 请求的URL
     * @return 成功时返回响应体字符串，失败时返回一个包含自定义异常的Mono。
     */
    public Mono<String> fetchDataAndHandleErrors(String url) {
        return webClient.get()
                .uri(url)
                .retrieve()
                // 使用onStatus拦截所有客户端和服务器错误
                .onStatus(HttpStatus::isError, clientResponse ->
                    clientResponse.bodyToMono(String.class) // 首先将错误响应体读取为字符串
                        .flatMap(errorBody -> {
                            System.err.println("接收到原始错误响应体: " + errorBody); // 打印原始错误体便于调试
                            try {
                                // 使用ObjectMapper将字符串转换为CustomErrorResponse POJO
                                CustomErrorResponse errorResponse = objectMapper.readValue(errorBody, CustomErrorResponse.class);
                                // 抛出一个自定义异常，其中包含解析后的错误信息
                                return Mono.error(new CustomApplicationException(
                                        errorResponse.getCode(), 
                                        errorResponse.getMessage(),
                                        clientResponse.statusCode().value() // 包含HTTP状态码
                                ));
                            } catch (IOException e) {
                                // 如果JSON解析失败，说明响应体不是预期的JSON格式
                                System.err.println("错误响应体JSON解析失败: " + e.getMessage());
                                // 可以选择抛出原始的WebClientResponseException，或者一个新的通用异常
                                return Mono.error(new RuntimeException("无法解析错误响应体", e));
                            }
                        })
                )
                .bodyToMono(String.class); // 对于成功的响应，继续将其转换为字符串
    }

    // 定义一个自定义的应用异常，用于封装解析后的错误信息
    public static class CustomApplicationException extends RuntimeException {
        private final String errorCode;
        private final int httpStatus;

        public CustomApplicationException(String errorCode, String message, int httpStatus) {
            super(message);
            this.errorCode = errorCode;
            this.httpStatus = httpStatus;
        }

        public String getErrorCode() {
            return errorCode;
        }

        public int getHttpStatus() {
            return httpStatus;
        }

        @Override
        public String toString() {
            return "CustomApplicationException{" +
                   "errorCode='" + errorCode + '\'' +
                   ", message='" + getMessage() + '\'' +
                   ", httpStatus=" + httpStatus +
                   '}';
        }
    }

    // 示例：如何使用这个服务
    public static void main(String[] args) {
        // 实际应用中WebClient和ObjectMapper通常通过Spring的依赖注入管理
        // 这里为了演示，我们手动创建
        WebClient webClient = WebClient.builder()
                .baseUrl("http://localhost:8080") // 假设有一个服务运行在8080端口
                .build();
        ObjectMapper objectMapper = new ObjectMapper();

        WebClientErrorConverterService service = new WebClientErrorConverterService(webClient, objectMapper);

        // 假设 '/api/resource/error' 会返回一个404状态码和 {"code": "NOT_FOUND", "message": "Resource not found"}
        String errorUrl = "/api/resource/error"; 
        // 假设 '/api/resource/success' 会返回一个200状态码和 "Success Data"
        String successUrl = "/api/resource/success";

        System.out.println("--- 测试错误响应 ---");
        service.fetchDataAndHandleErrors(errorUrl)
                .subscribe(
                    data -> System.out.println("成功响应: " + data),
                    error -> {
                        if (error instanceof CustomApplicationException) {
                            CustomApplicationException appEx = (CustomApplicationException) error;
                            System.err.println("捕获到自定义错误: " + appEx);
                        } else {
                            System.err.println("捕获到其他错误: " + error.getMessage());
                        }
                    }
                );

        System.out.println("\n--- 测试成功响应 ---");
        service.fetchDataAndHandleErrors(successUrl)
                .subscribe(
                    data -> System.out.println("成功响应: " + data),
                    error -> System.err.println("成功响应时意外捕获到错误: " + error.getMessage())
                );

        // 注意：在实际测试中，你需要一个后端服务来模拟这些响应。
        // 例如，使用Spring Boot创建一个简单的Controller：
        /*
        @RestController
        public class MockController {
            @GetMapping("/api/resource/error")
            public ResponseEntity<CustomErrorResponse> getError() {
                return ResponseEntity.status(HttpStatus.NOT_FOUND)
                                     .body(new CustomErrorResponse("NOT_FOUND", "Resource not found"));
            }

            @GetMapping("/api/resource/success")
            public String getSuccess() {
                return "Success Data";
            }
        }
        */
    }
}