it-swarm.com.de

So prüfen Sie, ob eine angegebene Zeichenfolge in Java gültiger JSON ist

Wie überprüfe ich einen JSON-String in Java? Oder könnte ich es mit regulären Ausdrücken analysieren?

121
sappu

Eine wilde Idee, versuchen Sie es zu analysieren und fangen Sie die Ausnahme:

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

Dieser Code verwendet org.json JSON API-Implementierung, die auf github , in maven und teilweise auf Android verfügbar ist.

224
MByD

JACKSON Library

Eine Option wäre die Verwendung von Jackson library . Importiere zuerst die neueste Version (jetzt ist):

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

Dann können Sie die richtige Antwort wie folgt implementieren:

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-Option

Eine andere Option ist die Verwendung von Google Gson . Importieren Sie die Abhängigkeit:

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

Sie können die vorgeschlagene Lösung erneut folgendermaßen implementieren:

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

Ein einfacher Test folgt hier: 

//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

Bitte beachten Sie, dass es ein "kleineres" Problem geben kann, weil nachfolgende Kommas in Version 3.0.0 behoben werden.

71
JeanValjean

Mit Google Gson können Sie JsonParser verwenden:

import com.google.gson.JsonParser;

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

Sie können die .mayBeJSON (String str) verwenden, die in der JSONUtils - Bibliothek verfügbar ist.

11
npinti

Es hängt von dem ab, was Sie mit Ihrer Validierung zu beweisen versuchen. Das Parsen des Json ist sicherlich besser als das Verwenden von Regex, da die Grammatik von Json komplizierter ist, als dies mit Regex möglich ist.

Wenn der Json immer nur von Ihrem Java-Code analysiert wird, verwenden Sie denselben Parser, um ihn zu überprüfen.

Aber nur das Parsen sagt nicht unbedingt aus, ob es in anderen Umgebungen akzeptiert wird. z.B. 

  • viele Parser ignorieren nachfolgende Kommas in einem Objekt oder Array, aber alte Versionen von IE können fehlschlagen, wenn sie ein nachfolgendes Komma treffen. 
  • Andere Parser akzeptieren möglicherweise ein nachfolgendes Komma, fügen jedoch danach einen undefined/null-Eintrag hinzu.
  • Einige Parser lassen möglicherweise Eigenschaftsnamen ohne Anführungszeichen zu. 
  • Einige Parser reagieren möglicherweise anders auf Nicht-ASCII-Zeichen in Zeichenfolgen.

Wenn Ihre Validierung sehr gründlich sein muss, können Sie:

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

Bitte laden Sie stringtree-json library herunter

4
Jamsheer

Ein bisschen über das Parsing:

Json und eigentlich alle Sprachen verwenden eine Grammatik , die eine Reihe von Regeln ist, die als Substitutionen verwendet werden können. Um Json zu analysieren, müssen Sie diese Substitutionen grundsätzlich in umgekehrter Reihenfolge berechnen

Json ist eine kontextfreie Grammatik , das heißt, Sie können unendlich verschachtelte Objekte/Arrays haben und der Json wäre noch gültig. regex behandelt nur reguläre Grammatiken (daher das 'reg' im Namen). Hierbei handelt es sich um eine Untergruppe kontextfreier Grammatiken, die keine unendliche Verschachtelung zulassen. Daher ist es unmöglich, nur regex zum Parsen aller gültigen Json-Werte zu verwenden. Sie könnten einen komplizierten Satz von Regex und Schleifen verwenden, mit der Annahme, dass sich niemand vorbeischauen lässt, sagen wir 100 Ebenen tief, aber es wäre immer noch sehr schwierig.

wenn Sie bereit sind, Ihren eigenen Parser zu schreiben
Sie könnten einen rekursiven Abstiegsparser erstellen, nachdem Sie die Grammatik erarbeitet haben

2
Austin_Anderson

Überprüfen Sie, ob eine bestimmte Zeichenfolge in Kotlin gültig ist. Ich habe Antwort von MByD Java nach Kotlin konvertiert

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

Mit Playframework 2.6 kann die Json-Bibliothek in der Java-API ebenfalls verwendet werden, um die Zeichenfolge einfach zu analysieren. Die Zeichenfolge kann entweder ein Json-Element eines Json-Arrays sein. Da der zurückgegebene Wert hier nicht von Bedeutung ist, fangen wir nur den Parser-Fehler, um festzustellen, ob der String ein korrekter Json-String ist oder nicht.

    import play.libs.Json;

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

Hier finden Sie ein tool , das eine JSON-Datei validieren kann, oder Sie können Ihre JSON-Datei mit einer beliebigen JSON-Bibliothek deserialisieren. Wenn die Operation erfolgreich ist, sollte sie gültig sein (beispielsweise google-json ) das wird eine Ausnahme auslösen, wenn die Eingabe, die es analysiert, kein gültiger JSON ist).

1
talnicolas
import static net.minidev.json.JSONValue.isValidJson;

und dann rufen Sie diese Funktion in Ihrem JSON-String auf :)

0
Jason

Hier ist ein funktionierendes Beispiel für striktes JSON-Parsen mit gson library:

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

Siehe auch meine andere ausführliche Antwort in So überprüfen Sie, ob JSON in Java unter Verwendung von GSON gültig ist mit weiteren Informationen und einem erweiterten Testfall mit verschiedenen ungültigen Beispielen.

0
Vadzim

IMHO ist die eleganteste Methode die Verwendung von Java-API für JSON-Verarbeitung (JSON-P), einer der JavaEE-Standards, die dem JSR 374 entsprechen.

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

Fügen Sie mit Maven die Abhängigkeit von JSON-P hinzu:

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

Besuchen Sie die offizielle Seite von JSON-P für weitere Informationen.

0
Domenico

Eine Lösung mit der javax.json Bibliothek:

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
yper
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.");
        }
    }
}

Die obige Lösung deckt beide Szenarien ab: 

  • zweitschlüssel
  • nicht übereinstimmende Anführungszeichen oder fehlende Klammern usw.
0
Shailendra

Die Antworten sind teilweise richtig. Ich stand auch vor dem gleichen Problem. Das Parsen des Json und das Überprüfen auf Ausnahmen scheint der übliche Weg zu sein, aber die Lösung schlägt für den Input-Json so etwas fehl

{"outputValueSchemaFormat": "", "sortByIndexInRecord": 0, "sortOrder": 847874874387209 "absteigend"} kajhfsadkjh

Wie Sie sehen können, ist der Json ungültig, da nachstehende Müllzeichen vorhanden sind. Wenn Sie jedoch versuchen, den obigen Json mit Jackson oder Gson zu analysieren, erhalten Sie die geparste Karte des gültigen Json, und die nachfolgenden Zeichen werden ignoriert. Dies ist nicht die erforderliche Lösung, wenn Sie den Parser zum Überprüfen der Json-Gültigkeit verwenden. 

Zur Lösung dieses Problems siehe hier

PS: Diese Frage wurde von mir gestellt und beantwortet. 

0
iec2011007

Ich habe eine sehr einfache Lösung dafür gefunden. 

Bitte installieren Sie zuerst diese Bibliothek net.sf.json-lib dafür.

    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
    }

Erledigt. Genießen

0
Atif Mehar