Gson seralizador personalizado para uma variável (de muitas) em um objeto usando TypeAdapter

Já vi muitos exemplos simples de como usar um TypeAdapter personalizado. O mais útil foi Class TypeAdapter<T>. Mas isso ainda não respondeu à minha pergunta.

Quero personalizar a serialização de um único campo no objeto e deixar que o mecanismo Gson padrão cuide do resto.

Para fins de discussão, podemos usar essa definição de classe como a classe do objeto que desejo serializar. Quero deixar Gson serializar os dois primeiros membros da classe, bem como todos os membros expostos da classe base, e quero fazer a serialização customizada para o terceiro e último membro da classe mostrado abaixo.

public class MyClass extends SomeClass {

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

Esta é uma ótima pergunta porque isola algo que deveria ser fácil, mas na verdade requer muito código.

Para começar, escreva um resumo TypeAdapterFactoryque forneça ganchos para modificar os dados de saída. Este exemplo usa uma nova API em Gson 2.2 chamada getDelegateAdapter()que permite que você procure o adaptador que Gson usaria por padrão. Os adaptadores delegados são extremamente úteis se você deseja apenas ajustar o comportamento padrão. E, ao contrário dos adaptadores de tipo totalmente personalizados, eles ficarão atualizados automaticamente conforme você adiciona e remove campos.

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) {
  }
}

A classe acima usa a serialização padrão para obter uma árvore JSON (representada por JsonElement) e, em seguida, chama o método de gancho beforeWrite()para permitir que a subclasse personalize essa árvore. Da mesma forma para desserialização com afterRead().

Em seguida, criamos uma subclasse para o MyClassexemplo específico . Para ilustrar, adicionarei uma propriedade sintética chamada 'size' ao mapa quando ele for serializado. E para simetria, removerei quando for desserializado. Na prática, isso pode ser qualquer personalização.

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

Por fim, reúna tudo criando uma Gsoninstância personalizada que usa o novo adaptador de tipo:

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

Novos do Gson TypeAdapter e TypeAdapterFactory tipos são extremamente poderosos, mas eles também são abstrato e levar a prática de usar de forma eficaz. Espero que você ache este exemplo útil!

Há outra abordagem para isso. Como Jesse Wilson disse, isso deveria ser fácil. E adivinhe, é fácil!

Se você implementar JsonSerializere JsonDeserializerpara o seu tipo, poderá lidar com as partes que deseja e delegar ao Gson para todo o resto , com muito pouco código. Estou citando a resposta de @Perception sobre outra questão abaixo por conveniência, veja essa resposta para mais detalhes:

Nesse caso, é melhor usar a JsonSerializerem vez de a TypeAdapter, pela simples razão de que os serializadores têm acesso ao seu contexto de serialização.

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

A principal vantagem disso (além de evitar soluções alternativas complicadas) é que você ainda pode aproveitar outros tipos de adaptadores e serializadores personalizados que podem ter sido registrados no contexto principal. Observe que o registro de serializadores e adaptadores usa exatamente o mesmo código.

No entanto, reconhecerei que a abordagem de Jesse parece melhor se você for modificar campos em seu objeto Java com frequência. É uma troca entre facilidade de uso e flexibilidade, faça a sua escolha.

Meu colega também mencionou o uso da @JsonAdapteranotação

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

A página foi movida para aqui: https://www.javadoc.io/doc/com.google.code.gson/gson/latest/com.google.gson/com/google/gson/annotations/JsonAdapter.html

Exemplo:

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