无法使用Gson将复杂/动态JSON反序列化为Java类

Question

我一直在尝试使用Gson将JSON反序列化为Java类，但JSON结构太复杂，我无法处理。JSON看起来像这样(由于重复，我对其中的一些内容进行了修剪)：

{
   "results":[
      {
         "openEHR-EHR-CLUSTER.encounter_channel.v0/items[at0001]/value<DV_TEXT>":{
            "type":"DV_TEXT",
            "name":{
               "en":"Encounter channel"
            },
            "attrs":[
               "value"
            ]
         },
         "openEHR-EHR-CLUSTER.monitoring_reason.v0/items[at0001]/value<DV_TEXT>":{
            "type":"DV_TEXT",
            "name":{
               "en":"Monitoring reason"
            },
            "attrs":[
               "value"
            ]
         }
      },
      {
         "163eee06-83a4-4fd8-bf65-5d6a3ef35ac5":{
            "d5760d01-84dd-42b2-8001-a69ebaa4c2df":{
               "date":"2020-08-06 09:45:31",
               "cols":[
                  {
                     "type":"DV_TEXT",
                     "path":"openEHR-EHR-CLUSTER.encounter_channel.v0/items[at0001]/value<DV_TEXT>",
                     "values":[
                        {
                           "instanceTemplatePath":"prova_de_conceito.en.v1/context/other_context[at0001]/items[archetype_id=openEHR-EHR-CLUSTER.encounter_channel.v0](0)/items[at0001](0)/value",
                           "value":"null"
                        }
                     ]
                  },
                  {
                     "type":"DV_TEXT",
                     "path":"openEHR-EHR-CLUSTER.monitoring_reason.v0/items[at0001]/value<DV_TEXT>",
                     "values":[
                        {
                           "instanceTemplatePath":"prova_de_conceito.en.v1/context/other_context[at0001]/items[archetype_id=openEHR-EHR-CLUSTER.monitoring_reason.v0](1)/items[at0001](0)/value",
                           "value":"null"
                        }
                     ]
                  }
               ]
            },
            "fb366b72-d567-4d23-9f5f-356fc09aff6f":{
               "date":"2020-08-06 10:02:26",
               "cols":[
                  {
                     "type":"DV_TEXT",
                     "path":"openEHR-EHR-CLUSTER.encounter_channel.v0/items[at0001]/value<DV_TEXT>",
                     "values":[
                        {
                           "instanceTemplatePath":"prova_de_conceito.en.v1/context/other_context[at0001]/items[archetype_id=openEHR-EHR-CLUSTER.encounter_channel.v0](0)/items[at0001](0)/value",
                           "value":"Consulta presencial"
                        }
                     ]
                  },
                  {
                     "type":"DV_TEXT",
                     "path":"openEHR-EHR-CLUSTER.monitoring_reason.v0/items[at0001]/value<DV_TEXT>",
                     "values":[
                        {
                           "instanceTemplatePath":"prova_de_conceito.en.v1/context/other_context[at0001]/items[archetype_id=openEHR-EHR-CLUSTER.monitoring_reason.v0](1)/items[at0001](0)/value",
                           "value":"Consulta"
                        }
                     ]
                  }
               ]
            }
         }
      }
   ],
   "pagination":{
      "max":20,
      "offset":0,
      "nextOffset":20,
      "prevOffset":0
   },
   "timing":"475 ms"
}

主JSON对象有三个字段：results、pagination和timing。我可以很好地反序列化pagination和timing，因为它们总是具有相同的结构。但是，我不能正确地反序列化results。

results始终是两个不同对象的列表。特别是第二个对象，它是最复杂的对象，因为它的字段名不是静态的。每次API响应时，UUID名称引用都会发生变化。例如，名为"163eee06-83a4-4fd8-bf65-5d6a3ef35ac5"的字段在下一个JSON响应中可能有另一个id。因此，我不能在相应的Java类中为其指定适当的字段名。本例中的"d5760d01-84dd-42b2-8001-a69ebaa4c2df"和"fb366b72-d567-4d23-9f5f-356fc09aff6f"也是如此。

关于如何使用Gson正确地反序列化这种JSON，您有什么想法吗？我尝试了几种不同的方法，但到目前为止还没有真正有效的方法。

在最近的尝试中，我尝试使用JsonDeserializer方法来区分results列表中的对象类型。我目前的实现是这样的(由于空间的限制，getter和setter被隐藏了)：

QueryResponse.java

public class QueryResponse {
    private List<Map<String, ResultInterface>> results;
    private Pagination pagination;
    private String timing;
}

Pagination.java

public class Pagination {
    private Integer max;
    private Integer offset;
    private Integer nextOffset;
    private Integer previousOffset;
}

ResultInterface.java

public interface ResultInterface {

}

ElementDefinition.java

public class ElementDefinition implements ResultInterface {
    private String type;
    private Name name;
    private List<String> attrs;
}

Name.java

public class Name {
    private String en;
    private String es;
}

Compositions.java

public class Compositions implements ResultInterface {
    private Map<String, Composition> compositions;
}

Composition.java

public class Composition {
    private String date;
    private List<Col> cols;
}

Col.java

public class Col {
    private String type;
    private String path;
    private List<Value> values;
}

Value.java

public class Value {
    private String instanceTemplatePath;
    private String value;
    private String magnitude;
    private String units;
    private String code;
    private String terminology_id;
}

ResultInterfaceDeserializer.java

public class ResultInterfaceDeserializer implements JsonDeserializer<ResultInterface> {
    
    @Override
    public ResultInterface deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jObject = (JsonObject) json;
        JsonElement typeObj = jObject.get("type");

        if (typeObj != null) {
            return context.deserialize(json, ElementDefinition.class);
        } else {
            return context.deserialize(json, Compositions.class);
        }
    }
}

我这样调用Gson：

GsonBuilder builder = new GsonBuilder();
        
builder.registerTypeAdapter(ResultInterface.class, new ResultInterfaceDeserializer());
Gson gson = builder.create();
        
QueryResponse queryResponse = gson.fromJson(externalJsonResponse, QueryResponse.class);

此实现的问题在于，在JSON结构中没有任何名为compositions的内容，因此无法正确标识Compositions.java类。我知道我必须使用像Map<String, SomeObject>这样的Java结构，但问题是这里有太多动态命名的Json字段，如果它们没有固定的名称标识符，我就不能“获取”它们。

更新

我设法找到了一个解决方案。我想说的是，这实际上是一种变通方法，可能不是最干净或优雅的解决方案。我当前实现的问题是，我试图“抓取”一个名为compositions的JSON字段，而实际上它并不存在。因此，我决定操作JSON并自己添加该字段(在代码中)。我将反序列化程序类更改为：

public class ResultInterfaceDeserializer implements JsonDeserializer<ResultInterface> { 
    public String encloseJsonWithCompositionsField(JsonElement json) {
        return "{\"compositions\":" + json.toString() + "}";
    }
    
    @Override
    public ResultInterface deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jObject = (JsonObject) json;
        
        if (jObject.get("type") != null) {
            return context.deserialize(json, ElementDefinition.class);
        } else {
            JsonElement jsonWithCompositionsField = new JsonParser().parse(encloseJsonWithCompositionsField(json));
            return context.deserialize(jsonWithCompositionsField, Compositions.class);
        }
    }
}

有了这个更改，我现在可以“抓取”compositions字段并获取Java POJO中的数据。

Answer 1

您可能可以通过为Compositions注册一个额外的JsonDeserializer来解决此问题

public class CompositionsDeserializer implements JsonDeserializer<Compositions> {
    public static final CompositionsDeserializer INSTANCE = new CompositionsDeserializer();
    
    private CompositionsDeserializer() { }
    
    @Override
    public Compositions deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        Compositions compositions = new Compositions();
        Map<String, Composition> compositionsMap = new HashMap<>();
        compositions.compositions = compositionsMap;
        
        JsonObject compositionsJson = json.getAsJsonObject();
        for (Map.Entry<String, JsonElement> compositionEntry : compositionsJson.entrySet()) {
            Composition composition = context.deserialize(compositionEntry.getValue(), Composition.class);
            compositionsMap.put(compositionEntry.getKey(), composition);
        }
        
        return compositions;
    }
}

然后在GsonBuilder上注册该反序列化程序：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(ResultInterface.class, new ResultInterfaceDeserializer())
    .registerTypeAdapter(Compositions.class, CompositionsDeserializer.INSTANCE)
    .create();