GSON：序列化/反序列化具有注册类型层次结构适配器的类的对象，使用ReflectiveTypeAdapterFactory.Adapter [英] GSON: serialize/deserialize object of class, that have registered type hierarchy adapter, using ReflectiveTypeAdapterFactory.Adapter

问题描述

$ b

 界面A {
 boolean isSomeCase（）; 
} 
 
类AAdapter实现了JsonSerializer< A> {
 public JsonElement serialize（A src，Type typeOfSrc，JsonSerializationContext context）{
 if（src.isSomeCase（））{
 / *某些逻辑* / 
返回结果; 
} else {
 JsonObject json = new JsonObject（）; 
 JsonElement valueJson =< ???>; // TODO序列化src，像POJO 
 json.add（src.getClass（）。getSimpleName（），valueJson）; 
返回json; 
 
 
 
 $ b Gson gson = new GsonBuilder（）
 .registerTypeHierarchyAdapter（A.class。new AAdapter（））
 。创建（）; 
  

如何实现 A isSomeCase（） = false ，它由 ReflectiveTypeAdapterFactory.Adapter 。

解决方案

您可以编写自定义的 TypeAdapterFactory 并处理传入对象的 isSomeCase（）会导致其 TypeAdapter 的 write（）方法并在那里应用您的逻辑：



  public class ATypeAdapterFactory implements TypeAdapterFactory {
 
 public TypeAdapter< A>创建（Gson gson，TypeToken类型）{
 if（！A.class.isAssignableFrom（type.getRawType（）））{
 //检查传入的原始类型是否是A接口的一个实例
返回null; 
} 
 
最终TypeAdapter< A> delegate = gson.getDelegateAdapter（this，type）; 
 
返回新的TypeAdapter< A>（）{
 
 @Override 
 public void write（JsonWriter out，A value）抛出IOException {
 if（ value.isSomeCase（））{
 //你的定制逻辑
 out.beginObject（）; 
 out.name（x）。value（0）; 
 out.endObject（）; 
} else {
 //默认序列化在这里
 delegate.write（out，value）; 
} 
} 
 
 @Override 
 public read（JsonReader in）抛出IOException {
 return delegate.read（in）; 
} 
}; 
 
 
  

测试：

  final GsonBuilder gsonBuilder = new GsonBuilder（）; 
 //注册自定义类型适配器工厂
 gsonBuilder.registerTypeAdapterFactory（new ATypeAdapterFactory（））; 
 final Gson gson = gsonBuilder.create（）; 
 
 a aSomeCaseTrue = new AImpl（true）; 
 System.out.print（aSomeCaseTrue：+ gson.toJson（aSomeCaseTrue））; 
 //写入; aSomeCaseTrue：{x：0} 
 
 
 aSomeCaseFalse = new AImpl（false）; 
 System.out.print（aSomeCaseFalse：+ gson.toJson（aSomeCaseFalse）;）; 
 //写入; aSomeCaseFalse：{someCase：false} 
  

其他：

1）您的界面：

 界面A {
 boolean isSomeCase （）; 
 
 $ / code> 

2）一个实现你的示例接口的样例类：



  class AImpl implements A {
 boolean someCase; 
 
 public AImpl（布尔值）{
 this.someCase = value; 
} 
 
 @Override 
 public boolean isSomeCase（）{
 return someCase; 
} 
} 
  




To be clear, let introduse some model:

interface A {
    boolean isSomeCase();
}

class AAdapter implements JsonSerializer<A> {
    public JsonElement serialize(A src, Type typeOfSrc, JsonSerializationContext context) {
        if (src.isSomeCase()) {
            /* some logic */
            return result;
        } else {
            JsonObject json = new JsonObject();
            JsonElement valueJson = <???>; // TODO serialize src like POJO
            json.add(src.getClass().getSimpleName(), valueJson);
            return json;
        } 
    }
}

Gson gson = new GsonBuilder()
        .registerTypeHierarchyAdapter(A.class. new AAdapter())
        .create();

How it is possible to serealize some instance of A, which isSomeCase() = false, like any other object, that is serialized by ReflectiveTypeAdapterFactory.Adapter.

解决方案

You can write a custom TypeAdapterFactory and handle incoming object's isSomeCase() result in its TypeAdapter's write() method and apply your logic there:

public class ATypeAdapterFactory implements TypeAdapterFactory {

    public TypeAdapter<A> create(Gson gson, TypeToken type) {
        if (!A.class.isAssignableFrom(type.getRawType())) {
            // Check if incoming raw type is an instance of A interface
            return null;
        } 

        final TypeAdapter<A> delegate = gson.getDelegateAdapter(this, type);

        return new TypeAdapter<A>() {

            @Override
            public void write(JsonWriter out, A value) throws IOException {
                if(value.isSomeCase()) {
                    // your custom logic here
                    out.beginObject();
                    out.name("x").value(0);
                    out.endObject();
                } else {
                    // default serialization here
                    delegate.write(out, value);
                }
            }

            @Override
            public A read(JsonReader in) throws IOException {
                return delegate.read(in);
            }
        };
    }
}

Test:

final GsonBuilder gsonBuilder = new GsonBuilder();
// Register custom type adapter factory
gsonBuilder.registerTypeAdapterFactory(new ATypeAdapterFactory());
final Gson gson = gsonBuilder.create();

A aSomeCaseTrue = new AImpl(true);
System.out.print("aSomeCaseTrue:" + gson.toJson(aSomeCaseTrue));
// writes; aSomeCaseTrue:{"x":0}


A aSomeCaseFalse = new AImpl(false);
System.out.print("aSomeCaseFalse:" + gson.toJson(aSomeCaseFalse););
// writes; aSomeCaseFalse:{"someCase":false}

Extras:

1) Your interface:

interface A {
    boolean isSomeCase();
}

2) A sample class which implements your sample interface:

class AImpl implements A {
    boolean someCase;

    public AImpl(boolean value) {
        this.someCase = value;
    }

    @Override
    public boolean isSomeCase() {
        return someCase;
    }
}

这篇关于GSON：序列化/反序列化具有注册类型层次结构适配器的类的对象，使用ReflectiveTypeAdapterFactory.Adapter的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！