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

JACKSON Library

Une option serait d'utiliser Jackson bibliothèque . Première importation de la dernière version (est maintenant):

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

alors, vous pouvez mettre en œuvre le 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;
    }
  }
}

Google Gson option

une Autre option est d'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 mettre en œuvre 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 guillemets qui seront corrigés 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) disponible dans la bibliothèque JSONUtils .

Cela dépend de ce que vous essayez de prouver avec votre validation. Il est certain que Parser le json comme d'autres l'ont suggéré est mieux que d'utiliser des regexes, parce que la grammaire de json est plus compliquée que ne peut être représenté avec juste des regexes.

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

mais simplement parsing ne vous dira pas nécessairement si elle sera acceptée dans d'autres environnements. par exemple

• beaucoup de parseurs ignorent les virgules traînantes dans un objet ou un tableau, mais les anciennes versions D'IE peuvent échouer quand elles frappent une virgule traînante.
• Autres analyseurs peuvent accepter une virgule, mais ajouter un indéfini/null entrée 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 la validation doit être très minutieuse, vous pourriez:

• Essayez différents parsers jusqu'à ce que vous trouviez un qui échoue sur tous les cas de coin que j'ai mentionnés ci-dessus
• ou vous pouvez probablement lancer jsonlint en utilisant javax.script.*,
  • http://npmjs.org/package/jsonlint
• ou combiner l'utilisation d'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 un outil qui peut valider un fichier JSON, ou vous pouvez tout simplement deserialiser votre fichier JSON avec n'importe quelle bibliothèque JSON et si l'opération est réussie alors il devrait être valide ( google-json par exemple qui lancera une exception si l'entrée qu'il analyse n'est pas valide JSON).

un peu sur le parsing:

Json, et en fait toutes les langues, l'utilisation d'un grammaire qui est un ensemble de règles qui peuvent être utilisés comme des substitutions. pour analyser json, vous avez besoin de travailler sur ces substitutions à l'envers

Json est un context free grammar , ce qui signifie que vous pouvez avoir des objets/tableaux imbriqués à l'infini et le json serait encore valide. poignées seulement regex grammaires régulières (d'où le 'reg' dans le nom), qui est un sous-ensemble de grammaires libres de contexte qui ne permet pas l'imbrication infinie, il est donc impossible d'utiliser seulement regex pour analyser tous les JSON valides. vous pourriez utiliser un ensemble compliqué de regex et boucles avec l'hypothèse que personne ne va nicher au-delà de dire, 100 niveaux de profondeur, mais il serait encore très difficile.

si vous êtes prêt à écrire votre propre parser

vous pourriez faire un parser de descente récursive après avoir établi la grammaire

en utilisant Playfram Framework 2.6, la bibliothèque Json trouvée dans l'api java peut aussi être utilisée pour simplement analyser la chaîne. La chaîne peut être soit un élément json de JSON array. Depuis la valeur retournée n'est pas d'importance ici, nous voulons juste rattraper l'erreur d'analyse pour déterminer que la chaîne est une bonne chaîne json ou pas.

    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 .

    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
    }

fait. Profiter 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 "descendent"} kajhfsadkjh

comme vous pouvez le voir le json est invalide car il y a des caractères d'ordures traînants. Mais si vous essayez d'analyser la au-dessus de json en utilisant jackson ou gson alors vous obtiendrez la carte commentée des caractères valides JSON et garbage trailing sont ignorés. 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 répondu par moi.

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

et ensuite appeler cette fonction passant dans votre chaîne JSON:)