मैं जावा में JSON स्ट्रिंग को कैसे मान्य करूं? या क्या मैं इसे नियमित अभिव्यक्ति का उपयोग करके पार्स कर सकता हूं?
मैं जावा में JSON स्ट्रिंग को कैसे मान्य करूं? या क्या मैं इसे नियमित अभिव्यक्ति का उपयोग करके पार्स कर सकता हूं?
जवाबों:
एक जंगली विचार, इसे पार्स करने का प्रयास करें और अपवाद को पकड़ें:
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 पर ।
जैक्सन लाइब्रेरी
एक विकल्प जैक्सन पुस्तकालय का उपयोग करना होगा । पहले नवीनतम संस्करण आयात करें (अब है):
<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
।
new ObjectMapper().readTree("28xjRBuOQqupRopHeSuhRQ")
पिटफुल : पर्स विदाउट एक्सेप्शन इन इंटनोड (28)। वास्तव में अपेक्षित नहीं ...
Google Gson के साथ आप JsonParser का उपयोग कर सकते हैं:
import com.google.gson.JsonParser;
JsonParser parser = new JsonParser();
parser.parse(json_string); // throws JsonSyntaxException
आप JSONUtils लाइब्रेरी में उपलब्ध .mayBeJSON (स्ट्रिंग str) का उपयोग कर सकते हैं ।
यह इस बात पर निर्भर करता है कि आप अपनी मान्यता के साथ क्या साबित करने की कोशिश कर रहे हैं। निश्चित रूप से जोंस को पार्स करना जैसा कि अन्य ने सुझाव दिया है कि रेग्क्स का उपयोग करने से बेहतर है, क्योंकि जोंस के व्याकरण की तुलना में अधिक जटिल है, केवल रेगीक्स के साथ प्रतिनिधित्व किया जा सकता है।
यदि आपके केवल java कोड के द्वारा ही jars को पार्स किया जाएगा, तो इसे मान्य करने के लिए उसी parser का उपयोग करें।
लेकिन सिर्फ पार्सिंग आपको यह नहीं बताएगा कि क्या यह अन्य वातावरणों में स्वीकार किया जाएगा। जैसे
यदि आपकी मान्यता बहुत संपूर्ण होनी चाहिए, तो आप निम्न कार्य कर सकते हैं:
String jsonInput = "{\"mob no\":\"9846716175\"}";//Read input Here
JSONReader reader = new JSONValidatingReader();
Object result = reader.read(jsonInput);
System.out.println("Validation Success !!");
कृपया stringtree-json लाइब्रेरी डाउनलोड करें
पार्सिंग के बारे में थोड़ा सा:
Json, और वास्तव में सभी भाषाओं में, एक व्याकरण का उपयोग करें जो नियमों का एक सेट है जिसे प्रतिस्थापन के रूप में उपयोग किया जा सकता है। json को पार्स करने के लिए, आपको मूल रूप से उन प्रतिस्थापनों को उल्टा करने की आवश्यकता है
Json एक संदर्भ मुक्त व्याकरण है , जिसका अर्थ है कि आप असीम रूप से नेस्टेड ऑब्जेक्ट / सरणियाँ ले सकते हैं और json अभी भी मान्य होगा। रेगेक्स केवल नियमित व्याकरण को संभालता है (इसलिए नाम में 'reg'), जो कि संदर्भ मुक्त व्याकरण का एक सबसेट है जो अनंत घोंसले के शिकार की अनुमति नहीं देता है, इसलिए सभी वैध जोंस को पार्स करने के लिए केवल रेगेक्स का उपयोग करना असंभव है। आप रेगेक्स के जटिल सेट का उपयोग कर सकते हैं और इस धारणा के साथ लूप कर सकते हैं कि कोई भी घोंसला नहीं कहेगा, 100 का स्तर गहरा होगा, लेकिन यह अभी भी बहुत मुश्किल होगा।
यदि आप अपने स्वयं के पार्सर को लिखने के लिए तैयार हैं, तो आप
व्याकरण का काम करने के बाद एक पुनरावर्ती वंशीय पार्सर बना सकते हैं
जांचें कि क्या कोई दिया गया तार कोटलिन में वैध JSON है । मैंने MBYD जावा से कोटलिन में परिवर्तित उत्तर दिया
fun isJSONValid(test: String): Boolean {
try {
JSONObject(test);
} catch (ex: JSONException) {
try {
JSONArray(test);
} catch (ex1: JSONException) {
return false;
}
}
return true;
}
यहां आप एक ऐसा टूल पा सकते हैं जो JSON फाइल को वेरिफाई कर सकता है, या आप किसी JSON लाइब्रेरी के साथ अपनी JSON फाइल को डिस्क्राइब कर सकते हैं और यदि ऑपरेशन सफल है, तो यह वैध होना चाहिए ( उदाहरण के लिए google-json जो कि एक अपवाद को फेंक देगा यदि इनपुट यह पार्सिंग मान्य JSON नहीं है)।
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;
}
}
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-पी आधिकारिक पेज अधिक जानकारियां के लिए।
यहाँ पर गन्स लाइब्रेरी के साथ सख्त जोंस पार्सिंग के लिए एक काम का उदाहरण दिया गया है:
public static JsonElement parseStrict(String json) {
// throws on almost any non-valid json
return new Gson().getAdapter(JsonElement.class).fromJson(json);
}
यह देखने के लिए कि कैसे JSON जावा में मान्य है और अधिक गैर-मान्य उदाहरणों के साथ अधिक जानकारी और विस्तारित परीक्षण मामले के साथ जावा में मान्य है, तो मेरा अन्य विस्तृत जवाब देखें ।
जैसा कि आप देख सकते हैं, बहुत सारे समाधान हैं, वे मुख्य रूप से JSON को जांचने के लिए पार्स करते हैं और अंत में आपको यह सुनिश्चित करने के लिए पार्स करना होगा।
लेकिन, संदर्भ के आधार पर, आप पूर्व-चेक के साथ प्रदर्शन में सुधार कर सकते हैं।
जब मैं API को कॉल करता हूं, तो मैं यह देखता हूं कि पहला वर्ण '{' है और अंतिम '}' है। यदि यह मामला नहीं है, तो मैं एक पार्सर बनाने से परेशान नहीं हूं।
मैंने इसके लिए एक बहुत ही सरल उपाय खोजा है।
कृपया इसके लिए पहले इस लाइब्रेरी 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
}
किया हुआ। का आनंद लें
उत्तर आंशिक रूप से सही हैं। मैंने भी उसी समस्या का सामना किया। जसन को पार्स करना और अपवाद की जांच करना सामान्य तरीका लगता है लेकिन इनपुट जन्स के लिए समाधान कुछ ऐसा ही होता है
{"outputValueSchemaFormat": "", "sortByIndexInRecord": 0, "SortOrder": 847874874387209 "अवरोही"} Jajhfsadkjh
जैसा कि आप देख सकते हैं कि कचरा अमान्य है, क्योंकि वहां कचरा पात्र हैं। लेकिन यदि आप जैकसन या गन्स का उपयोग करके उपरोक्त जोंस को पार्स करने का प्रयास करते हैं तो आपको वैध जॅसन के पार्स किए गए नक्शे मिलेंगे और कचरा अनुगामी पात्रों को अनदेखा कर दिया जाएगा। जब आप जैसन वैधता की जाँच के लिए पार्सर का उपयोग कर रहे हों तो यह आवश्यक समाधान नहीं है।
इस समस्या के समाधान के लिए यहां देखें ।
पुनश्च: यह सवाल मुझसे पूछा गया था और जवाब दिया गया था।
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.");
}
}
}
उपरोक्त समाधान में दोनों परिदृश्य शामिल हैं:
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;
}
आप 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()
);
यह इस तरह के एक सरल कार्य के लिए एक ओवरकिल की तरह लग सकता है, लेकिन यह तब चमकता है जब आपको एक जटिल अनुरोध को मान्य करना पड़ता है। वैलिडॉल की त्वरित शुरुआत अनुभाग देखें ।