使用 GSON 调整改造响应

Question

我希望通过从特定 API 收到的每个成功响应来检索已知 JSON 对象的子元素。

每个服务器响应都返回以下 JSON 格式（为简单起见进行了精简）：

{
    "status": "success",
    "error_title": "",
    "error_message": "",
    "data": {
        "messages": [
            { "message_id": "123",
              "content": "This is a message" },
            { "message_id": "124",
              "content": "This is another message" }
        ]
    }
}

错误响应包含相同的通用格式，“数据”对象为空，错误相关的 JSON 对象包含有用的值。在出现错误的情况下，我想提取与错误相关的 JSON 对象。

通过上述响应，我有一个 MessageResponse 类，其中包含状态、errorTitle 和 errorMessage 字符串属性以及一个 MessageData 对象。然后MessageData 对象包含一个消息列表 - List<Message> messages。我在这种情况下获取消息的 GET 方法如下（为简单起见）：

@GET("/chat/conversation")
void getMessages(Callback<MessageResponse> callback);

如果我坚持使用 GSON 的序列化程序提供的开箱即用的默认 POJO 映射，则此设计需要三个类用于 每个 响应类型。我的最终目标是通过仅从成功的服务器响应中读取我需要的内容并忽略其余部分来减少所需的类数量。我希望此 API 上的所有成功回调数据类型尽可能接近“数据”内容。

换句话说，我想不可知地返回“数据”的子元素。在上面的例子中，它是一个名为“messages”的数组，但在其他一些响应中，它可能是一个“用户”对象，例如。我知道这可以通过为每种响应类型注册单独的 TypeAdapters 来完成，但我想通过使用单一的通用解决方案来实现我的最终目标。

更新：从下面执行大卫的建议

public class BaseResponse<T> {
     @SerializedName("status") public String status;
     @SerializedName("error_title") public String errorMessageTitle;
     @SerializedName("error_message") public String errorMessage;
     @SerializedName("data") public T data;
}

public class MessagesResponse extends BaseResponseData<List<Message>> {
     @SerializedName("messages") List<Message> messages;
}

@GET("/chat/conversation")
void getMessages(Callback<BaseResponse<MessageResponse>> callback);

不幸的是，这没有得到正确的序列化。如果我能以某种方式通知 GSON 来自“数据”父级的可变名称 JSON 对象子级，并将该子级反序列化为由通用数据类型引用的模型类。本质上，dataJsonObject.getChild()。

Answer 1

在向 GSON 提供通用的基本响应类几个小时失败后，我最终通过了这条路线并确定了我几天前实施的解决方案（减去状态检查条件）。

GSON 通过在通用 TypeAdapterFactory 中定义反序列化逻辑，提供向所有响应添加 TypeAdapter 的能力。这个实体并不像我希望的那样干净和无知，但它在减少必要的响应模型类数量的同时还维护了一个适配器。

private static class ResponseTypeAdapterFactory implements TypeAdapterFactory {

    private static final String STATUS = "status";
    private static final String SUCCESS = "success";
    private static final String DATA = "data";

    @Override
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        final TypeAdapter<T> delegateAdapter = gson.getDelegateAdapter(this, type);
        final TypeAdapter<JsonElement> jsonElementAdapter = gson.getAdapter(JsonElement.class);

        return new TypeAdapter<T>() {
            @Override
            public void write(JsonWriter out, T value) throws IOException {
                delegateAdapter.write(out, value);
            }

            @Override
            public T read(JsonReader in) throws IOException {
                // Ignore extraneous data and read in only the response data when the response is a success
                JsonElement jsonElement = jsonElementAdapter.read(in);
                if (jsonElement.isJsonObject()) {
                    JsonObject jsonObject = jsonElement.getAsJsonObject();
                    if (jsonObject.has(STATUS)) {
                        if (jsonObject.get(STATUS).getAsString().equals(SUCCESS)) {
                            if (jsonObject.has(DATA) && jsonObject.get(DATA).isJsonObject()) {
                                jsonElement = jsonObject.get(DATA);
                            }
                        }
                    }
                }
                return delegateAdapter.fromJsonTree(jsonElement);
            }
        }.nullSafe();
    }
}

简而言之，如果响应成功，我会告诉 GSON 抓取“数据”JSON 对象。否则，返回整个响应正文，以便我的自定义 Retrofit 错误处理程序可以使用从服务器返回的“error_title”和“error_message”字段。

非常感谢 @david.mihola 提出的好建议，并最终将我的注意力引回到 TypeAdapterFactory 解决方案上。

Answer 2

这并不是您问题的真正答案，但可能是针对同一问题的替代解决方案，即为许多类似的响应提供多个冗余类：

这是我们的AbstractResponse：

public abstract class AbstractResponse<T> {

    @SerializedName("success")
    private boolean success;

    // used for error handling
    @SerializedName("error")
    private String errorMessage;

    @SerializedName("code")
    private Integer errorCode;

    // used for normal operation
    @SerializedName("data")
    protected T data;

    @SerializedName("details")
    private DetailsError details;

    @SerializedName("points")
    private Integer points;

    public boolean isSuccess() {
        return success;
    }

    public T getData() {
        return data;
    }

    public DetailsError getDetailsError() {
        return details;
    }

    public Integer getPoints() {
        return points;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    public Integer getErrorCode() {
        return errorCode;
    }

    public AbstractResponse(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "AbstractResponse{" +
                "success=" + success +
                ", errorMessage='" + errorMessage + '\'' +
                ", errorCode=" + errorCode +
                ", data=" + data +
                '}';
    }
}

还有像这样的类：

public class VotingImageListResponse extends AbstractResponse<List<VotingImage>> {

    public VotingImageListResponse(List<VotingImage> data) {
        super(data);
    }

}

Retrofit 像这样使用它们：

@GET("/api/VotingImage")
public void getVotingImages(@Query("voting_id") Integer id, @Query("app_user_id") Integer userId, @Query("session") String sessionId, Callback<VotingImageListResponse> callback);

仅此而已。

编辑：

为了更清楚，这里是VotingImage：

public class VotingImage implements Parcelable {

    @SerializedName("voting_image_id")
    private final Integer votingImageId;

    @SerializedName("voting_id")
    private final Integer votingId;

    @SerializedName("image_id")
    private final Integer imageId;

    @SerializedName("url")
    private final Uri uri;

    @SerializedName("url_small")
    private final Uri uriSmall;

    // ...
}

更多具体响应类的例子：

public class ChoiceResponse extends AbstractResponse<Choice> {
    public ChoiceResponse(Choice data) {
        super(data);
    }
}

Choice 的定义如下：

public class Choice {

    @SerializedName("question_list")
    private final PVector<Question> questions;

    @SerializedName("is_evaluation")
    private final Boolean isEvaluation;

   // ...
}

或者：

public class RegisterResponse extends AbstractResponse<RegisterResponseData>{
    public RegisterResponse(RegisterResponseData data) {
        super(data);
    }
}

与：

public class RegisterResponseData {

    @SerializedName("mail")
    private String email;

    @SerializedName("app_user_id")
    private Integer appUserId;

    @SerializedName("name")
    private String name;

    @SerializedName("session")
    private String sessionId;

    // ...
}

如您所见，尽管 JSON 属性始终称为“数据”，但该字段的类型/内容对于每个响应可能会有很大差异。唯一重要的是 Retrofit 知道（以便它可以告诉 Gson）您预期响应的类型。上面的通用类结构只是-我认为-告诉 Retrofit/Gson 将 JSON 解析为什么的简洁方式。上面的示例方法也可以直接写成这样：

@GET("/api/VotingImage")
public void getVotingImages(@Query("voting_id") Integer id, @Query("app_user_id") Integer userId, @Query("session") String sessionId, Callback<AbstractResponse<List<VotingImage> callback);

还有一件事：这没有经过测试，我现在还不能真正测试它，但是这个怎么样：

public abstract class MyAbstractCallback<T> implements Callback<AbstractResponse<T>> {

    @Callback
    public void onSuccess(AbstractResponse<T> response) {
        // if (response was successful) {
            T data = response.getData();
            onRealSuccess(data);
        // }
    }

    public abstract void onRealSuccess(T data);
}

通过这种方式，您还可以从整个通用响应中分解出实际响应数据的“解包”。