在GSON中反序列化递归多态类

• Z时代
• 2024-01-10
• 分类：问答

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

我如何反序列化此json：

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

使用Google GSON？

回答：

要反序列化JSON，您需要为递归接口使用自定义反序列化器。在这种类中，您需要检查JSON并确定要实例化为JSON本身的type字段的类。在这里，您有一个我为您编写的示例基本解串器。

当然，管理边界事件可以得到改善（例如，如果没有类型字段，会发生什么情况？）。

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

这是我的代码的结果：

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

以上是 在GSON中反序列化递归多态类 的全部内容， 来源链接： utcz.com/qa/410302.html