Question

我正在使用 Retrofit 与 Gson 进行反序列化。我希望Retrofit响应成为接口，所以我做了 TypeAdapterFactory ，它应该告诉gson将接口反序列化到它们的类实现。在我的情况下 FeedElement 是界面 FeedElementImp 是实现它的类。

public class InterfaceAdapterFactory implements TypeAdapterFactory {

@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    if (FeedElement.class.isAssignableFrom(type.getRawType())) {
        return (TypeAdapter<T>) new FeedElementAdapter(gson);
    } else {
        return null;
    }
}

private class FeedElementAdapter extends TypeAdapter<FeedElement> {
    private Gson gson;

    public FeedElementAdapter(Gson gson) {
        this.gson = gson;
    }

    @Override
    public void write(JsonWriter out, FeedElement value) throws IOException {
        out.jsonValue(gson.toJson(value));
    }

    @Override
    public FeedElement read(JsonReader in) throws IOException {
        return gson.fromJson(in, FeedElementImp.class);
    }
}
}

当然，这不起作用。在使用构建器创建Gson时，我正在注册此工厂。我想问题出现在FeedElementAdapter写/读方法中。

private static ApiModule createApiModule(String baseURl, BoutAppPreferences prefs) {
    OkHttpClient client = new OkHttpClient.Builder()
            .addInterceptor(new RequestInterceptor(prefs))
            .build();

    Gson gson = new GsonBuilder()
            .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
            .excludeFieldsWithoutExposeAnnotation()
            .registerTypeAdapterFactory(new InterfaceAdapterFactory())
            .serializeNulls()
            .create();

    Retrofit.Builder builder = new Retrofit.Builder()
            .baseUrl(baseURl)
            .client(client)
            .addConverterFactory(GsonConverterFactory.create(gson));

    API api = builder.build().create(API.class);
    return new ApiModule(api);
}

以下是API调用示例。

@GET("api/feed")
Call<List<FeedElement>> getFeedItems();

正如您所看到的，Retrofit无法反序列化FeedItem，因为它是一个接口。如果我把Call＆gt;相反，它会正常工作。

Answer 1

如果您有很多模型对象，并且想要删除每个模型对象的（反）序列化，则突然您必须编写许多TypeAdapter。

您可以使用Stag库，Stag通过为模型对象自动生成无反射的TypeAdapter来改善Gson性能。

Gson自定义TypeAdapter实现

1 个答案: