Question

我正在尝试在java中解析递归未知的json输入结构，如下面的格式，并尝试在另一个json中重写相同的结构。

同时我需要验证每个＆amp;解析时的每个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

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

或杰克逊

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

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

2 个答案: