Jak sprawdzić, czy dany łańcuch jest poprawny JSON w Javie

Biblioteka Jacksona

Jedną z opcji byłoby użycie Biblioteki Jacksona. Najpierw zaimportuj najnowszą wersję (teraz jest):

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

Następnie możesz zaimplementować poprawną odpowiedź w następujący sposób:

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

Opcja Google GSON

Inną opcją jest użycie Google Gson. Import zależności:

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

Ponownie można wdrożyć proponowane rozwiązanie jako:

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

Oto prosty test:

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

Proszę zauważyć, że może wystąpić "drobny" problem z powodu końcowych przecinków, które zostaną naprawione w wydaniu 3.0.0.

Z Google Gson możesz użyć JsonParser:

import com.google.gson.JsonParser;

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

Możesz użyć .mayBeJSON (String str) dostępny w bibliotece JSONUtils .

To zależy od tego, co próbujesz udowodnić swoją walidacją. Z pewnością parsowanie json, jak sugerowali inni, jest lepsze niż używanie wyrażeń regularnych, ponieważ gramatyka json jest bardziej skomplikowana niż może być reprezentowana tylko wyrażeniami regularnymi.

Jeśli json będzie kiedykolwiek parsowany tylko przez Twój kod java, użyj tego samego parsera, aby go zweryfikować.

Ale samo parsowanie niekoniecznie powie Ci, czy będzie akceptowane w innych środowiskach. np.

• Wiele parserów ignoruje końcowe przecinki w obiekcie lub tablicy, ale stare wersje IE mogą się nie udać, gdy trafią końcowy przecinek.
• Inne parsery mogą akceptować końcowy przecinek, ale dodają po nim niezdefiniowany / null wpis.
• niektóre parsery mogą zezwalać na niecytowane nazwy właściwości.
• niektóre parsery mogą reagować inaczej na znaki spoza ASCII w łańcuchach.

Jeśli twoja Walidacja musi być bardzo dokładna, możesz:

• Wypróbuj różne parsery, aż znajdziesz taki, który zawiedzie na wszystkich narożniki, o których wspomniałem powyżej
• lub prawdopodobnie możesz uruchomić jsonlint używając javax.scenariusz.*,
  • http://npmjs.org/package/jsonlint
• lub połączyć za pomocą parsera z uruchomieniem jshint za pomocą javax.scenariusz.*.
  • 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 !!");

Proszę pobrać stringtree-JSON biblioteka

Tutaj można znaleźć narzędzie , które może zweryfikować plik JSON, lub po prostu deserializować plik JSON z dowolną biblioteką JSON i jeśli operacja się powiedzie, to powinien być poprawny (google-json na przykład, który rzuci wyjątek, jeśli Dane wejściowe, które analizuje, nie są poprawne JSON).

Trochę o parsowaniu:

Json, a właściwie wszystkie języki, używają gramatyki, która jest zbiorem reguł, które mogą być używane jako podstawienia. aby przetworzyć json, musisz zasadniczo opracować te podstawienia w odwrotnej kolejności

Json jest gramatyką bezkontekstową , co oznacza, że możesz mieć nieskończenie zagnieżdżone obiekty/tablice, a json nadal będzie ważny. regex obsługuje tylko gramatyki regularne (stąd 'reg' w nazwie), które są podzbiorem kontekstu wolne gramatyki, które nie pozwalają na nieskończone zagnieżdżanie, więc nie można używać tylko regex do parsowania wszystkich poprawnych json. możesz użyć skomplikowanego zestawu regex i pętli z założeniem, że nikt nie zagnieździ się poza powiedzmy, 100 poziomami głęboko, ale nadal byłoby to bardzo trudne.

Jeśli chcesz napisać własny parser
możesz utworzyć rekurencyjny Parser zejścia po opracowaniu gramatyki

Używając Playframework 2.6, biblioteka Json znaleziona w java api może być również używana do prostego przetwarzania ciągu znaków. Łańcuch może być elementem JSON tablicy JSON. Ponieważ zwracana wartość nie ma tutaj znaczenia, po prostu wyłapujemy błąd parse, aby ustalić, że łańcuch jest poprawnym łańcuchem json, czy nie.

    import play.libs.Json;

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

Znalazłem na to bardzo proste rozwiązanie.

Proszę najpierw zainstalować tę bibliotekę 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
    }

Odpowiedzi są częściowo poprawne. Ja również stanąłem przed tym samym problemem. Parsowanie json i sprawdzanie WYJĄTKÓW wydaje się zwyczajowym sposobem, ale rozwiązanie nie powiedzie się dla wejściowego json coś w stylu

{"outputValueSchemaFormat": "","sortByIndexInRecord": 0,"sortOrder":847874874387209"malejąco"}kajhfsadkjh

Jak widać json jest nieprawidłowy, ponieważ istnieją końcowe znaki śmieci. Ale jeśli spróbujesz przeanalizować powyższy json używając Jacksona lub gson, otrzymasz przetworzona Mapa poprawnych znaków końcowych json i garbage jest ignorowana. Nie jest to wymagane rozwiązanie, gdy używasz parsera do sprawdzania poprawności json.

Rozwiązanie tego problemu zobacz tutaj .

PS: na to pytanie odpowiedziałem ja.

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

A następnie wywołaj tę funkcję przechodzącą w łańcuch JSON:)