web-dev-qa-db-fra.com

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

Comment valider une chaîne JSON en Java? Ou pourrais-je analyser à l'aide d'expressions régulières?

javajsonvalidation
121
sappu

Une idée folle, essayez de l'analyser et attrapez l'exception:

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

Ce code utilise org.json L'implémentation de l'API JSON disponible sur github , dans maven et partiellement sur Android .

224
MByD

Bibliothèque JACKSON

Une option serait d'utiliser Jackson library . 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 implémenter 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;
    }
  }
}

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>

Là encore, vous pouvez implémenter la solution proposée en tant que:

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

Notez qu’il peut y avoir un problème "mineur" en raison des virgules de fin qui seront résolus dans la version 3.0.0.

71
JeanValjean

Avec Google Gson vous pouvez utiliser JsonParser:

import com.google.gson.JsonParser;

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

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

11
npinti

Cela dépend de ce que vous essayez de prouver avec votre validation ..__ Certes, analyser le json comme le suggèrent d’autres est préférable à l’utilisation de regex, car la grammaire de json est plus compliquée que celle représentée par de simples regex.

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

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

  • de nombreux analyseurs ignorent les virgules de fin dans un objet ou un tableau, mais les anciennes versions de IE peuvent échouer quand ils frappent une virgule de fin. 
  • D'autres analyseurs peuvent accepter une virgule de fin, mais ajouter une entrée non définie/nulle après celle-ci.
  • Certains analyseurs peuvent autoriser les noms de propriété sans guillemets. 
  • 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:

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 !!");

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

4
Jamsheer

Un peu d'analyse:

Json, et en fait toutes les langues, utilisent un grammaire 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 dépourvue de contexte, ce qui signifie que vous pouvez avoir des objets/des tableaux infiniment imbriqués 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 grammaires sans contexte qui ne permettent pas d'imbrication infinie, il est donc impossible d'utiliser uniquement regex pour analyser tous les json . vous pouvez utiliser un ensemble compliqué de regex et de boucles en supposant que personne ne fera son nid passé, par exemple, à une profondeur de 100 niveaux, mais ce serait tout de même très difficile.

si vous êtes prêt à écrire votre propre analyseur
vous pourriez faire un analyseur récursif de descente après avoir travaillé la grammaire

2
Austin_Anderson

Vérifiez si une chaîne donnée est un JSON valide dans Kotlin . J'ai converti la réponse de MByD Java en Kotlin

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

Avec Playframework 2.6, la bibliothèque Json présente dans l’API Java peut également être utilisée pour analyser simplement la chaîne. La chaîne peut être soit un élément json du tableau json. Étant donné que la valeur renvoyée n’a pas d’importance ici, nous saisissons simplement l’erreur d’analyse pour déterminer si 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;
        }
    }
1
Baah

Ici vous pouvez trouver un tool 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, elle devrait être valide ( google-json par exemple qui lève une exception si l’entrée à analyser est un JSON non valide).

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

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

0
Jason

Voici un exemple pratique d’analyse syntaxique JSON stricte avec la bibliothèque gson :

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

Voir aussi mon autre réponse détaillée dans Comment vérifier si JSON est valide dans Javaà l'aide de GSON avec plus d'informations et un scénario de test étendu avec divers exemples non valides.

0
Vadzim

IMHO, la méthode la plus élégante consiste à utiliser la API Java pour le traitement JSON (JSON-P), l'un des standards JavaEE conformes à la 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();
}

A l’aide de Maven, ajoutez la dépendance à JSON-P:

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

Visitez la page officielle de JSON-P pour plus d'informations.

0
Domenico

Une solution utilisant la bibliothèque 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;
}
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.");
        }
    }
}

La solution ci-dessus couvre à la fois les scénarios: 

  • clé en double
  • citations mal assorties ou parenthèses manquantes, etc.
0
Shailendra

Les réponses sont partiellement correctes. J'ai aussi fait face au même problème. L'analyse du json et la recherche d'une exception semblent être la méthode habituelle, mais la solution échoue pour l'entrée json.

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

Comme vous pouvez le constater, le json est invalide car il y a des caractères de fin de mémoire. Mais si vous essayez d'analyser le json ci-dessus à l'aide de jackson ou de gson, vous obtiendrez la carte analysée du json valide et les caractères de fin de lecture erronée seront ignorés. Ce qui n’est pas la solution requise lorsque vous utilisez l’analyseur pour vérifier la validité de json. 

Pour résoudre ce problème, voir ici . 

PS: Cette question a été posée et a répondu par moi. 

0
iec2011007

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

S'il vous plaît installer d'abord 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é. Prendre plaisir

0
Atif Mehar