Come verificare se una determinata stringa è JSON valida in Java

Come convalido una stringa JSON in Java? O potrei analizzarlo usando le espressioni regolari?

Un’idea selvaggia, prova ad analizzarla e cogli l’eccezione:

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

Questo codice utilizza l’implementazione dell’API JSON org.json disponibile su github , in maven e parzialmente su Android .

JACKSON Library

Un’opzione sarebbe usare la libreria di Jackson . Prima importa l’ultima versione (ora lo è):

  com.fasterxml.jackson.core jackson-databind 2.7.0  

Quindi, è ansible implementare la risposta corretta come segue:

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

Opzione GSON di Google

Un’altra opzione è usare Google Gson . Importa la dipendenza:

  com.google.code.gson gson 2.5  

Ancora una volta, puoi implementare la soluzione proposta come:

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

Un semplice test segue qui:

 //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(VALID_JSON_STRING); //true boolean secondStringValid = JSONUtils.isJSONValid(NOT_VALID_JSON_STRING); //false 

Per favore, osserva che potrebbe esserci un problema “minore” dovuto alle virgole finali che verranno corrette nella versione 3.0.0 .

Con Google Gson puoi usare JsonParser:

 import com.google.gson.JsonParser; JsonParser parser = new JsonParser(); parser.parse(json_string); // throws JsonSyntaxException 

È ansible utilizzare .mayBeJSON (String str) disponibile nella libreria JSONUtils .

Dipende da ciò che stai cercando di dimostrare con la tua convalida. Certamente analizzare l’errore come altri hanno suggerito è meglio che usare espressioni regolari, perché la grammatica di json è più complicata di quanto possa essere rappresentata con le espressioni rege.

Se il json verrà analizzato solo dal codice java, utilizzare lo stesso parser per convalidarlo.

Ma solo l’analisi non ti dirà necessariamente se sarà accettata in altri ambienti. per esempio

  • molti parser ignorano le virgole finali in un object o array, ma le versioni precedenti di IE possono fallire quando colpiscono una virgola finale.
  • Altri parser possono accettare una virgola finale, ma aggiungono una voce non definita / nulla dopo di essa.
  • Alcuni parser possono consentire nomi di proprietà non quotate.
  • Alcuni parser possono reactjs in modo diverso ai caratteri non ASCII nelle stringhe.

Se la tua convalida deve essere molto approfondita, potresti:

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

Si prega di scaricare la libreria stringtree-json

Qui puoi trovare uno strumento che può validare un file JSON, o puoi semplicemente deserializzare il tuo file JSON con qualsiasi libreria JSON e se l’operazione ha successo allora dovrebbe essere valida (ad esempio, google-json genererà un’eccezione se l’input è l’analisi non è valido JSON).

Un po ‘sull’analisi:

JSON, e in effetti tutte le lingue, usano una grammatica che è un insieme di regole che possono essere usate come sostituzioni. al fine di analizzare JSON, è necessario sostanzialmente risolvere queste sostituzioni al contrario

Json è una grammatica libera dal contesto , nel senso che puoi avere oggetti / matrici infinitamente annidati e il json sarebbe comunque valido. regex gestisce solo grammatiche regolari (da qui il ‘reg’ nel nome), che è un sottoinsieme di grammatiche context free che non consente il nesting infinito, quindi è imansible usare solo regex per analizzare tutto il json valido. è ansible utilizzare un insieme complicato di regex e loop con l’ipotesi che nessuno possa annidare il passato, con 100 livelli di profondità, ma sarebbe comunque molto difficile.

se sei pronto per scrivere il tuo parser
potresti eseguire un parser di discesa ricorsivo dopo aver elaborato la grammatica

Usando Playframework 2.6, la libreria Json trovata nella java api può anche essere usata per analizzare semplicemente la stringa. La stringa può essere un elemento json di json array. Poiché il valore restituito non è importante qui, rileviamo solo l’errore di analisi per determinare se la stringa è una stringa json corretta o meno.

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

Ho trovato una soluzione molto semplice per questo.

Per prima cosa installa questa libreria net.sf.json-lib per questo.

  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 } 

Fatto. Godere

Le risposte sono parzialmente corrette. Ho anche affrontato lo stesso problema. L’analisi di JSON e il controllo dell’eccezione sembrano il solito modo, ma la soluzione non riesce per l’input JSON qualcosa del genere

{“outputValueSchemaFormat”: “”, “sortByIndexInRecord”: 0, “sortOrder”: 847874874387209 “discendente”} kajhfsadkjh

Come puoi vedere, JSON non è valido in quanto ci sono caratteri garbage finali. Ma se si tenta di analizzare il json precedente utilizzando jackson o gson, si otterrà la mappa analizzata del json valido e i caratteri finali della spazzatura verranno ignorati. Quale non è la soluzione richiesta quando si utilizza il parser per verificare la validità di JSON.

Per la soluzione a questo problema, vedere qui .

PS: questa domanda è stata fatta e ha risposto da me.