在GSON中反序列化递归多态类 [英] Deserialize recursive polymorphic class in GSON

问题描述

 类Complex实现递归{
 Map< String，Recursive>地图; 
 ... 
} 
 
类简单实现递归{...} 
  

如何反序列化此json：

  {
type：complex ，
map：{
a：{
type：简单
}，
b：{
 type：complex，
map：{
ba：{
type：simple
} 
} 
} 
} 
  

使用Google GSON？

当然，可以改进管理临界情况（例如，如果没有类型字段？）。

  package stackoverflow.questions; 
 
 import java.lang.reflect.Type; 
 import java.util。*; 
 
导入stackoverflow.questions.Q20254329。*; 
 
 import com.google.gson。*; 
 import com.google.gson.reflect.TypeToken; 
 
公共类Q20327670 {
 
静态类Complex实现递归{
 Map< String，Recursive>地图; 
 
 @Override 
 public String toString（）{
 returnComplex [map =+ map +]; 
 
 
 
 $ b静态类简单实现递归{
 
 @Override 
 public String toString（）{
返回Simple []; 
} 
} 
 
 public static class RecursiveDeserializer实现JsonDeserializer<递归> {
 
 public递归反序列化（JsonElement json，类型typeOfT，JsonDeserializationContext上下文）抛出JsonParseException {
递归r = null; 
 if（json == null）
 r = null; 
 else {
 JsonElement t = json.getAsJsonObject（）。get（type）; 
 String type = null; 
 if（t！= null）{
 type = t.getAsString（）; 
 
 switch（type）{
 casecomplex：{
 Complex c = new Complex（）; 
 JsonElement e = json.getAsJsonObject（）。get（map）; 
 if（e！= null）{
 Type mapType = new TypeToken< Map< String，Recursive>>（）{} .getType（）; 
 c.map = context.deserialize（e，mapType）; 
} 
 r = c; 
休息; 
} 
 casesimple：{
 r = new Simple（）; 
休息; 
} 
 //记得管理默认.. 
} 
 
} 
} 
 return r; 
 
 
 
 $ b public static void main（String [] args）{
 String json ={+ 
\\ \\complex \：\complex \，+ 
\map \：{+ 
\a\：{+ 
\type \：\simple \+ 
}，+ 
\b\：{+ 
 \type \：\complex \，+ 
\map \：{+ 
\ba \：{ + 
\type \：\\ simple\ + 
} + 
} + 
} + 
}}; 
 
 GsonBuilder gb = new GsonBuilder（）; 
 gb.registerTypeAdapter（Recursive.class，new RecursiveDeserializer（））; 
 
 Gson gson = gb.create（）; 
递归r = gson.fromJson（json，Recursive.class）; 
 
 System.out.println（r）; 
 
} 
 
} 
  

这是我的代码结果如下：

$ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ []}]}]

class Complex implements Recursive {
  Map<String, Recursive> map;
  ...
}

class Simple implements Recursive { ... }

How do I deserialize this json:

{
  "type" : "complex",
  "map" : {
     "a" : {
        "type" : "simple"
     },
     "b" : {
        "type" : "complex",
        "map" : {
            "ba" : {
                "type" : "simple"
        } 
     } 
  }
}

using Google GSON?

解决方案

To deserialize your JSON you need a custom deserializer for your Recursive interface. In that kind of class you need to examine your JSON and decide what kind of class to instantiate as the type field in the JSON itself. Here you have a basic deserializer I wrote for you example.

Of course it can be improve to manage borderline cases (for example, what happens if you do not have type field?).

package stackoverflow.questions;

import java.lang.reflect.Type;
import java.util.*;

import stackoverflow.questions.Q20254329.*;

import com.google.gson.*;
import com.google.gson.reflect.TypeToken;

public class Q20327670 {

   static class Complex implements Recursive {
      Map<String, Recursive> map;

      @Override
      public String toString() {
         return "Complex [map=" + map + "]";
      }

   }

   static class Simple implements Recursive {

      @Override
      public String toString() {
         return "Simple []";
      }
   }

   public static class RecursiveDeserializer implements JsonDeserializer<Recursive> {

      public Recursive deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
         Recursive r = null;
         if (json == null)
            r = null;
         else {
            JsonElement t = json.getAsJsonObject().get("type");
            String type = null;
            if (t != null) {
               type = t.getAsString();

               switch (type) {
               case "complex": {
                  Complex c = new Complex();
                  JsonElement e = json.getAsJsonObject().get("map");
                  if (e != null) {
                     Type mapType = new TypeToken<Map<String, Recursive>>() {}.getType();
                     c.map = context.deserialize(e, mapType);
                  }
                  r = c;
                  break;
               }
               case "simple": {
                  r = new Simple();
                  break;
               }
               // remember to manage default..
               }

            }
         }
         return r;
      }

   }

   public static void main(String[] args) {
      String json = " {                                         " + 
                    "    \"type\" : \"complex\",                " + 
                    "    \"map\" : {                            " + 
                    "       \"a\" : {                           " +
                    "          \"type\" : \"simple\"            " +
                    "       },                                  " + 
                    "       \"b\" : {                           " +
                    "          \"type\" : \"complex\",          " + 
                    "          \"map\" : {                      " + 
                    "              \"ba\" : {                   " +
                    "                  \"type\" : \"simple\"    " +
                    "          }                                " +
                    "       }                                   " +
                    "    }                                      " +
                    "  }  }                                     ";

      GsonBuilder gb = new GsonBuilder();
      gb.registerTypeAdapter(Recursive.class, new RecursiveDeserializer());

      Gson gson = gb.create();
      Recursive r = gson.fromJson(json, Recursive.class);

      System.out.println(r);

   }

}

This is the result of my code:

Complex [map={a=Simple [], b=Complex [map={ba=Simple []}]}]

这篇关于在GSON中反序列化递归多态类的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！