जावा में JSON फ़ाइल से कुंजी मान जोड़े कैसे निकालें

Dec 03 2020

मैं सोच रहा था कि क्या कोई मेरी मदद कर सकता है या मुझे संकेत दे सकता है कि जावा में संलग्न डमी JSON फ़ाइल को कैसे संपादित किया जाए।

जैसा कि आप देख सकते हैं कि मेरे पास एक हेड ऑब्जेक्ट है जिसमें कई मूल्य और बच्चे हैं जो समान पैटर्न का पालन करते हैं।

मैं जानना चाहता था कि क्या सभी कुंजियों को हटाने का एक तरीका है जहां मूल्य -1 है।

निम्नलिखित का उपयोग करके मैं कई वेबसाइटों पर आधारित कोशिश कर रहा था jackson:

try {
            // create object mapper instance
            ObjectMapper mapper = new ObjectMapper();

            // convert JSON file to map
            Map<?, ?> map = mapper.readValue(Paths.get("test.json").toFile(), Map.class);

            // print map entries
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                isInteger = main.isObjectInteger(entry.getValue());

                
//              System.out.println("if value is all: " + entry.getKey() + "=" + entry.getValue());
//              

उपरोक्त कोड फ़ाइल की संरचना को प्रदर्शित करेगा, हालांकि मेरी समस्या बच्चों के अंदर -1 मूल्यों तक पहुंचने और उन्हें दूर करने की है।

.GetClass और .simpleName विधियों का उपयोग करके मुझे पता है कि यह एक सरणी है, लेकिन मुझे भ्रम है कि इसके माध्यम से कैसे खोजा जाए।

किसी भी प्रकार की सहायता सराहनीय होगी!

जवाब

1 MichałZiober Dec 04 2020 at 00:49

में Jacksonआप पूरी पढ़ सकते हैं JSONके रूप में पेलोड JsonNodeसभी गुण से अधिक और दोहराएं हालत को देखते हुए जांच कर लें। यदि स्थिति पूरी हो जाए तो आप दिए गए क्षेत्र को हटा सकते हैं। ऐसा करने के लिए आपको पुनरावर्ती पद्धति को लागू करने की आवश्यकता है । नीचे दिए गए उदाहरण पर एक नज़र डालें:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.function.Predicate;

public class JsonRemoveSomeFieldsApp {

    public static void main(String[] args) throws IOException {
        File jsonFile = new File("./resource/test.json").getAbsoluteFile();

        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        JsonNode root = mapper.readTree(jsonFile);

        JsonCleaner jsonCleaner = new JsonCleaner(root, (node) -> node.isNumber() && node.numberValue().intValue() == -1);
        JsonNode result = jsonCleaner.removeAll();

        // write to file
        mapper.writeValue(System.out, result);
    }
}

class JsonCleaner {

    private final JsonNode root;
    private final Predicate<JsonNode> toRemoveCondition;

    JsonCleaner(JsonNode node, Predicate<JsonNode> toRemoveCondition) {
        this.root = Objects.requireNonNull(node);
        this.toRemoveCondition = Objects.requireNonNull(toRemoveCondition);
    }

    public JsonNode removeAll() {
        process(root);
        return root;
    }

    private void process(JsonNode node) {
        if (node.isObject()) {
            ObjectNode object = (ObjectNode) node;
            Iterator<Map.Entry<String, JsonNode>> fields = object.fields();
            while (fields.hasNext()) {
                Map.Entry<String, JsonNode> field = fields.next();
                JsonNode valueToCheck = field.getValue();
                if (valueToCheck.isContainerNode()) {
                    process(valueToCheck);
                } else if (toRemoveCondition.test(valueToCheck)) {
                    fields.remove();
                }
            }
        } else if (node.isArray()) {
            ArrayNode array = (ArrayNode) node;
            array.elements().forEachRemaining(this::process);
        }
    }
}

JSONपेलोड के नीचे के लिए :

{
  "name": "Head",
  "missed": -1,
  "covered": -1,
  "children": [
    {
      "name": "project1",
      "missed": -1,
      "covered": -1,
      "children": [
        {
          "name": "project1",
          "missed": 10,
          "covered": 11
        }
      ]
    },
    {
      "name": "project1",
      "missed": -1,
      "covered": 12,
      "children": [
        {
          "name": "project1",
          "missed": 10,
          "covered": -1
        }
      ]
    }
  ]
}

कोड प्रिंट के ऊपर:

{
  "name" : "Head",
  "children" : [ {
    "name" : "project1",
    "children" : [ {
      "name" : "project1",
      "missed" : 10,
      "covered" : 11
    } ]
  }, {
    "name" : "project1",
    "covered" : 12,
    "children" : [ {
      "name" : "project1",
      "missed" : 10
    } ]
  } ]
}

यह सभी देखें:

  • जावा में एक 3 स्तर नेस्टेड JSON स्ट्रिंग समतल
2 AnatolyG Dec 03 2020 at 11:09

JSON डेटा (साथ ही XML आदि जैसे कई अन्य स्वरूपों) को पार्स और जेनरेट करने के लिए दो मुख्य तकनीकें हैं: ऑब्जेक्ट मैपिंग और इवेंट / टोकन / स्ट्रीम-ओरिएंटेड प्रोसेसिंग। फ़िल्टरिंग सहित कई मामलों के लिए दूसरा तरीका सबसे अच्छा तरीका है। सहारा:

  • फ़ाइल / डेटा को पूरी तरह से मेमोरी में लोड करने की आवश्यकता नहीं है, आप बिना किसी समस्या के megs / gigs को संसाधित कर सकते हैं
  • यह बहुत अधिक तेजी से काम करता है, खासकर बड़ी फ़ाइलों के लिए
  • इस पैटर्न के साथ किसी भी कस्टम प्रकार / परिवर्तन के नियम को लागू करना आसान है

Gson और जैक्सन दोनों स्ट्रीम-ओरिएंटेड प्रोसेसिंग का समर्थन करते हैं। इस विचार को समझने के लिए यहां एक छोटे पार्सर / जनरेटर का उपयोग कर एक उदाहरण हैhttps://github.com/anatolygudkov/green-jelly

import org.green.jelly.AppendableWriter;
import org.green.jelly.JsonBufferedWriter;
import org.green.jelly.JsonEventPump;
import org.green.jelly.JsonNumber;
import org.green.jelly.JsonParser;

import java.io.StringWriter;

public class UpdateMyJson {
    private static final String jsonToUpdate = "{\n" +
            "\"name\": \"Head\",\n" +
            "\"missed\": -1,\n" +
            "\"children\": [\n" +
            "    {\n" +
            "        \"name\": \"project1\",\n" +
            "        \"fixes\": 0,\n" +
            "        \"commits\": -1,\n" +
            "    },\n" +
            "    {\n" +
            "        \"name\": \"project2\",\n" +
            "        \"fixes\": 20,\n" +
            "        \"commits\": 5,\n" +
            "    }\n" +
            "]\n" +
            "}";

    public static void main(String[] args) {
        final StringWriter result = new StringWriter(); // you can use FileWriter

        final JsonParser parser = new JsonParser();
        parser.setListener(new MyJsonUpdater(new AppendableWriter<>(result)));
        parser.parseAndEoj(jsonToUpdate); // if you read a file with a buffer,
        // to don't load the whole file into memory,
        // call parse() several times (part by part) in a loop until EOF
        // and then call .eoj()

        System.out.println(result);
    }

    static class MyJsonUpdater extends JsonEventPump {
        MyJsonUpdater(final JsonBufferedWriter output) {
            super(output);
        }

        @Override
        public boolean onNumberValue(final JsonNumber number) {
            if (number.mantissa() == -1 && number.exp() == 0) {
                return true; // return immediately
            }
            return super.onNumberValue(number); // otherwise pump the value to the result JSON
        }
    }
}