Java中优化结构多变的REST API响应反序列化方案探讨

我需要反序列化外部REST API的响应：正常情况下响应是JSON对象，出错时会变为JSON对象数组。由于该API无文档，我只能通过HTTP状态码判断是否出错。不同API路由的正常响应结构差异明显（如用户响应、产品响应等），应用中用抽象类AbsractApiResponse统一处理外部API响应，包含error、hasError等字段。

当前实现代码如下：

public abstract class AbsractApiResponse {
    public abstract String getError();
    public abstract void setError(String error);
    public abstract String getDescription();
    public abstract void setDescription(String error);
}

public class ErrorResponse {
    private String errorCode; // getters/setters
    private String message; // getters/setters
}

public class UserResponse extends AbsractApiResponse {
    private String error; // getters/setters
    private boolean hasError; // getters/setters
    private boolean description; // 此处应为String类型，原代码存在笔误
    private String userName;
    private String userEmail;
}

public <R extends AbsractApiResponse> R deserializeResponse(
    String apiResponse, Class<R> responseType, boolean isHttpError)
    throws JsonProcessingException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
    R response;
    Object deserialized = objectMapper.readValue(apiResponse, Object.class);

    if (isHttpError && deserialized instanceof List) {
        TypeReference<List<ErrorResponse>> errorResponseType = new TypeReference<>() {};
        List<ErrorResponse> responseErrors = objectMapper.convertValue(deserialized, errorResponseType);
        Constructor<R> constructor = responseType.getDeclaredConstructor();
        response = constructor.newInstance();
        ErrorResponse firstError = responseErrors.get(0);
        String errorDescription = responseErrors.stream().map(ErrorResponse::toString).collect(Collectors.joining());
        response.setError(firstError.getMessage());
        response.setDescription(errorDescription);
    } else {
        response = objectMapper.convertValue(deserialized, responseType);
    }
    return response;
}

当前方案存在两个核心问题：每个响应类需重复定义error/hasError等字段，且反射引入4个受检异常，希望找到更优解决办法。

1. 用组合代替继承，消除重复字段 #

将错误相关字段抽为独立的ApiError类，让抽象响应类持有该对象并提供快捷访问方法，子类只需关注业务字段：

public class ApiError {
    private String error;
    private String description;
    private boolean hasError;

    // getters and setters
}

// 修正原类名拼写错误：Absract -> Abstract
public abstract class AbstractApiResponse {
    private ApiError apiError = new ApiError();

    // 代理ApiError的方法，提供快捷访问
    public String getError() {
        return apiError.getError();
    }

    public void setError(String error) {
        apiError.setError(error);
        apiError.setHasError(error != null && !error.isEmpty());
    }

    public String getDescription() {
        return apiError.getDescription();
    }

    public void setDescription(String description) {
        apiError.setDescription(description);
    }

    public boolean isHasError() {
        return apiError.isHasError();
    }
}

// 子类仅需定义业务字段
public class UserResponse extends AbstractApiResponse {
    private String userName;
    private String userEmail;

    // getters and setters
}

2. 替换反射，用Jackson原生API创建实例 #

利用Jackson的ObjectReader直接创建响应实例，避免反射带来的受检异常：

public <R extends AbstractApiResponse> R deserializeResponse(
    String apiResponse, Class<R> responseType, boolean isHttpError)
    throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    R response;

    if (isHttpError) {
        // 直接反序列化为错误列表
        List<ErrorResponse> errorResponses = objectMapper.readValue(apiResponse, 
            objectMapper.getTypeFactory().constructCollectionType(List.class, ErrorResponse.class));
        
        // 用Jackson创建空实例，替代反射
        response = objectMapper.readValue("{}", responseType);
        
        if (!errorResponses.isEmpty()) {
            ErrorResponse firstError = errorResponses.get(0);
            // 优化错误描述格式，提升可读性
            String errorDescription = errorResponses.stream()
                .map(err -> String.format("错误码：%s，信息：%s", err.getErrorCode(), err.getMessage()))
                .collect(Collectors.joining("; "));
            
            response.setError(firstError.getMessage());
            response.setDescription(errorDescription);
        } else {
            response.setError("未知错误");
            response.setDescription("未返回具体错误信息");
        }
    } else {
        response = objectMapper.readValue(apiResponse, responseType);
    }
    return response;
}

此方式仅保留JsonProcessingException一种受检异常，同时利用Jackson的默认构造逻辑，比反射更安全可靠。

3. 额外优化：处理边界场景 #

原代码直接调用responseErrors.get(0)，若错误数组为空会抛出IndexOutOfBoundsException，上述优化代码已添加空列表判断，避免此类异常。

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