Seralizer personnalisé de Gson pour une variable (parmi plusieurs) dans un objet en utilisant TypeAdapter

Question

J'ai vu de nombreux exemples simples d'utilisation d'un TypeAdapter personnalisé. Le plus utile a été Class TypeAdapter<T> . Mais cela n'a pas encore répondu à ma question.

Je veux personnaliser la sérialisation d'un seul champ de l'objet et laisser le mécanisme Gson par défaut s'occuper du reste.

Pour les besoins de la discussion, nous pouvons utiliser cette définition de classe comme la classe de l'objet que je souhaite sérialiser. Je veux laisser Gson sérialiser les deux premiers membres de classe ainsi que tous les membres exposés de la classe de base, et je veux faire une sérialisation personnalisée pour le 3ème et dernier membre de classe montré ci-dessous.

public class MyClass extends SomeClass {

@Expose private HashMap<String, MyObject1> lists;
@Expose private HashMap<String, MyObject2> sources;
private LinkedHashMap<String, SomeClass> customSerializeThis;
    [snip]
}

Answer 1

C'est une excellente question car elle permet d'isoler quelque chose qui devrait être facile mais qui nécessite en fait beaucoup de code.

Pour commencer, écrivez un résumé TypeAdapterFactory qui vous donne des crochets pour modifier les données sortantes. Cet exemple utilise une nouvelle API dans Gson 2.2 appelée getDelegateAdapter() qui vous permet de rechercher l'adaptateur que Gson utilise par défaut. Les adaptateurs de délégués sont extrêmement pratiques si vous souhaitez simplement modifier le comportement standard. Et contrairement aux adaptateurs de types personnalisés complets, ils seront mis à jour automatiquement lorsque vous ajouterez ou supprimerez des champs.

public abstract class CustomizedTypeAdapterFactory<C>
    implements TypeAdapterFactory {
  private final Class<C> customizedClass;

  public CustomizedTypeAdapterFactory(Class<C> customizedClass) {
    this.customizedClass = customizedClass;
  }

  @SuppressWarnings("unchecked") // we use a runtime check to guarantee that 'C' and 'T' are equal
  public final <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    return type.getRawType() == customizedClass
        ? (TypeAdapter<T>) customizeMyClassAdapter(gson, (TypeToken<C>) type)
        : null;
  }

  private TypeAdapter<C> customizeMyClassAdapter(Gson gson, TypeToken<C> type) {
    final TypeAdapter<C> delegate = gson.getDelegateAdapter(this, type);
    final TypeAdapter<JsonElement> elementAdapter = gson.getAdapter(JsonElement.class);
    return new TypeAdapter<C>() {
      @Override public void write(JsonWriter out, C value) throws IOException {
        JsonElement tree = delegate.toJsonTree(value);
        beforeWrite(value, tree);
        elementAdapter.write(out, tree);
      }
      @Override public C read(JsonReader in) throws IOException {
        JsonElement tree = elementAdapter.read(in);
        afterRead(tree);
        return delegate.fromJsonTree(tree);
      }
    };
  }

  /**
   * Override this to muck with {@code toSerialize} before it is written to
   * the outgoing JSON stream.
   */
  protected void beforeWrite(C source, JsonElement toSerialize) {
  }

  /**
   * Override this to muck with {@code deserialized} before it parsed into
   * the application type.
   */
  protected void afterRead(JsonElement deserialized) {
  }
}

La classe ci-dessus utilise la sérialisation par défaut pour obtenir un arbre JSON (représenté par JsonElement ), puis appelle la méthode hook beforeWrite() pour permettre à la sous-classe de personnaliser cet arbre. De même pour la désérialisation avec afterRead() .

Ensuite, nous le sous-classons pour le MyClass exemple. Pour illustrer, je vais ajouter une propriété synthétique appelée "size" à la carte lorsqu'elle est sérialisée. Et par symétrie, je la supprime lorsqu'elle est désérialisée. En pratique, cela peut être n'importe quelle personnalisation.

private class MyClassTypeAdapterFactory extends CustomizedTypeAdapterFactory<MyClass> {
  private MyClassTypeAdapterFactory() {
    super(MyClass.class);
  }

  @Override protected void beforeWrite(MyClass source, JsonElement toSerialize) {
    JsonObject custom = toSerialize.getAsJsonObject().get("custom").getAsJsonObject();
    custom.add("size", new JsonPrimitive(custom.entrySet().size()));
  }

  @Override protected void afterRead(JsonElement deserialized) {
    JsonObject custom = deserialized.getAsJsonObject().get("custom").getAsJsonObject();
    custom.remove("size");
  }
}

Enfin, pour mettre tout cela en place, créez un Gson qui utilise le nouvel adaptateur de type :

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(new MyClassTypeAdapterFactory())
    .create();

La nouvelle de Gson Adaptateur de type y TypeAdapterFactory Les types sont extrêmement puissants, mais ils sont aussi abstraits et il faut de la pratique pour les utiliser efficacement. Nous espérons que cet exemple vous sera utile !

Answer 2

Il y a une autre approche à cela. Comme le dit Jesse Wilson, c'est censé être facile. Et devinez quoi, c'est es facile !

Si vous mettez en œuvre JsonSerializer y JsonDeserializer pour votre type, vous pouvez gérer les parties que vous voulez et déléguer à Gson pour tout le reste avec très peu de code. Je cite La réponse de @Perception sur une autre question ci-dessous pour plus de commodité, voir cette réponse pour plus de détails :

Dans ce cas, il est préférable d'utiliser un JsonSerializer par opposition à un TypeAdapter pour la simple raison que les sérialiseurs ont accès à leur contexte de sérialisation.

public class PairSerializer implements JsonSerializer<Pair> {
    @Override
    public JsonElement serialize(final Pair value, final Type type,
            final JsonSerializationContext context) {
        final JsonObject jsonObj = new JsonObject();
        jsonObj.add("first", context.serialize(value.getFirst()));
        jsonObj.add("second", context.serialize(value.getSecond()));
        return jsonObj;
    }
}

Le principal avantage de cette méthode (hormis le fait d'éviter les solutions de contournement compliquées) est que vous pouvez toujours profiter des autres adaptateurs de type et des sérialiseurs personnalisés qui ont pu être enregistrés dans le contexte principal. Notez que l'enregistrement des sérialiseurs et des adaptateurs utilise exactement le même code.

Cependant, je reconnais que l'approche de Jesse semble meilleure si vous devez fréquemment modifier des champs dans votre objet Java. C'est un compromis entre la facilité d'utilisation et la flexibilité, à vous de choisir.

Answer 3

Mon collègue a également mentionné l'utilisation de la @JsonAdapter annotation

https://google.github.io/gson/apidocs/com/google/gson/annotations/JsonAdapter.html

La page a été déplacée ici : https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/annotations/JsonAdapter.html

Exemple :

 private static final class Gadget {
   @JsonAdapter(UserJsonAdapter2.class)
   final User user;
   Gadget(User user) {
       this.user = user;
   }
 }