Obtenez un objet JSON imbriqué avec GSON à l'aide de la modernisation

Je consomme une API de mon application Android, et toutes les réponses JSON sont comme ceci:

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

Le problème est que tous mes POJO ont un status, les reasonchamps, et à l' intérieur du contentchamp est le vrai POJO je veux.

Existe-t-il un moyen de créer un convertisseur personnalisé de Gson pour extraire toujours le contentchamp, de sorte que la mise à niveau renvoie le POJO approprié?

Vous écririez un désérialiseur personnalisé qui renvoie l'objet incorporé.

Disons que votre JSON est:

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

Vous auriez alors un ContentPOJO:

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

Ensuite, vous écrivez un désérialiseur:

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);

    }
}

Maintenant, si vous construisez un Gsonwith GsonBuilderet enregistrez le désérialiseur:

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

Vous pouvez désérialiser votre JSON directement dans votre Content:

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

Modifier pour ajouter à partir des commentaires:

Si vous avez différents types de messages mais qu'ils ont tous le champ «contenu», vous pouvez rendre le désérialiseur générique en faisant:

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);

    }
}

Il vous suffit d'enregistrer une instance pour chacun de vos types:

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

Lorsque vous appelez, .fromJson()le type est transporté dans le désérialiseur, il devrait donc fonctionner pour tous vos types.

Et enfin lors de la création d'une instance Retrofit:

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

La solution de @ BrianRoach est la bonne solution. Il est à noter que dans le cas particulier où vous avez des objets personnalisés imbriqués qui ont tous deux besoin d'une personnalisation TypeAdapter, vous devez enregistrer le TypeAdapteravec la nouvelle instance de GSON , sinon la seconde TypeAdapterne sera jamais appelée. C'est parce que nous créons une nouvelle Gsoninstance dans notre désérialiseur personnalisé.

Par exemple, si vous aviez le json suivant:

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

Et vous vouliez que ce JSON soit mappé aux objets suivants:

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

class SubContent
{
    public String baz;
}

Vous devrez enregistrer les SubContentfichiers TypeAdapter. Pour être plus robuste, vous pouvez effectuer les opérations suivantes:

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);

    }
}

puis créez-le comme ceci:

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

Cela pourrait facilement être utilisé pour le cas "contenu" imbriqué en passant simplement une nouvelle instance de MyDeserializeravec des valeurs nulles.

Un peu tard mais j'espère que cela aidera quelqu'un.

Créez simplement TypeAdapterFactory suivant.

    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();
    }
}

et ajoutez-le dans votre générateur GSON:

.registerTypeAdapterFactory(new ItemTypeAdapterFactory());

ou

 yourGsonBuilder.registerTypeAdapterFactory(new ItemTypeAdapterFactory());

J'ai eu le même problème il y a quelques jours. J'ai résolu cela en utilisant la classe de wrapper de réponse et le transformateur RxJava, ce qui, à mon avis, est une solution assez flexible:

Emballage:

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

Exception personnalisée à lever, lorsque l'état n'est pas OK:

public class ApiException extends RuntimeException {
    private final String reason;

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

    public String getReason() {
        return apiError;
    }
}

Transformateur 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;
            });
}

Exemple d'utilisation:

// 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() );
}

Mon sujet: Retrofit 2 RxJava - Gson - Désérialisation "globale", changement de type de réponse

Poursuivant l'idée de Brian, car nous avons presque toujours de nombreuses ressources REST, chacune avec sa propre racine, il pourrait être utile de généraliser la désérialisation:

 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);

    }
}

Ensuite, pour analyser l'exemple de charge utile ci-dessus, nous pouvons enregistrer le désérialiseur GSON:

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

Une meilleure solution pourrait être celle-ci.

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

Ensuite, définissez votre service comme ceci.

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

Selon la réponse de @Brian Roach et @rafakob, je l'ai fait de la manière suivante

Réponse Json du serveur

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

Classe de gestionnaire de données commune

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

    @SerializedName("code")
    public int code;

    @SerializedName("message")
    public String reason;

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

Sérialiseur personnalisé

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);

      }
}

Objet Gson

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

Appel 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());
                    }
                });

C'est la même solution que @AYarulin mais supposons que le nom de classe est le nom de la clé JSON. De cette façon, il vous suffit de transmettre le nom de la classe.

 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);

    }
}

Ensuite, pour analyser l'exemple de charge utile ci-dessus, nous pouvons enregistrer le désérialiseur GSON. Ceci est problématique car la clé est sensible à la casse, donc la casse du nom de classe doit correspondre à la casse de la clé JSON.

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

Voici une version Kotlin basée sur les réponses de Brian Roach et 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)
    }
}

Dans mon cas, la clé "contenu" changerait pour chaque réponse. Exemple:

// 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
    }
}

Dans de tels cas, j'ai utilisé une solution similaire à celle indiquée ci-dessus, mais j'ai dû la modifier. Vous pouvez voir l'essentiel ici . C'est un peu trop grand pour le publier ici sur SOF.

L'annotation @InnerKey("content")est utilisée et le reste du code sert à faciliter son utilisation avec Gson.

Ne pas oublier @SerializedNameet @Exposeannotations pour tous les membres de classe et membres de classe interne que la plupart désérialisés de JSON par GSON.

Regardez https://stackoverflow.com/a/40239512/1676736

Une autre solution simple:

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