在java中递归地解析递归未知的json输入结构

Question

我想解析Java中的未知json输入结构，如下面的格式，并试图在另一个json中重写相同的结构。

同时，我需要在解析时验证每个json键/值的每个&。

{"Verbs":[{ 
    "aaaa":"30d", "type":"ed", "rel":1.0, "id":"80", "spoken":"en", "ct":"on", "sps":null 
},{ 
    "aaaa":"31", "type":"cc", "rel":3.0, "id":"10", "spoken":"en", "ct":"off", "sps":null 
},{ 
    "aaaa":"81", "type":"nn", "rel":3.0, "id":"60", "spoken":"en", "ct":"on", "sps":null 
}]} 

请指教哪些json解析器可用于读取和编写未知的json内容。

Answer 1

这样，您就可以递归解析JSON对象：

import com.eclipsesource.json.JsonArray; 
import com.eclipsesource.json.JsonObject; 
import com.eclipsesource.json.JsonValue; 

public class JsonQuestion { 

    public static void main(String[] args) { 
     String input = "{\"Verbs\":[{\n" + 
       " \"aaaa\":\"30d\", \"type\":\"ed\", \"rel\":1.0, \"id\":\"80\", \"spoken\":\"en\", \"ct\":\"on\", \"sps\":null\n" + 
       "},{\n" + 
       " \"aaaa\":\"31\", \"type\":\"cc\", \"rel\":3.0, \"id\":\"10\", \"spoken\":\"en\", \"ct\":\"off\", \"sps\":null\n" + 
       "},{\n" + 
       " \"aaaa\":\"81\", \"type\":\"nn\", \"rel\":3.0, \"id\":\"60\", \"spoken\":\"en\", \"ct\":\"on\", \"sps\":null\n" + 
       "}]}"; 

     JsonObject jsonObject = JsonObject.readFrom(input); 
     handleObject(jsonObject); 
    } 

    private static void handleValue(JsonObject.Member member, JsonValue value) { 
     if (value.isArray()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println("array value "); 
      recurseArray(value.asArray()); 
     } else if (value.isBoolean()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println(", boolean value = " + value.asBoolean()); 
     } else if (value.isNull()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println(", null value"); 
     } else if (value.isNumber()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println(", number value = " + value.asDouble()); 
     } else if (value.isObject()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println(", object value "); 
      handleObject(value.asObject()); 
     } else if (value.isString()) { 
      if (member != null) { 
       System.out.print("name = " + member.getName()); 
      } 
      System.out.println(", string value = " + value.asString()); 
     } 
    } 

    private static void handleObject(JsonObject object) { 
     for (JsonObject.Member next : object) { 
      JsonValue value = next.getValue(); 
      handleValue(next, value); 
     } 
    } 

    private static void recurseArray(JsonArray array) { 
     for (JsonValue value : array) { 
      handleValue(null, value); 
     } 
    } 
} 

Answer 2

使用Jackson库，你可以做到这一点，例如，以这样的方式

ObjectMapper mapper = new ObjectMapper(); 
JsonNode rootNode = mapper.readTree(json); 
ArrayNode verbs = (ArrayNode) rootNode.get("Verbs"); 
int size = verbs.size(); 
for (int index = 0; index < size; index++) { 
    JsonNode itemNode = verbs.get(index); 
    System.out.println(itemNode); 
    System.out.println(itemNode.get("aaaa").asText()); 
    System.out.println(itemNode.get("type").asText()); 
    System.out.println(itemNode.get("rel").asInt()); 
    System.out.println(itemNode.get("id").asInt()); 
    //... 
} 

Answer 3

使用GSON库 https://sites.google.com/site/gson/gson-user-guide

public void parseJson() { 
    String jsonStr = "";//nput json String. 
    JsonElement jsonElement = parser.parse(jsonStr); 
    processJsonElement(jsonElement); 
} 


private void processJsonElement(JsonElement e) { 
    if (e.isJsonArray()) { 
     processJsonArray(e.getAsJsonArray()); 
    } else if (e.isJsonNull()) { 
     processJsonNull(e.getAsJsonNull()); 
    } else if (e.isJsonObject()) { 
     processJsonObject(e.getAsJsonObject()); 
    } else if (e.isJsonPrimitive()) { 
     processJsonPrimitive(e.getAsJsonPrimitive()); 
    } 
} 

private void processJsonArray(JsonArray a) { 
    for (JsonElement e : a) { 
     processJsonElement(e); 
    } 
} 

private void processJsonNull(JsonNull n) { 
    System.out.println("null || : " + n); 
} 

private void processJsonObject(JsonObject o) { 
    Set<Map.Entry<String, JsonElement>> members= o.entrySet(); 
    for (Map.Entry<String, JsonElement> e : members) { 
     System.out.println("Processing object member: " + e.getKey()); 
     processJsonElement(e.getValue()); 
    } 
} 

private void processJsonPrimitive(JsonPrimitive p) { 
    System.out.println("Primitive || :" + p); 
} 

or Jackson

public void processJson() { 
    ObjectMapper objectMapper = new ObjectMapper(); 
    try { 
     JsonNode node = objectMapper.readTree(jsonStr); 
     System.out.println(node); 
     processNode(node); 
    } catch (IOException e) { 
     throw new RuntimeException(e); 
    } 

} 

private void processNode(JsonNode n) { 
    if (n.isContainerNode()) { 
     processJsonContainer(n.iterator()); 
    } else if (n.isNull()) { 
     System.out.println("Null || :" + n); 
    } else if (n.isNumber()) { 
     System.out.println("Number || :" + n.asDouble()); 
    } else if (n.isBoolean()) { 
     System.out.println("Boolean || :" + n.asBoolean()); 
    } else if (n.isTextual()) { 
     System.out.println("Text || :" + n.asText()); 
    } 
} 

private void processJsonContainer(Iterator<JsonNode> iterator) { 
    while (iterator.hasNext()) { 
     processNode(iterator.next()); 
    } 
}