जावा में JSON वैध है या नहीं यह कैसे जांचें


155

मैं जावा में JSON स्ट्रिंग को कैसे मान्य करूं? या क्या मैं इसे नियमित अभिव्यक्ति का उपयोग करके पार्स कर सकता हूं?


आगजनी के साथ पार्स करने की कोशिश? रेगेक्स के माध्यम से मान्य करना एक अच्छा विचार नहीं हो सकता है
ऐश्वर्या

2
json.org के बहुत सारे पार्सर्स के साथ संबंध हैं
MartinK

जवाबों:


261

एक जंगली विचार, इसे पार्स करने का प्रयास करें और अपवाद को पकड़ें:

import org.json.*;

public boolean isJSONValid(String test) {
    try {
        new JSONObject(test);
    } catch (JSONException ex) {
        // edited, to include @Arthur's comment
        // e.g. in case JSONArray is valid as well...
        try {
            new JSONArray(test);
        } catch (JSONException ex1) {
            return false;
        }
    }
    return true;
}

इस कोड का उपयोग करता है org.json JSON एपीआई कार्यान्वयन कि उपलब्ध है GitHub पर , Maven में और आंशिक रूप से Android पर


2
यह करीब है, लेकिन एक JSONArray के लिए एक सत्यापन याद आ रही है (मैंने इस पोस्ट को अधिक उपयुक्त फ़ंक्शन के साथ अद्यतन किया है)
आर्थर

9
मैंने "{'हैलो': 'foo'} 'अमान्य'" ({} के बाहर 'जोड़ा गया अमान्य) जैसे json स्ट्रिंग की कोशिश की है, और JSONObject ParseException को नहीं फेंक रहा है। मैं org.json.JSONObject का उपयोग कर रहा हूं। क्या यह अपेक्षित है?
सोइची हयाशी

16
आपने लाइब्रेरी का उल्लेख नहीं किया है जिसमें JSONObject है, मैंने इसे मानक जावा
लिवा

6
यह समाधान अधिकांश मामलों के लिए काम करता है, लेकिन कुछ परिस्थितियों में विफल हो सकता है। उदाहरण के लिए, यह बंद ब्रेस से ठीक पहले अल्पविराम की अनुमति देता है, जो वास्तव में एक वाक्यविन्यास त्रुटि है। अन्य कोने के मामलों के लिए json.org/javadoc/org/json/JSONObject.html देखें ।
182

9
मुझे समझ नहीं आ रहा है कि कोड स्निपेट के साथ आयात स्टेटमेंट को शामिल करने के लिए पोस्टर को क्यों परेशान नहीं किया जा सकता है। यह यहाँ महत्वपूर्ण है। यहां दूसरे दर्जे का जवाब ज्यादा बेहतर है।

100

जैक्सन लाइब्रेरी

एक विकल्प जैक्सन पुस्तकालय का उपयोग करना होगा । पहले नवीनतम संस्करण आयात करें (अब है):

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.7.0</version>
</dependency>

फिर, आप सही उत्तर को इस प्रकार लागू कर सकते हैं:

import com.fasterxml.jackson.databind.ObjectMapper;

public final class JSONUtils {
  private JSONUtils(){}

  public static boolean isJSONValid(String jsonInString ) {
    try {
       final ObjectMapper mapper = new ObjectMapper();
       mapper.readTree(jsonInString);
       return true;
    } catch (IOException e) {
       return false;
    }
  }
}

Google GSON विकल्प

एक अन्य विकल्प Google Gson का उपयोग करना है । निर्भरता आयात करें:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.5</version>
</dependency>

फिर, आप प्रस्तावित समाधान को इस प्रकार लागू कर सकते हैं:

import com.google.gson.Gson;

public final class JSONUtils {
  private static final Gson gson = new Gson();

  private JSONUtils(){}

  public static boolean isJSONValid(String jsonInString) {
      try {
          gson.fromJson(jsonInString, Object.class);
          return true;
      } catch(com.google.gson.JsonSyntaxException ex) { 
          return false;
      }
  }
}

एक साधारण परीक्षण यहां दिया गया है:

//A valid JSON String to parse.
String validJsonString = "{ \"developers\": [{ \"firstName\":\"Linus\" , \"lastName\":\"Torvalds\" }, " +
        "{ \"firstName\":\"John\" , \"lastName\":\"von Neumann\" } ]}";

// Invalid String with a missing parenthesis at the beginning.
String invalidJsonString = "\"developers\": [ \"firstName\":\"Linus\" , \"lastName\":\"Torvalds\" }, " +
        "{ \"firstName\":\"John\" , \"lastName\":\"von Neumann\" } ]}";

boolean firstStringValid = JSONUtils.isJSONValid(validJsonString); //true
boolean secondStringValid = JSONUtils.isJSONValid(invalidJsonString); //false

कृपया, ध्यान दें कि अनुगामी अल्पविराम के कारण एक "मामूली" मुद्दा हो सकता है जिसे रिलीज में तय किया जाएगा 3.0.0


जबकि यह बेमेल उद्धरण, या लापता कोष्ठक जैसी बड़ी चीज़ों के लिए काम करता है, Gson खुशी से एक अनुगामी अल्पविराम के साथ एक json सरणी को पार्स करेगा, जो RFC-4627 के
eurythmia

@ सूर्यमणि सच! संस्करण 3.0 में उन्हें इस मुद्दे
जीनलजेन

1
यह {कुंजी: मान} को भी मान्य करता है, लेकिन इसका वैध नहीं है
प्रतापी हेमंत पटेल

2
जैक्सन new ObjectMapper().readTree("28xjRBuOQqupRopHeSuhRQ")पिटफुल : पर्स विदाउट एक्सेप्शन इन इंटनोड (28)। वास्तव में अपेक्षित नहीं ...
मर्गर्ट

1
जैसा कि मैं समझता हूं कि यह समाधान न केवल मान्य है, बल्कि पारस (और भंडार) पूरे जोंस को दर्शाता है। यह संख्याओं को इंटेगर / लॉन्ग / डबल आदि में कनवर्ट करता है। यह सिंटैक्स चेक से अधिक है, यह मेमोरी में पूरे जोंस को स्टोर करता है। यह गहन भार के लिए महत्वपूर्ण हो सकता है। यदि सिंटैक्स चेक के लिए बेहतर समाधान मौजूद है?
javapowered

15

Google Gson के साथ आप JsonParser का उपयोग कर सकते हैं:

import com.google.gson.JsonParser;

JsonParser parser = new JsonParser();
parser.parse(json_string); // throws JsonSyntaxException

3
ध्यान दें कि यह असभ्य स्ट्रिंग्स एएलए "asdf" पर एक त्रुटि नहीं फेंकता है
एंड्रयू

1
न ही यह JSON सरणियों में ट्रेलिंग कॉमा को अस्वीकार करता है।
सोटिरिओस डेलिमोनोलिस

मैं वास्तव में उस पर भरोसा नहीं कर सकता ... यह कहता है कि स्ट्रिंग "सेव" पार्स करने योग्य है।
धरिक

खबरदार है कि यहाँ उदाहरण के लिए उदार पार्सिंग मोड का उपयोग किया गया है जो अभी भी कई विचलन की अनुमति देता है। मेरे अन्य उत्तरों में टेस्टकेस और सख्त पार्सिंग उदाहरण के साथ अधिक विवरण देखें ।
वडज़िम

14

आप JSONUtils लाइब्रेरी में उपलब्ध .mayBeJSON (स्ट्रिंग str) का उपयोग कर सकते हैं ।


हाँ ... यह काम कर रहा है। धन्यवाद निंपी मैं आगजनी के साथ कोशिश कर रहा था, लेकिन ऐसी कोई विधि मैंने नहीं देखी।
सप्पू

@ सप्पू: अगर इस सवाल ने आपके सवाल को हल कर दिया तो इसे चिह्नित करें। अधिकांश पुस्तकालय एक स्ट्रिंग में ले जाते हैं और इसे पार्स करने की कोशिश करते हैं, अगर पार्सिंग विफल हो जाती है, अर्थात, स्ट्रिंग एक वैध JSON स्ट्रिंग नहीं है, तो यह एक अपवाद फेंक देगा।
१३

@npinti: अतिरिक्त के लिए विफल}। अतिरिक्त ब्रैकेट के साथ अमान्य स्ट्रिंग के लिए सही है =>}
विवेक

3
यह विधि शाब्दिक रूप से केवल यह जांचती है कि स्ट्रिंग शुरू होती है और या तो उद्धरण या कोष्ठक के साथ समाप्त होती है। बहुत अविश्वसनीय है।
Mun में माइकल मुंसी

2
इसलिए विधि का नाम 'शायद' है, न कि ':)'
खो

5

यह इस बात पर निर्भर करता है कि आप अपनी मान्यता के साथ क्या साबित करने की कोशिश कर रहे हैं। निश्चित रूप से जोंस को पार्स करना जैसा कि अन्य ने सुझाव दिया है कि रेग्क्स का उपयोग करने से बेहतर है, क्योंकि जोंस के व्याकरण की तुलना में अधिक जटिल है, केवल रेगीक्स के साथ प्रतिनिधित्व किया जा सकता है।

यदि आपके केवल java कोड के द्वारा ही jars को पार्स किया जाएगा, तो इसे मान्य करने के लिए उसी parser का उपयोग करें।

लेकिन सिर्फ पार्सिंग आपको यह नहीं बताएगा कि क्या यह अन्य वातावरणों में स्वीकार किया जाएगा। जैसे

  • कई पार्सर्स ऑब्जेक्ट या एरे में ट्रेलिंग कॉमा को नजरअंदाज करते हैं, लेकिन आईई के पुराने संस्करण तब विफल हो सकते हैं जब वे एक ट्रेलिंग कॉमा से टकराते हैं।
  • अन्य पार्सर्स अनुगामी अल्पविराम स्वीकार कर सकते हैं, लेकिन इसके बाद अपरिभाषित / अशक्त प्रविष्टि जोड़ सकते हैं।
  • कुछ पार्सर्स अयोग्य संपत्ति के नाम की अनुमति दे सकते हैं।
  • कुछ पार्सर्स स्ट्रिंग में गैर-एएससीआईआई पात्रों के लिए अलग तरह से प्रतिक्रिया कर सकते हैं।

यदि आपकी मान्यता बहुत संपूर्ण होनी चाहिए, तो आप निम्न कार्य कर सकते हैं:

  • जब तक आपको पता नहीं चलेगा कि मैं ऊपर उल्लिखित सभी कोने के मामलों में विफल रहता है, तब तक अलग-अलग पार्सर की कोशिश करें
  • या आप शायद javax.script का उपयोग करके jsonlint चला सकते हैं। *।
  • या javax.script का उपयोग करके रनशंट के साथ एक पार्सर का उपयोग करके गठबंधन करें। *।

4
String jsonInput = "{\"mob no\":\"9846716175\"}";//Read input Here
JSONReader reader = new JSONValidatingReader();
Object result = reader.read(jsonInput);
System.out.println("Validation Success !!");

कृपया stringtree-json लाइब्रेरी डाउनलोड करें


क्या उपरोक्त की तरह स्ट्रिंग को परिभाषित करना संभव है? या यह सिर्फ आइडिया के लिए है।
सैंट्रोन मणिभारती

संभव नहीं है, यह मेरी गलती के कारण था। इसकी
सुध ली। थैंक्स

1
JSONValidatingReader जावा एपीआई का हिस्सा नहीं है
इगोरगानापोलस्की

कृपया उपर्युक्त पुस्तकालय का उपयोग करें, धन्यवाद
जेमशीर

2

पार्सिंग के बारे में थोड़ा सा:

Json, और वास्तव में सभी भाषाओं में, एक व्याकरण का उपयोग करें जो नियमों का एक सेट है जिसे प्रतिस्थापन के रूप में उपयोग किया जा सकता है। json को पार्स करने के लिए, आपको मूल रूप से उन प्रतिस्थापनों को उल्टा करने की आवश्यकता है

Json एक संदर्भ मुक्त व्याकरण है , जिसका अर्थ है कि आप असीम रूप से नेस्टेड ऑब्जेक्ट / सरणियाँ ले सकते हैं और json अभी भी मान्य होगा। रेगेक्स केवल नियमित व्याकरण को संभालता है (इसलिए नाम में 'reg'), जो कि संदर्भ मुक्त व्याकरण का एक सबसेट है जो अनंत घोंसले के शिकार की अनुमति नहीं देता है, इसलिए सभी वैध जोंस को पार्स करने के लिए केवल रेगेक्स का उपयोग करना असंभव है। आप रेगेक्स के जटिल सेट का उपयोग कर सकते हैं और इस धारणा के साथ लूप कर सकते हैं कि कोई भी घोंसला नहीं कहेगा, 100 का स्तर गहरा होगा, लेकिन यह अभी भी बहुत मुश्किल होगा।

यदि आप अपने स्वयं के पार्सर को लिखने के लिए तैयार हैं, तो आप
व्याकरण का काम करने के बाद एक पुनरावर्ती वंशीय पार्सर बना सकते हैं


2

जांचें कि क्या कोई दिया गया तार कोटलिन में वैध JSON है । मैंने MBYD जावा से कोटलिन में परिवर्तित उत्तर दिया

fun isJSONValid(test: String): Boolean {
    try {
        JSONObject(test);
    } catch (ex: JSONException) {
        try {
            JSONArray(test);
        } catch (ex1: JSONException) {
            return false;
        }
    }
    return true;
}

1

यहां आप एक ऐसा टूल पा सकते हैं जो JSON फाइल को वेरिफाई कर सकता है, या आप किसी JSON लाइब्रेरी के साथ अपनी JSON फाइल को डिस्क्राइब कर सकते हैं और यदि ऑपरेशन सफल है, तो यह वैध होना चाहिए ( उदाहरण के लिए google-json जो कि एक अपवाद को फेंक देगा यदि इनपुट यह पार्सिंग मान्य JSON नहीं है)।


1

Playframework 2.6 का उपयोग करते हुए, जावा एपि में पाई गई Json लाइब्रेरी का उपयोग केवल स्ट्रिंग को पार्स करने के लिए किया जा सकता है। स्ट्रिंग या तो json सरणी का एक json तत्व हो सकता है। चूँकि लौटा मूल्य यहाँ महत्व का नहीं है इसलिए हम सिर्फ यह निर्धारित करने के लिए पार्स त्रुटि को पकड़ते हैं कि स्ट्रिंग एक सही ज़ोन स्ट्रिंग है या नहीं।

    import play.libs.Json;

    public static Boolean isValidJson(String value) {
        try{
            Json.parse(value);
            return true;
        } catch(final Exception e){
            return false;
        }
    }

1

IMHO, सबसे सुंदर तरीका JSON प्रसंस्करण (JSON-P) के लिए जावा एपीआई का उपयोग कर रहा है , जो कि JavaR मानकों में से एक है जो JSR 374 के अनुरूप है ।

try(StringReader sr = new StringReader(jsonStrn)) {
    Json.createReader(sr).readObject();
} catch(JsonParsingException e) {
    System.out.println("The given string is not a valid json");
    e.printStackTrace();
}

मावेन का उपयोग करते हुए, JSON-P पर निर्भरता जोड़ें:

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>javax.json</artifactId>
    <version>1.1.4</version>
</dependency>

यात्रा JSON-पी आधिकारिक पेज अधिक जानकारियां के लिए।


1

यहाँ पर गन्स लाइब्रेरी के साथ सख्त जोंस पार्सिंग के लिए एक काम का उदाहरण दिया गया है:

public static JsonElement parseStrict(String json) {
    // throws on almost any non-valid json
    return new Gson().getAdapter(JsonElement.class).fromJson(json); 
}

यह देखने के लिए कि कैसे JSON जावा में मान्य है और अधिक गैर-मान्य उदाहरणों के साथ अधिक जानकारी और विस्तारित परीक्षण मामले के साथ जावा में मान्य है, तो मेरा अन्य विस्तृत जवाब देखें ।


1

जैसा कि आप देख सकते हैं, बहुत सारे समाधान हैं, वे मुख्य रूप से JSON को जांचने के लिए पार्स करते हैं और अंत में आपको यह सुनिश्चित करने के लिए पार्स करना होगा।

लेकिन, संदर्भ के आधार पर, आप पूर्व-चेक के साथ प्रदर्शन में सुधार कर सकते हैं।

जब मैं API को कॉल करता हूं, तो मैं यह देखता हूं कि पहला वर्ण '{' है और अंतिम '}' है। यदि यह मामला नहीं है, तो मैं एक पार्सर बनाने से परेशान नहीं हूं।


0

मैंने इसके लिए एक बहुत ही सरल उपाय खोजा है।

कृपया इसके लिए पहले इस लाइब्रेरी net.sf.json-libको स्थापित करें ।

    import net.sf.json.JSONException;

    import net.sf.json.JSONSerializer;

    private static boolean isValidJson(String jsonStr) {
        boolean isValid = false;
        try {
            JSONSerializer.toJSON(jsonStr);
            isValid = true;
        } catch (JSONException je) {
            isValid = false;
        }
        return isValid;
    }

    public static void testJson() {
        String vjson = "{\"employees\": [{ \"firstName\":\"John\" , \"lastName\":\"Doe\" },{ \"firstName\":\"Anna\" , \"lastName\":\"Smith\" },{ \"firstName\":\"Peter\" , \"lastName\":\"Jones\" }]}";
        String ivjson = "{\"employees\": [{ \"firstName\":\"John\" ,, \"lastName\":\"Doe\" },{ \"firstName\":\"Anna\" , \"lastName\":\"Smith\" },{ \"firstName\":\"Peter\" , \"lastName\":\"Jones\" }]}";
        System.out.println(""+isValidJson(vjson)); // true
        System.out.println(""+isValidJson(ivjson)); // false
    }

किया हुआ। का आनंद लें


0

उत्तर आंशिक रूप से सही हैं। मैंने भी उसी समस्या का सामना किया। जसन को पार्स करना और अपवाद की जांच करना सामान्य तरीका लगता है लेकिन इनपुट जन्स के लिए समाधान कुछ ऐसा ही होता है

{"outputValueSchemaFormat": "", "sortByIndexInRecord": 0, "SortOrder": 847874874387209 "अवरोही"} Jajhfsadkjh

जैसा कि आप देख सकते हैं कि कचरा अमान्य है, क्योंकि वहां कचरा पात्र हैं। लेकिन यदि आप जैकसन या गन्स का उपयोग करके उपरोक्त जोंस को पार्स करने का प्रयास करते हैं तो आपको वैध जॅसन के पार्स किए गए नक्शे मिलेंगे और कचरा अनुगामी पात्रों को अनदेखा कर दिया जाएगा। जब आप जैसन वैधता की जाँच के लिए पार्सर का उपयोग कर रहे हों तो यह आवश्यक समाधान नहीं है।

इस समस्या के समाधान के लिए यहां देखें ।

पुनश्च: यह सवाल मुझसे पूछा गया था और जवाब दिया गया था।


0
import static net.minidev.json.JSONValue.isValidJson;

और फिर अपने JSON स्ट्रिंग में इस फ़ंक्शन को कॉल करें :)


0
public static boolean isJSONValid(String test) {
    try {
        isValidJSON(test);
        JsonFactory factory = new JsonFactory();
        JsonParser parser = factory.createParser(test);
        while (!parser.isClosed()) {
            parser.nextToken();
        }
    } catch (Exception e) {
        LOGGER.error("exception: ", e);
        return false;
    }
    return true;
}

private static void isValidJSON(String test) {
    try {
        new JSONObject(test);
    } catch (JSONException ex) {
        try {
            LOGGER.error("exception: ", ex);
            new JSONArray(test);
        } catch (JSONException ex1) {
            LOGGER.error("exception: ", ex1);
            throw new Exception("Invalid JSON.");
        }
    }
}

उपरोक्त समाधान में दोनों परिदृश्य शामिल हैं:

  • नकली चाबी
  • बेमेल उद्धरण या लापता कोष्ठक आदि।

0

javax.jsonपुस्तकालय का उपयोग कर एक समाधान :

import javax.json.*;

public boolean isTextJson(String text) {
    try {
        Json.createReader(new StringReader(text)).readObject();
    } catch (JsonException ex) {
        try {
            Json.createReader(new StringReader(text)).readArray();
        } catch (JsonException ex2) {
            return false;
        }
    }
    return true;
}

0

आप Validol घोषणात्मक सत्यापन पुस्तकालय WellFormedJsonसे कक्षा का उपयोग कर सकते हैं ।

घोषणा स्वयं निम्नलिखित की तरह दिख सकती है:

new WellFormedJson(
    new Unnamed<>(Either.right(new Present<>(jsonRequestString)))
)

चेक चरण इस तरह दिखता है:

    Result<JsonElement> result =
        (new WellFormedJson(
            new Named<>(
                "vasya",
                Either.right(
                    new Present<>(
                        "{\"guest\":{\"name\":\"Vadim Samokhin\",\"email\":\"samokhinvadim@gmail.com\"},\"source\":1,\"items\":[{\"id\":1900},{\"id\":777}]}"
                    )
                )
            )
        ))
            .result();

    assertTrue(result.isSuccessful());
    assertEquals(
        "{\"guest\":{\"name\":\"Vadim Samokhin\",\"email\":\"samokhinvadim@gmail.com\"},\"source\":1,\"items\":[{\"id\":1900},{\"id\":777}]}",
        result.value().raw().toString()
    );
    assertEquals(
        "{\"name\":\"Vadim Samokhin\",\"email\":\"samokhinvadim@gmail.com\"}",
        result.value().raw().getAsJsonObject().get("guest").toString()
    );

यह इस तरह के एक सरल कार्य के लिए एक ओवरकिल की तरह लग सकता है, लेकिन यह तब चमकता है जब आपको एक जटिल अनुरोध को मान्य करना पड़ता है। वैलिडॉल की त्वरित शुरुआत अनुभाग देखें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.