Question

在后端，我必须能够接收/发送JSON结构，如下所示。

{  
   "firstObject":{  
      "type":"string",
      "value":"productValue"
   },
   "secondObject":{  
      "type":"string",
      "value":"statusValue"
   },
   "thirdObject":{  
      "type":"map",
      "value":{  
         "customerName":{  
            "type":"string",
            "value":"customerValue"
         }
      }
   },
   "fourthObject":{  
      "type":"map",
      "value":{  
         "firstObject":{  
            "type":"map",
            "value":{  
               "anotherObj1":{  
                  "type":"string",
                  "value":"TEST"
               },
               "anotherObj2":{  
                  "type":"date",
                  "value":"01/12/2018"
               },
               "anotherObj3":{  
                  "type":"date",
                  "value":"31/01/2018"
               }
            }
         }
      }
   }
}

令这个问题有些棘手的是，对于每个对象，我必须知道哪种类型。可能有4种类型：

int
字符串
布尔值
地图

例如，如果某个对象的值是map（由客户选择），则在前端侧将出现另一个键/值结构，因此我在后端将收到的是动态结构。我将需要对此结构进行验证，以检查其是否符合我的期望。

如果只使用Java类，制作所需的对象或在其中使用Jackson进行JSON验证并映射所有内容，我将不胜感激会变成JSON。

如果要使用Jackson，则必须制作一个自定义的序列化器和反序列化器。

Answer 1

在Jackson库中，您可以使用JsonTypeInfo和JsonSubTypes批注。它们是处理多态类型的处理：

@JsonTypeInfo用于指示序列化中包含哪些类型信息的详细信息
@JsonSubTypes用于指示带注释类型的子类型
@JsonTypeName用于定义用于带注释的类的逻辑类型名称

您的示例适合该解决方案，但根对象看起来更像简单的POJO类。在您的情况下，我们应该使用Craete类型结构来帮助处理以下3种类型：string，date，map：

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = StringValue.class, name = "string"),
    @JsonSubTypes.Type(value = DateValue.class, name = "date"),
    @JsonSubTypes.Type(value = MapValue.class, name = "map")
})
abstract class HasValue<T> {

    protected T value;

    public HasValue() {
        this(null);
    }

    public HasValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return getClass().getSimpleName() + "{" +
            "value=" + value +
            "}";
    }
}

class StringValue extends HasValue<String> {

    public StringValue() {
        this(null);
    }

    public StringValue(String value) {
        super(value);
    }
}

class DateValue extends HasValue<String> {

    public DateValue(String value) {
        super(value);
    }

    public DateValue() {
        this(null);
    }
}

class MapValue extends HasValue<Map<String, HasValue>> {

    public MapValue(Map<String, HasValue> value) {
        super(value);
    }

    public MapValue() {
        this(new LinkedHashMap<>());
    }

    public void put(String key, HasValue hasValue) {
        this.value.put(key, hasValue);
    }
}

现在，我们需要引入POJO作为根值。它看起来可能如下所示，但是您可以根据需要添加getter / setter。对于下面的示例，代码就足够了：

class Root {

    public HasValue firstObject;
    public HasValue secondObject;
    public HasValue thirdObject;
    public HasValue fourthObject;

    @Override
    public String toString() {
        return "Root{" +
            "firstObject=" + firstObject +
            ", secondObject=" + secondObject +
            ", thirdObject=" + thirdObject +
            ", fourthObject=" + fourthObject +
            '}';
    }
}

现在，我们终于可以尝试序列化和反序列化这些对象：

MapValue customerName = new MapValue();
customerName.put("customerName", new StringValue("customerValue"));

MapValue innerMap = new MapValue();
innerMap.put("anotherObj1", new StringValue("TEST"));
innerMap.put("anotherObj2", new DateValue("01/12/2018"));
innerMap.put("anotherObj3", new DateValue("31/01/2018"));

MapValue fourthObject = new MapValue();
fourthObject.put("firstObject", innerMap);

Root root = new Root();
root.firstObject = new StringValue("productValue");
root.secondObject = new StringValue("statusValue");
root.thirdObject = customerName;
root.fourthObject = fourthObject;

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root);
System.out.println(json);
System.out.println(mapper.readValue(json, Root.class));

Aboce代码显示JSON：

{
  "firstObject" : {
    "type" : "string",
    "value" : "productValue"
  },
  "secondObject" : {
    "type" : "string",
    "value" : "statusValue"
  },
  "thirdObject" : {
    "type" : "map",
    "value" : {
      "customerName" : {
        "type" : "string",
        "value" : "customerValue"
      }
    }
  },
  "fourthObject" : {
    "type" : "map",
    "value" : {
      "firstObject" : {
        "type" : "map",
        "value" : {
          "anotherObj1" : {
            "type" : "string",
            "value" : "TEST"
          },
          "anotherObj2" : {
            "type" : "date",
            "value" : "01/12/2018"
          },
          "anotherObj3" : {
            "type" : "date",
            "value" : "31/01/2018"
          }
        }
      }
    }
  }
}

和toString表示形式：

Root{firstObject=StringValue{value=productValue}, secondObject=StringValue{value=statusValue}, thirdObject=MapValue{value={customerName=StringValue{value=customerValue}}}, fourthObject=MapValue{value={firstObject=MapValue{value={anotherObj1=StringValue{value=TEST}, anotherObj2=DateValue{value=01/12/2018}, anotherObj3=DateValue{value=31/01/2018}}}}}}

您可以通过添加/删除任何类型的HasValue实例来轻松操纵输出。

有关更多信息，请参见：

Answer 2

从here下载JSON jar。从客户端使用json.stringify将JSON转换为字符串（因为JSONObject的构造函数仅接受字符串）。收到客户端的请求后，请执行以下操作：

public void doPost(request,response) throws ParseException, JSONException {
        parseMapFromJSON(request.getParameter("JSONFromClient"));
}
private void parseMapFromJSON(String JSONParam) throws JSONException
{
    JSONObject requestJSON = new JSONObject(JSONParam);
    for(int i=0; i<requestJSON.length();i++)
    {
         String key = (String) requestJSON.names().get(i);             
         if(key.endsWith("Object"))
         {
            parseMapFromJSON(requestJSON.get(key).toString());
         }
         else if(key.startsWith("type") && (requestJSON.get(key).equals("date") || requestJSON.get(key).equals("string")))
         {
            System.out.println(requestJSON.get("value"));
            break;
         }
         else if(key.startsWith("type") && requestJSON.get(key).equals("map"))
         {
            parseMapFromJSON(requestJSON.get("value").toString());
         }
         else if(!key.equals("value"))
         {
            parseMapFromJSON(requestJSON.get(key).toString());
         }
    }
}

在Jackson旁边还有其他东西可以用Java处理复杂对象吗？

2 个答案: