处理REST API动态响应：基于JSON结构动态解析不同数据类型

当rest api在同一http状态码下返回多种不同的json响应结构时，直接使用`resttemplate`结合`object.class`和`instanceof`进行类型判断是无效的。本文将介绍一种健壮的方法，通过将api响应获取为字符串，并利用jackson `objectmapper`的`jsonnode`进行初步结构判断，然后根据判断结果将响应反序列化为对应的j*a对象，从而有效处理这种动态响应场景。

1. 问题背景与挑战

在与第三方API集成时，我们有时会遇到这样的场景：API在成功（例如HTTP 200 OK）的情况下，根据业务逻辑的不同，返回两种或多种截然不同的JSON响应结构。例如，一个请求可能在有数据时返回一个记录列表，而在无数据或发生特定业务错误时，仍然返回200 OK，但其响应体却是一个包含错误信息的对象。

在这种情况下，如果直接使用RestTemplate的exchange方法并将响应类型指定为Object.class，然后尝试通过instanceof操作符来判断response.getBody()的具体类型（例如ZohoError或List），会发现这种判断总是失败的。其根本原因在于，当RestTemplate接收到JSON响应并将其反序列化为Object时，通常会将其解析为J*a的通用类型，如LinkedHashMap（表示JSON对象）或ArrayList（表示JSON数组），而不是我们期望的自定义DTO类（如ZohoError）。因此，instanceof ZohoError或instanceof List（即使是ArrayList）都可能无法按照预期工作，导致业务逻辑分支判断错误。

2. 解决方案：基于字符串的JSON结构动态解析

为了准确识别并处理这种动态响应，我们需要一种更灵活的方法：将API响应作为原始字符串获取，然后利用JSON处理库（如Jackson）进行结构化分析和条件反序列化。

2.1 核心思路

1. 获取原始响应字符串： 不直接让RestTemplate尝试反序列化为特定对象，而是将其响应体获取为String类型。
2. 初步解析为JsonNode： 使用ObjectMapper将响应字符串解析为一个通用的JsonNode。JsonNode是Jackson库中表示JSON结构的基本单元，它可以是对象、数组、字符串、数字、布尔值或null。
3. 判断JSON结构： 通过检查JsonNode的类型（是对象还是数组）以及其中是否存在特定的关键字段（例如错误消息字段），来判断当前的JSON响应属于哪种预期的结构。
4. 条件反序列化： 根据判断结果，使用ObjectMapper将原始响应字符串反序列化为对应的J*a DTO对象（例如ZohoError或List）。

2.2 示例代码实现

假设我们有以下两个DTO类用于表示可能的响应结构：

达芬奇

达芬奇——你的AI创作大师

166 查看详情

import com.fasterxml.jackson.annotation.JsonAlias;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

// 错误响应DTO
@Getter
@Setter
@ToString
@EqualsAndHashCode
public class ZohoError {
  private String message;
  @JsonAlias("errorcode")
  private String errorCode;
  @JsonAlias("Response status")
  private int responseStatus;
}

// 成功响应中的单个记录DTO
@Getter
@Setter
@ToString
@EqualsAndHashCode
public class Le*e {
  private String id;
  private String employeeName;
  private String le*eType;
  // ... 其他字段
}

现在，我们修改原有的API调用逻辑，使用Jackson ObjectMapper进行动态解析：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import j*a.util.Collections;
import j*a.util.List;

@Service
public class ThirdPartyApiService {

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper; // 注入或创建ObjectMapper实例

    public ThirdPartyApiService(RestTemplate restTemplate, ObjectMapper objectMapper) {
        this.restTemplate = restTemplate;
        this.objectMapper = objectMapper;
    }

    public List<Le*e> getLe*eRecords(String uri) {
        HttpHeaders httpHeaders = new HttpHeaders();
        // ... 添加必要的HTTP头

        HttpEntity<Void> request = new HttpEntity<>(httpHeaders);

        // 1. 获取原始响应字符串
        ResponseEntity<String> response = restTemplate.exchange(uri, HttpMethod.GET, request, String.class);
        String responseBody = response.getBody();

        if (responseBody == null || responseBody.isEmpty()) {
            return Collections.emptyList();
        }

        try {
            // 2. 将响应字符串解析为JsonNode
            JsonNode rootNode = objectMapper.readTree(responseBody);

            // 3. 判断JSON结构：
            // 假设错误响应总是包含 "errorCode" 字段，而成功列表响应是一个JSON数组。
            // 这是一个基于业务规则的判断，需要根据实际API响应结构来确定。
            if (rootNode.has("errorCode") || rootNode.has("message") && rootNode.has("Response status")) {
                // 看起来是错误响应
                ZohoError zohoError = objectMapper.readValue(responseBody, ZohoError.class);
                System.err.println("API返回错误: " + zohoError.getMessage() + " (Code: " + zohoError.getErrorCode() + ")");
                return Collections.emptyList(); // 或者抛出自定义异常
            } else if (rootNode.isArray()) {
                // 看起来是列表响应
                // 使用TypeReference来处理泛型列表的反序列化
                return objectMapper.readValue(responseBody, new TypeReference<List<Le*e>>() {});
            } else {
                // 未知响应结构，可能是单个对象而不是列表，或者其他意外情况
                System.err.println("API返回未知结构: " + responseBody);
                return Collections.emptyList();
            }
        } catch (Exception e) {
            System.err.println("解析API响应失败: " + e.getMessage());
            // 记录日志，并根据业务需求处理异常
            return Collections.emptyList();
        }
    }
}

2.3 注意事项

• ObjectMapper实例： 在Spring Boot项目中，ObjectMapper通常会被自动配置并作为Bean提供，可以直接注入使用。
• 判断逻辑的健壮性： 用于判断JSON结构的条件 (rootNode.has("errorCode") 等) 必须基于对第三方API响应结构的准确理解。选择那些在不同响应类型中具有唯一性或明确指示作用的字段。
• 错误处理： 在解析JSON和反序列化过程中，应捕获JsonProcessingException或其他相关异常，并进行适当的错误日志记录和业务处理（例如返回空列表、抛出自定义异常等）。
• TypeReference： 当反序列化泛型类型（如List）时，必须使用TypeReference来帮助ObjectMapper正确推断泛型类型信息。
• API设计建议： 理想情况下，第三方API应该遵循RESTful原则，对于不同类型的响应（成功数据、业务错误、系统错误），使用不同的HTTP状态码，这样可以简化客户端的错误处理逻辑，例如200 OK用于成功，4xx用于客户端错误，5xx用于服务器错误。

3. 总结

当面对REST API在同一HTTP状态码下返回多种JSON结构时，直接依赖RestTemplate的自动类型推断和instanceof是不可靠的。通过将API响应获取为原始字符串，并结合Jackson ObjectMapper的JsonNode进行灵活的结构判断和条件反序列化，我们可以构建出更加健壮和适应性强的客户端代码。这种方法虽然增加了代码量，但显著提升了对复杂API响应的处理能力和程序的稳定性。

以上就是处理REST API动态响应：基于JSON结构动态解析不同数据类型的详细内容，更多请关注其它相关文章！