GSON TypeAdapter：基于“type”字段反序列化多态对象

Question

class BaseTypeDeserializer implements JsonDeserializer<BaseType> {
    private static final String TYPE_FIELD = "type";

    @Override
    public BaseType deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json.isJsonObject() && json.getAsJsonObject().has(TYPE_FIELD)) {
            JsonObject jsonObject = json.getAsJsonObject();
            final String type = jsonObject.get(TYPE_FIELD).getAsString();
            if ("type_a".equals(type)) {
                return context.deserialize(json, AType.class);
            } else if ("type_b".equals(type)) {
                return context.deserialize(json, BType.class);
            } ...

            // If you need to deserialize as BaseType,
            // deserialize without the current context
            // or you will infinite loop
            return new Gson().fromJson(json, typeOfT);

        } else {
            // Return a blank object on error
            return new BaseType();
        }
    }
}

这里有人知道如何使用TypeAdapterFactory基于“type”字段进行反序列化而不需要将整个json流读取到JsonElement对象树中吗？

Answer 1

>

只有当反序列化数据中有baseType或子类时，才应运行自定义反序列化程序，而不是每个请求。您根据类型注册它，并且只有当gson需要序列化该类型时才调用它。

您是否反序列化baseType以及子类？如果是这样，这一行会影响你的表现--

返回new Gson().fromjson(json，typeOfT)；

如果您的子类相似，并且它们之间没有任何字段冲突（字段名称相同但类型不同），则可以使用包含所有字段的data transfer对象。使用gson对其进行反序列化，然后使用它创建对象。

public class MyDTO {
   String type;
   // Fields from BaseType
   String fromBase;
   // Fields from TypeA
   String fromA;
   // Fields from TypeB
   // ...
}


public class BaseType {
  String type;
  String fromBase;

  public BaseType(MyDTO dto) {
    type = dto.type;
    fromBase = dto.fromBase;
  }
}

public class TypeA extends BaseType {
  String fromA;

  public TypeA(MyDTO dto) {
    super(dto);
    fromA = dto.fromA;
  }
}

然后，您可以创建typeadapterFactory，该typeadapterFactory处理从DTO到对象的转换-

public class BaseTypeAdapterFactory implements TypeAdapterFactory {

  public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {
    if(BaseType.class.isAssignableFrom(type.getRawType())) {
      TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
      return newItemAdapter((TypeAdapter<BaseType>) delegate,
          gson.getAdapter(new TypeToken<MyDTO>(){}));
    } else {
      return null;
    }
  }

  private TypeAdapter newItemAdapter(
      final TypeAdapter<BaseType> delagateAdapter,
      final TypeAdapter<MyDTO> dtoAdapter) {
    return new TypeAdapter<BaseType>() {

      @Override
      public void write(JsonWriter out, BaseType value) throws IOException {
        delagateAdapter.write(out, value);
      }

      @Override
      public BaseType read(JsonReader in) throws IOException {
        MyDTO dto = dtoAdapter.read(in);
        if("base".equals(dto.type)) {
          return new BaseType(dto);
        } else if ("type_a".equals(dto.type)) {
          return new TypeA(dto);
        } else {
          return null;
        }
      }
    };
  }
}

像这样使用--

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

BaseType base = gson.fromJson(baseString, BaseType.class);