Nhận đối tượng JSON lồng nhau với GSON bằng cách sử dụng trang bị thêm

Tôi đang sử dụng một API từ ứng dụng Android của mình và tất cả các phản hồi JSON đều như thế này:

{
    'status': 'OK',
    'reason': 'Everything was fine',
    'content': {
         < some data here >
}

Vấn đề là tất cả các POJO tôi có một status, reasonlĩnh vực, và bên trong contentlĩnh vực là POJO thực tôi muốn.

Có cách nào để tạo bộ chuyển đổi tùy chỉnh của Gson để trích xuất luôn contenttrường, vì vậy việc trang bị thêm trả về POJO đã hết hạn không?

Bạn sẽ viết một trình giải mã tùy chỉnh trả về đối tượng được nhúng.

Giả sử JSON của bạn là:

{
    "status":"OK",
    "reason":"some reason",
    "content" : 
    {
        "foo": 123,
        "bar": "some value"
    }
}

Sau đó, bạn sẽ có một ContentPOJO:

class Content
{
    public int foo;
    public String bar;
}

Sau đó, bạn viết một deserializer:

class MyDeserializer implements JsonDeserializer<Content>
{
    @Override
    public Content deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
        throws JsonParseException
    {
        // Get the "content" element from the parsed JSON
        JsonElement content = je.getAsJsonObject().get("content");

        // Deserialize it. You use a new instance of Gson to avoid infinite recursion
        // to this deserializer
        return new Gson().fromJson(content, Content.class);

    }
}

Bây giờ nếu bạn xây dựng một Gsonvới GsonBuildervà đăng ký bộ giải mã:

Gson gson = 
    new GsonBuilder()
        .registerTypeAdapter(Content.class, new MyDeserializer())
        .create();

Bạn có thể giải mã JSON của mình thẳng tới Content:

Content c = gson.fromJson(myJson, Content.class);

Chỉnh sửa để thêm từ nhận xét:

Nếu bạn có các loại thư khác nhau nhưng tất cả đều có trường "nội dung", bạn có thể đặt Deserializer chung bằng cách:

class MyDeserializer<T> implements JsonDeserializer<T>
{
    @Override
    public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
        throws JsonParseException
    {
        // Get the "content" element from the parsed JSON
        JsonElement content = je.getAsJsonObject().get("content");

        // Deserialize it. You use a new instance of Gson to avoid infinite recursion
        // to this deserializer
        return new Gson().fromJson(content, type);

    }
}

Bạn chỉ cần đăng ký một phiên bản cho từng loại của mình:

Gson gson = 
    new GsonBuilder()
        .registerTypeAdapter(Content.class, new MyDeserializer<Content>())
        .registerTypeAdapter(DiffContent.class, new MyDeserializer<DiffContent>())
        .create();

Khi bạn gọi .fromJson(), kiểu này được đưa vào bộ khử không khí, vì vậy nó sẽ hoạt động với tất cả các kiểu của bạn.

Và cuối cùng khi tạo một phiên bản Retrofit:

Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(url)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();

Giải pháp của @ BrianRoach là giải pháp chính xác. Cần lưu ý rằng trong trường hợp đặc biệt khi bạn có các đối tượng tùy chỉnh lồng nhau mà cả hai đều cần tùy chỉnh TypeAdapter, bạn phải đăng ký phiên TypeAdapterbản mới của GSON , nếu không đối tượng thứ hai TypeAdaptersẽ không bao giờ được gọi. Điều này là do chúng tôi đang tạo một phiên bản mới Gsonbên trong trình giải mã tùy chỉnh của chúng tôi.

Ví dụ: nếu bạn có json sau:

{
    "status": "OK",
    "reason": "some reason",
    "content": {
        "foo": 123,
        "bar": "some value",
        "subcontent": {
            "useless": "field",
            "data": {
                "baz": "values"
            }
        }
    }
}

Và bạn muốn JSON này được ánh xạ tới các đối tượng sau:

class MainContent
{
    public int foo;
    public String bar;
    public SubContent subcontent;
}

class SubContent
{
    public String baz;
}

Bạn sẽ cần phải đăng ký SubContent's TypeAdapter. Để mạnh mẽ hơn, bạn có thể làm như sau:

public class MyDeserializer<T> implements JsonDeserializer<T> {
    private final Class mNestedClazz;
    private final Object mNestedDeserializer;

    public MyDeserializer(Class nestedClazz, Object nestedDeserializer) {
        mNestedClazz = nestedClazz;
        mNestedDeserializer = nestedDeserializer;
    }

    @Override
    public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc) throws JsonParseException {
        // Get the "content" element from the parsed JSON
        JsonElement content = je.getAsJsonObject().get("content");

        // Deserialize it. You use a new instance of Gson to avoid infinite recursion
        // to this deserializer
        GsonBuilder builder = new GsonBuilder();
        if (mNestedClazz != null && mNestedDeserializer != null) {
            builder.registerTypeAdapter(mNestedClazz, mNestedDeserializer);
        }
        return builder.create().fromJson(content, type);

    }
}

và sau đó tạo nó như vậy:

MyDeserializer<Content> myDeserializer = new MyDeserializer<Content>(SubContent.class,
                    new SubContentDeserializer());
Gson gson = new GsonBuilder().registerTypeAdapter(Content.class, myDeserializer).create();

Điều này cũng có thể dễ dàng được sử dụng cho trường hợp "nội dung" lồng nhau bằng cách chỉ cần chuyển vào một trường hợp mới MyDeserializercó giá trị null.

Hơi muộn nhưng hy vọng điều này sẽ giúp ích cho ai đó.

Chỉ cần tạo TypeAdapterFactory sau đây.

    public class ItemTypeAdapterFactory implements TypeAdapterFactory {

      public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {

        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
        final TypeAdapter<JsonElement> elementAdapter = gson.getAdapter(JsonElement.class);

        return new TypeAdapter<T>() {

            public void write(JsonWriter out, T value) throws IOException {
                delegate.write(out, value);
            }

            public T read(JsonReader in) throws IOException {

                JsonElement jsonElement = elementAdapter.read(in);
                if (jsonElement.isJsonObject()) {
                    JsonObject jsonObject = jsonElement.getAsJsonObject();
                    if (jsonObject.has("content")) {
                        jsonElement = jsonObject.get("content");
                    }
                }

                return delegate.fromJsonTree(jsonElement);
            }
        }.nullSafe();
    }
}

và thêm nó vào trình tạo GSON của bạn:

.registerTypeAdapterFactory(new ItemTypeAdapterFactory());

hoặc là

 yourGsonBuilder.registerTypeAdapterFactory(new ItemTypeAdapterFactory());

Đã gặp vấn đề tương tự vài ngày trước. Tôi đã giải quyết vấn đề này bằng cách sử dụng lớp trình bao bọc phản hồi và biến áp RxJava, mà tôi nghĩ là giải pháp khá linh hoạt:

Vỏ bánh:

public class ApiResponse<T> {
    public String status;
    public String reason;
    public T content;
}

Tùy chỉnh ngoại lệ để ném, khi trạng thái không ổn:

public class ApiException extends RuntimeException {
    private final String reason;

    public ApiException(String reason) {
        this.reason = reason;
    }

    public String getReason() {
        return apiError;
    }
}

Máy biến áp Rx:

protected <T> Observable.Transformer<ApiResponse<T>, T> applySchedulersAndExtractData() {
    return observable -> observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .map(tApiResponse -> {
                if (!tApiResponse.status.equals("OK"))
                    throw new ApiException(tApiResponse.reason);
                else
                    return tApiResponse.content;
            });
}

Ví dụ sử dụng:

// Call definition:
@GET("/api/getMyPojo")
Observable<ApiResponse<MyPojo>> getConfig();

// Call invoke:
webservice.getMyPojo()
        .compose(applySchedulersAndExtractData())
        .subscribe(this::handleSuccess, this::handleError);


private void handleSuccess(MyPojo mypojo) {
    // handle success
}

private void handleError(Throwable t) {
    getView().showSnackbar( ((ApiException) throwable).getReason() );
}

Chủ đề của tôi: Trang bị thêm 2 RxJava - Gson - deserialization "Toàn cầu", loại phản hồi thay đổi

Tiếp tục ý tưởng của Brian, vì chúng ta hầu như luôn có nhiều tài nguyên REST, mỗi tài nguyên đều có gốc riêng, nên có thể hữu ích khi khái quát hóa quá trình giải hóa:

 class RestDeserializer<T> implements JsonDeserializer<T> {

    private Class<T> mClass;
    private String mKey;

    public RestDeserializer(Class<T> targetClass, String key) {
        mClass = targetClass;
        mKey = key;
    }

    @Override
    public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
            throws JsonParseException {
        JsonElement content = je.getAsJsonObject().get(mKey);
        return new Gson().fromJson(content, mClass);

    }
}

Sau đó, để phân tích cú pháp trọng tải mẫu từ phía trên, chúng ta có thể đăng ký bộ giải mã GSON:

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Content.class, new RestDeserializer<>(Content.class, "content"))
    .build();

Một giải pháp tốt hơn có thể là ..

public class ApiResponse<T> {
    public T data;
    public String status;
    public String reason;
}

Sau đó, xác định dịch vụ của bạn như thế này ..

Observable<ApiResponse<YourClass>> updateDevice(..);

Theo câu trả lời của @Brian Roach và @rafakob, tôi đã thực hiện việc này theo cách sau

Phản hồi Json từ máy chủ

{
  "status": true,
  "code": 200,
  "message": "Success",
  "data": {
    "fullname": "Rohan",
    "role": 1
  }
}

Lớp xử lý dữ liệu chung

public class ApiResponse<T> {
    @SerializedName("status")
    public boolean status;

    @SerializedName("code")
    public int code;

    @SerializedName("message")
    public String reason;

    @SerializedName("data")
    public T content;
}

Bộ nối tiếp tùy chỉnh

static class MyDeserializer<T> implements JsonDeserializer<T>
{
     @Override
      public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
                    throws JsonParseException
      {
          JsonElement content = je.getAsJsonObject();

          // Deserialize it. You use a new instance of Gson to avoid infinite recursion
          // to this deserializer
          return new Gson().fromJson(content, type);

      }
}

Đối tượng Gson

Gson gson = new GsonBuilder()
                    .registerTypeAdapter(ApiResponse.class, new MyDeserializer<ApiResponse>())
                    .create();

Cuộc gọi api

 @FormUrlEncoded
 @POST("/loginUser")
 Observable<ApiResponse<Profile>> signIn(@Field("email") String username, @Field("password") String password);

restService.signIn(username, password)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Observer<ApiResponse<Profile>>() {
                    @Override
                    public void onCompleted() {
                        Log.i("login", "On complete");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.i("login", e.toString());
                    }

                    @Override
                    public void onNext(ApiResponse<Profile> response) {
                         Profile profile= response.content;
                         Log.i("login", profile.getFullname());
                    }
                });

Đây là giải pháp tương tự như @AYarulin nhưng giả sử tên lớp là tên khóa JSON. Bằng cách này, bạn chỉ cần nhập tên Lớp.

 class RestDeserializer<T> implements JsonDeserializer<T> {

    private Class<T> mClass;
    private String mKey;

    public RestDeserializer(Class<T> targetClass) {
        mClass = targetClass;
        mKey = mClass.getSimpleName();
    }

    @Override
    public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
            throws JsonParseException {
        JsonElement content = je.getAsJsonObject().get(mKey);
        return new Gson().fromJson(content, mClass);

    }
}

Sau đó, để phân tích cú pháp trọng tải mẫu từ phía trên, chúng ta có thể đăng ký bộ giải mã GSON. Điều này có vấn đề vì Khóa phân biệt chữ hoa chữ thường, vì vậy trường hợp của tên lớp phải khớp với trường hợp của khóa JSON.

Gson gson = new GsonBuilder()
.registerTypeAdapter(Content.class, new RestDeserializer<>(Content.class))
.build();

Đây là phiên bản Kotlin dựa trên câu trả lời của Brian Roach và AYarulin.

class RestDeserializer<T>(targetClass: Class<T>, key: String?) : JsonDeserializer<T> {
    val targetClass = targetClass
    val key = key

    override fun deserialize(json: JsonElement?, typeOfT: Type?, context: JsonDeserializationContext?): T {
        val data = json!!.asJsonObject.get(key ?: "")

        return Gson().fromJson(data, targetClass)
    }
}

Trong trường hợp của tôi, khóa "nội dung" sẽ thay đổi cho mỗi phản hồi. Thí dụ:

// Root is hotel
{
  status : "ok",
  statusCode : 200,
  hotels : [{
    name : "Taj Palace",
    location : {
      lat : 12
      lng : 77
    }

  }, {
    name : "Plaza", 
    location : {
      lat : 12
      lng : 77
    }
  }]
}

//Root is city

{
  status : "ok",
  statusCode : 200,
  city : {
    name : "Vegas",
    location : {
      lat : 12
      lng : 77
    }
}

Trong những trường hợp như vậy, tôi đã sử dụng một giải pháp tương tự như được liệt kê ở trên nhưng phải tinh chỉnh nó. Bạn có thể xem ý chính ở đây . Nó hơi quá lớn để đăng nó ở đây trên SOF.

Chú thích @InnerKey("content")được sử dụng và phần còn lại của mã là để hỗ trợ việc sử dụng nó với Gson.

Đừng quên @SerializedNamevà @Exposechú thích cho tất cả các thành viên Lớp học và thành viên Lớp học Nội bộ được GSON gỡ bỏ nhiều nhất từ ​​JSON bởi GSON.

Xem tại https://stackoverflow.com/a/40239512/1676736

Một giải pháp đơn giản khác:

JsonObject parsed = (JsonObject) new JsonParser().parse(jsonString);
Content content = gson.fromJson(parsed.get("content"), Content.class);