Spring WebFlux如何处理WebClient多格式响应体的运行时序列化？

这种同一个接口返回不同JSON结构的场景确实挺棘手的，不过在WebFlux里我们有几种简洁的方式来处理，既避免重复请求，又能优雅地尝试不同的序列化目标。

方式一：缓存响应体字节数组，依次尝试反序列化 #

最稳妥的做法是先发起一次请求，把响应体缓存成字节数组，然后依次尝试序列化为目标类型——这样不会因为序列化失败而重复调用接口，性能更优。

首先，我们需要定义两个响应模型类：

public class Type1Response {
    private Integer a;
    private String b;
    // getter、setter、构造方法省略
}

public class Type2Response {
    private LocalDate c;
    private NestedData d;
    // getter、setter、构造方法省略
    
    public static class NestedData {
        private List<String> items;
        // getter、setter省略
    }
}

然后，用WebClient的exchangeToMono获取ClientResponse，读取并缓存响应体，再用Jackson（Spring默认的序列化工具）依次尝试反序列化：

// 注入Spring管理的ObjectMapper，避免重复创建
@Autowired
private ObjectMapper objectMapper;

public Mono<?> handleDynamicResponse() {
    return webClient.get()
            .uri("/your-target-endpoint")
            .exchangeToMono(clientResponse -> {
                // 读取响应体并转换为字节数组，释放缓冲区资源
                return clientResponse.bodyToFlux(DataBuffer.class)
                        .collect(DataBufferUtils::join)
                        .map(dataBuffer -> {
                            byte[] responseBytes = new byte[dataBuffer.readableByteCount()];
                            dataBuffer.read(responseBytes);
                            DataBufferUtils.release(dataBuffer);
                            return responseBytes;
                        })
                        .flatMap(responseBytes -> {
                            // 先尝试序列化为Type1
                            try {
                                Type1Response type1 = objectMapper.readValue(responseBytes, Type1Response.class);
                                return Mono.just(type1);
                            } catch (JsonProcessingException e) {
                                // Type1序列化失败，尝试Type2
                                try {
                                    Type2Response type2 = objectMapper.readValue(responseBytes, Type2Response.class);
                                    return Mono.just(type2);
                                } catch (JsonProcessingException ex) {
                                    // 两种类型都失败，返回自定义错误
                                    return Mono.error(new RuntimeException("Failed to deserialize response to either expected type", ex));
                                }
                            }
                        });
            });
}

这里的核心是只发起一次请求，通过DataBufferUtils.join把响应体的数据流合并成一个字节数组，然后用Jackson的readValue方法依次尝试反序列化，捕获JsonProcessingException来切换尝试目标。

方式二：利用onErrorResume链式尝试（注意重复请求问题） #

如果你能接受序列化失败时重新发起一次请求（不推荐，但简单场景下可用），可以用bodyToMono结合onErrorResume的链式调用：

public Mono<?> handleDynamicResponseSimple() {
    return webClient.get()
            .uri("/your-target-endpoint")
            .retrieve()
            .bodyToMono(Type1Response.class)
            // Type1序列化失败，尝试Type2
            .onErrorResume(DecodeException.class, ex -> 
                webClient.get()
                        .uri("/your-target-endpoint")
                        .retrieve()
                        .bodyToMono(Type2Response.class)
            )
            // 两种都失败，返回错误
            .onErrorResume(DecodeException.class, ex -> 
                Mono.error(new RuntimeException("Failed to deserialize response", ex))
            );
}

⚠️ 注意：这种方式会在Type1序列化失败时重新发起一次请求，接口性能敏感的场景下不建议使用。

运行时动态模型的序列化 #

如果你的目标模型是运行时动态确定的（比如根据请求参数选择不同的模型类），直接把Class对象传入Jackson的readValue方法即可：

// runtimeTargetClass是运行时获取的目标类型Class
public Mono<?> deserializeToRuntimeType(byte[] responseBytes, Class<?> runtimeTargetClass) {
    try {
        Object result = objectMapper.readValue(responseBytes, runtimeTargetClass);
        return Mono.just(result);
    } catch (JsonProcessingException e) {
        return Mono.error(e);
    }
}

如果是泛型类型（比如List<MyDynamicModel>），可以用Jackson的TypeReference来指定具体类型：

public Mono<List<?>> deserializeToList(byte[] responseBytes, Class<?> elementType) {
    // 用JavaType构建泛型类型，更灵活
    JavaType listType = objectMapper.getTypeFactory().constructCollectionType(List.class, elementType);
    try {
        List<?> result = objectMapper.readValue(responseBytes, listType);
        return Mono.just(result);
    } catch (JsonProcessingException e) {
        return Mono.error(e);
    }
}

总结 #

• 优先选择缓存响应体字节数组后依次尝试反序列化的方式，避免重复请求，性能更优
• 运行时动态模型的处理核心是利用Jackson的readValue方法，传入动态的Class或JavaType/TypeReference
• 全局复用场景下也可以自定义HttpMessageDecoder，但复杂度较高，适合需要统一处理这类场景的项目

内容的提问来源于stack exchange，提问作者diziaq