Comment vérifier si une chaîne donnée est JSON valide en Java

Bibliothèque JACKSON

, Une option serait d'utiliser Jackson bibliothèque. Importez d'abord la dernière version (maintenant):

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

Ensuite, vous pouvez mettre en œuvre la réponse correcte comme suit:

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

L'option Google GSON

Une autre option consiste à utiliser Google Gson. Importer la dépendance:

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

Encore une fois, vous pouvez implémenter la solution proposée comme:

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 test simple suit ici:

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

Veuillez noter qu'il pourrait y avoir un problème "mineur" dû aux virgules de fin qui seront corrigées dans la version 3.0.0.

Avec Google Gson vous pouvez utiliser JsonParser:

import com.google.gson.JsonParser;

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

Vous pouvez utiliser le .mayBeJSON (String str) disponible dans la bibliothèque JSONUtils.

Cela dépend de ce que vous essayez de prouver avec votre validation. Il est certainement préférable d'analyser le json comme d'autres l'ont suggéré que d'utiliser des expressions régulières, car la grammaire de json est plus compliquée que ce qui peut être représenté avec des expressions régulières.

Si le json ne sera analysé que par votre code java, utilisez le même analyseur pour le valider.

Mais juste l'analyse ne vous dira pas nécessairement si elle sera acceptée dans d'autres environnements. par exemple

• de nombreux analyseurs ignorent virgules de fin dans un objet ou un tableau, mais les anciennes versions d'IE peuvent échouer lorsqu'elles frappent une virgule de fin.
• D'autres analyseurs peuvent accepter une virgule de fin, mais ajouter une entrée undefined/null après.
• Certains analyseurs peuvent autoriser des noms de propriété non cotés.
• Certains analyseurs peuvent réagir différemment aux caractères non-ASCII dans les chaînes.

Si votre validation doit être très approfondie, vous pouvez:

• essayez différents analyseurs jusqu'à ce que vous en trouviez un qui échoue sur tous les cas d'angle que j'ai mentionnés ci-dessus
• ou vous pourriez probablement exécuter jsonlint en utilisant javax.script.*,
  • http://npmjs.org/package/jsonlint
• ou combiner en utilisant un analyseur avec l'exécution de jshint en utilisant javax.script.*.
  • https://www.npmjs.org/package/jshint
  • https://github.com/webjars/jshint

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

S'il vous Plaît télécharger stringtree-json bibliothèque

Ici, vous pouvez trouver unoutil qui peut valider un fichier JSON, ou vous pouvez simplement désérialiser votre fichier JSON avec n'importe quelle bibliothèque JSON et si l'opération réussit, il devrait être valide (google-json par exemple qui lèvera une exception si l'entrée qu'il analyse n'est pas JSON valide).

Un peu d'analyse:

Json, et en fait toutes les langues, utilisent une grammar qui est un ensemble de règles pouvant être utilisées comme substitutions. afin d'analyser json, vous devez essentiellement travailler sur ces substitutions en sens inverse

Json est une grammaire sans contexte, ce qui signifie que vous pouvez avoir des objets/tableaux imbriqués à l'infini et que le json serait toujours valide. regex ne gère que grammaires régulières (d'où le ' reg ' dans le nom), qui est un sous-ensemble de contexte grammaires libres qui ne permettent pas l'imbrication infinie, il est donc impossible d'utiliser uniquement regex pour analyser tous les json valides. vous pouvez utiliser un ensemble compliqué de regex et de boucles avec l'hypothèse que personne ne nichera au-delà, disons, de 100 niveaux de profondeur, mais ce serait toujours très difficile.

Si vous êtes prêt à écrire votre propre analyseur
vous pouvez créer un analyseur de descente récursif après avoir travaillé la grammaire

En utilisant Playframework 2.6, la bibliothèque Json trouvée dans l'api java peut également être utilisée pour analyser simplement la chaîne. La chaîne peut être un élément json du tableau json. Puisque la valeur renvoyée n'a pas d'importance ici, nous attrapons simplement l'erreur d'analyse pour déterminer que la chaîne est une chaîne json correcte ou non.

    import play.libs.Json;

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

J'ai trouvé une solution très simple pour elle.

Veuillez d'abord installer cette bibliothèque net.sf.json-lib pour elle.

    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
    }

Terminé. Profitez de

Les réponses sont partiellement correctes. J'ai également fait face au même problème. Analyser le json et vérifier l'exception semble la manière habituelle mais la solution échoue pour le json d'entrée quelque chose comme

{"outputValueSchemaFormat": "","sortByIndexInRecord": 0,"sortOrder":847874874387209"décroissant"}kajhfsadkjh

Comme vous pouvez le voir, le json n'est pas valide car il y a des caractères garbage à la fin. Mais si vous essayez d'analyser le json ci dessus en utilisant jackson ou gson alors vous obtiendrez le la carte analysée des caractères de fin json et garbage valides est ignorée. Ce qui n'est pas la solution requise lorsque vous utilisez l'analyseur de vérifier json validité.

Pour solution à ce problème, voir ici.

PS: Cette question a été posée et j'ai répondu.

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

Puis appelez cette fonction en passant dans votre chaîne JSON:)