web-dev-qa-db-ja.com

Gsonはポリモーフィックオブジェクトのリストをシリアル化します

ポリモーフィズムを含むオブジェクトをGsonを使用してJSONにシリアライズ/デシリアライズしようとしています。

これはシリアル化のための私のコードです：

ObixBaseObj lobbyObj = new ObixBaseObj();
lobbyObj.setIs("obix:Lobby");

ObixOp batchOp = new ObixOp();
batchOp.setName("batch");
batchOp.setIn("obix:BatchIn");
batchOp.setOut("obix:BatchOut");

lobbyObj.addChild(batchOp);

Gson gson = new Gson();
System.out.println(gson.toJson(lobbyObj));

結果は次のとおりです。

 {"obix":"obj","is":"obix:Lobby","children":[{"obix":"op","name":"batch"}]}

継承されたメンバー（特にobix:BatchInおよびobixBatchout文字列が欠落しています）。これが私の基本クラスです。

public class ObixBaseObj  {
    protected String obix;
    private String display;
    private String displayName;
    private ArrayList<ObixBaseObj> children;

    public ObixBaseObj()
    {
        obix = "obj";
    }

    public void setName(String name) {
        this.name = name;
    }
        ...
}

継承されたクラス（ObixOp）は次のようになります。

public class ObixOp extends ObixBaseObj {
    private String in;
    private String out;

    public ObixOp() {
        obix = "op";
    }
    public ObixOp(String in, String out) {
        obix = "op";
        this.in = in;
        this.out = out;
    }
    public String getIn() {
        return in;
    }
    public void setIn(String in) {
        this.in = in;
    }
    public String getOut() {
        return out;
    }
    public void setOut(String out) {
        this.out = out;
    }
}

私はこれにアダプターを使用できることを認識していますが、問題は、基本クラス型ObixBaseObjのコレクションをシリアル化することです。これを継承するクラスは約25個あります。この作業をエレガントにするにはどうすればよいですか？

javajsonserializationgson
42
l46kok

カスタムシリアライザー/デシリアライザーが先に進む唯一の方法であると思います。私が見つけた最もコンパクトな方法を実現するために、私はあなたに提案しようとしました。クラスを使用していないことをおizeびしますが、考え方は同じです（少なくとも1つの基本クラスと2つの拡張クラスが必要でした）。

BaseClass.Java

public class BaseClass{

    @Override
    public String toString() {
        return "BaseClass [list=" + list + ", isA=" + isA + ", x=" + x + "]";
    }

    public ArrayList<BaseClass> list = new ArrayList<BaseClass>();

    protected String isA="BaseClass"; 
    public int x;

 }

ExtendedClass1.Java

public class ExtendedClass1 extends BaseClass{

    @Override
    public String toString() {
       return "ExtendedClass1 [total=" + total + ", number=" + number
            + ", list=" + list + ", isA=" + isA + ", x=" + x + "]";
    }

    public ExtendedClass1(){
        isA = "ExtendedClass1";
    }

    public Long total;
    public Long number;

}

ExtendedClass2.Java

public class ExtendedClass2 extends BaseClass{

    @Override
    public String toString() {
      return "ExtendedClass2 [total=" + total + ", list=" + list + ", isA="
            + isA + ", x=" + x + "]";
    }

    public ExtendedClass2(){
        isA = "ExtendedClass2";
    }

    public Long total;

}

CustomDeserializer.Java

public class CustomDeserializer implements JsonDeserializer<List<BaseClass>> {

    private static Map<String, Class> map = new TreeMap<String, Class>();

    static {
        map.put("BaseClass", BaseClass.class);
        map.put("ExtendedClass1", ExtendedClass1.class);
        map.put("ExtendedClass2", ExtendedClass2.class);
    }

    public List<BaseClass> deserialize(JsonElement json, Type typeOfT,
            JsonDeserializationContext context) throws JsonParseException {

        List list = new ArrayList<BaseClass>();
        JsonArray ja = json.getAsJsonArray();

        for (JsonElement je : ja) {

            String type = je.getAsJsonObject().get("isA").getAsString();
            Class c = map.get(type);
            if (c == null)
                throw new RuntimeException("Unknow class: " + type);
            list.add(context.deserialize(je, c));
        }

        return list;

    }

}

CustomSerializer.Java

public class CustomSerializer implements JsonSerializer<ArrayList<BaseClass>> {

    private static Map<String, Class> map = new TreeMap<String, Class>();

    static {
        map.put("BaseClass", BaseClass.class);
        map.put("ExtendedClass1", ExtendedClass1.class);
        map.put("ExtendedClass2", ExtendedClass2.class);
    }

    @Override
    public JsonElement serialize(ArrayList<BaseClass> src, Type typeOfSrc,
            JsonSerializationContext context) {
        if (src == null)
            return null;
        else {
            JsonArray ja = new JsonArray();
            for (BaseClass bc : src) {
                Class c = map.get(bc.isA);
                if (c == null)
                    throw new RuntimeException("Unknow class: " + bc.isA);
                ja.add(context.serialize(bc, c));

            }
            return ja;
        }
    }
}

そして今、これはすべてをテストするために実行したコードです：

public static void main(String[] args) {

  BaseClass c1 = new BaseClass();
  ExtendedClass1 e1 = new ExtendedClass1();
  e1.total = 100L;
  e1.number = 5L;
  ExtendedClass2 e2 = new ExtendedClass2();
  e2.total = 200L;
  e2.x = 5;
  BaseClass c2 = new BaseClass();

  c1.list.add(e1);
  c1.list.add(e2);
  c1.list.add(c2);


  List<BaseClass> al = new ArrayList<BaseClass>();

  // this is the instance of BaseClass before serialization
  System.out.println(c1);

  GsonBuilder gb = new GsonBuilder();

  gb.registerTypeAdapter(al.getClass(), new CustomDeserializer());
  gb.registerTypeAdapter(al.getClass(), new CustomSerializer());
  Gson gson = gb.create();

  String json = gson.toJson(c1);
  // this is the corresponding json
  System.out.println(json);

  BaseClass newC1 = gson.fromJson(json, BaseClass.class);

  System.out.println(newC1);

}

これは私の実行です：

BaseClass [list=[ExtendedClass1 [total=100, number=5, list=[], isA=ExtendedClass1, x=0], ExtendedClass2 [total=200, list=[], isA=ExtendedClass2, x=5], BaseClass [list=[], isA=BaseClass, x=0]], isA=BaseClass, x=0]
{"list":[{"total":100,"number":5,"list":[],"isA":"ExtendedClass1","x":0},{"total":200,"list":[],"isA":"ExtendedClass2","x":5},{"list":[],"isA":"BaseClass","x":0}],"isA":"BaseClass","x":0}
BaseClass [list=[ExtendedClass1 [total=100, number=5, list=[], isA=ExtendedClass1, x=0], ExtendedClass2 [total=200, list=[], isA=ExtendedClass2, x=5], BaseClass [list=[], isA=BaseClass, x=0]], isA=BaseClass, x=0]

いくつかの説明：トリックはシリアライザー/デシリアライザー内の別のGsonによって行われます。 isAフィールドだけを使用して適切なクラスを見つけます。高速化するために、マップを使用してisA文字列を対応するクラスに関連付けます。次に、2番目のGsonオブジェクトを使用して適切なシリアル化/逆シリアル化を行います。 Gsonの複数の割り当てによるシリアル化/逆シリアル化を遅くしないように、静的と宣言しました。

Pro実際にはこれ以上のコードを書くことはなく、Gsonにすべての仕事をさせます。新しいサブクラスをマップに入れることを忘れないでください（例外はそのことを思い出させます）。

短所 2つのマップがあります。私の実装は、マップの重複を避けるために少し改良できると思いますが、私はそれらをあなた（または、もしあれば、将来のエディター）に任せました。

シリアライゼーションとデシリアライゼーションを一意のオブジェクトに統合したい場合は、TypeAdapterクラスを確認するか、両方のインターフェイスを実装するオブジェクトを試してください。

41
giampaolo

簡単な解決策があります： GsonのRuntimeTypeAdapterFactory （from _com.google.code.gson:gson-extras:$gsonVersion_）。シリアライザーを作成する必要はありません。このクラスはすべて機能します。あなたのコードでこれを試してください：

_    ObixBaseObj lobbyObj = new ObixBaseObj();
    lobbyObj.setIs("obix:Lobby");

    ObixOp batchOp = new ObixOp();
    batchOp.setName("batch");
    batchOp.setIn("obix:BatchIn");
    batchOp.setOut("obix:BatchOut");

    lobbyObj.addChild(batchOp);

    RuntimeTypeAdapterFactory<ObixBaseObj> adapter = 
                    RuntimeTypeAdapterFactory
                   .of(ObixBaseObj.class)
                   .registerSubtype(ObixBaseObj.class)
                   .registerSubtype(ObixOp.class);


    Gson gson2=new GsonBuilder().setPrettyPrinting().registerTypeAdapterFactory(adapter).create();
    Gson gson = new Gson();
    System.out.println(gson.toJson(lobbyObj));
    System.out.println("---------------------");
    System.out.println(gson2.toJson(lobbyObj));

}
_

出力：

_{"obix":"obj","is":"obix:Lobby","children":[{"obix":"op","name":"batch","children":[]}]}
---------------------
{
  "type": "ObixBaseObj",
  "obix": "obj",
  "is": "obix:Lobby",
  "children": [
    {
      "type": "ObixOp",
      "in": "obix:BatchIn",
      "out": "obix:BatchOut",
      "obix": "op",
      "name": "batch",
      "children": []
    }
  ]
}
_

EDIT：より良い作業例。

ObixBaseObjから継承する約25のクラスがあるとおっしゃいました。

GsonUtilsという新しいクラスの作成を開始します

_public class GsonUtils {

    private static final GsonBuilder gsonBuilder = new GsonBuilder()
            .setPrettyPrinting();

    public static void registerType(
            RuntimeTypeAdapterFactory<?> adapter) {
        gsonBuilder.registerTypeAdapterFactory(adapter);
    }

    public static Gson getGson() {
        return gsonBuilder.create();
    }
_

Gsonオブジェクトが必要になるたびに、new Gson()を呼び出す代わりに、

_GsonUtils.getGson()
_

このコードをObixBaseObjに追加します。

_public class ObixBaseObj {
    protected String obix;
    private String display;
    private String displayName;
    private String name;
    private String is;
    private ArrayList<ObixBaseObj> children = new ArrayList<ObixBaseObj>();
    // new code
    private static final RuntimeTypeAdapterFactory<ObixBaseObj> adapter = 
            RuntimeTypeAdapterFactory.of(ObixBaseObj.class);

    private static final HashSet<Class<?>> registeredClasses= new HashSet<Class<?>>();

    static {
        GsonUtils.registerType(adapter);
    }

    private synchronized void registerClass() {
        if (!registeredClasses.contains(this.getClass())) {
            registeredClasses.add(this.getClass());
            adapter.registerSubtype(this.getClass());
        }
    }
    public ObixBaseObj() {
        registerClass();
        obix = "obj";
    }
_

どうして？このクラスまたはObixBaseObjの子クラスがインスタンス化されるたびに、クラスはRuntimeTypeAdapterに登録されるため

子クラスでは、最小限の変更のみが必要です。

_public class ObixOp extends ObixBaseObj {
    private String in;
    private String out;

    public ObixOp() {
        super();
        obix = "op";
    }

    public ObixOp(String in, String out) {
        super();
        obix = "op";
        this.in = in;
        this.out = out;
    }
_

作業例：

_public static void main(String[] args) {

        ObixBaseObj lobbyObj = new ObixBaseObj();
        lobbyObj.setIs("obix:Lobby");

        ObixOp batchOp = new ObixOp();
        batchOp.setName("batch");
        batchOp.setIn("obix:BatchIn");
        batchOp.setOut("obix:BatchOut");

        lobbyObj.addChild(batchOp);



        Gson gson = GsonUtils.getGson();
        System.out.println(gson.toJson(lobbyObj));

    }
_

出力：

_{
  "type": "ObixBaseObj",
  "obix": "obj",
  "is": "obix:Lobby",
  "children": [
    {
      "type": "ObixOp",
      "in": "obix:BatchIn",
      "out": "obix:BatchOut",
      "obix": "op",
      "name": "batch",
      "children": []
    }
  ]
}
_

役に立てば幸いです。

49
rpax

この問題を解決するための道を私に導いた他の回答に感謝します。 RuntimeTypeAdapterFactoryと Reflection の組み合わせを使用しました。

また、適切に構成されたGsonが使用されることを確認するヘルパークラスを作成しました。

GsonHelperクラス内の静的ブロック内で、次のコードをプロジェクトに通して、すべての適切なタイプを見つけて登録します。 JSON-ificationを通過するすべてのオブジェクトは、Jsonableのサブタイプです。以下を変更する必要があります。

  1. Reflectionsのmy.projectはパッケージ名にする必要があります。
  2. Jsonable.classは私の基本クラスです。あなたの代わりに。

  3. 私はフィールドに完全な正規名を表示するのが好きですが、明らかにそれが必要ない場合は、呼び出しのその部分を省略してサブタイプを登録することができます。 classNameのRuntimeAdapterFactoryについても同じことが言えます。既にtypeフィールドを使用しているデータ項目があります。

    private static final GsonBuilder gsonBuilder = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
    .excludeFieldsWithoutExposeAnnotation()
    .setPrettyPrinting();

static {
Reflections reflections = new Reflections("my.project");

Set<Class<? extends Jsonable>> allTypes = reflections.getSubTypesOf(Jsonable.class);
for (Class< ? extends Jsonable> serClass : allTypes){
    Set<?> subTypes = reflections.getSubTypesOf(serClass);
    if (subTypes.size() > 0){
        RuntimeTypeAdapterFactory<?> adapterFactory = RuntimeTypeAdapterFactory.of(serClass, "className");
        for (Object o : subTypes ){
            Class c = (Class)o;
            adapterFactory.registerSubtype(c, c.getCanonicalName());
        }
        gsonBuilder.registerTypeAdapterFactory(adapterFactory);
    }
}
}

public static Gson getGson() {
    return gsonBuilder.create();
}
5
Jeff