Lorsque vous disposez de données au format JSON, vous souhaiterez peut-être vérifier si les données sont écrites selon des règles prédéterminées. Un standard appelé le schéma JSON a été développé à cet effet.
À titre d'exemple, considérons les données au format JSON suivantes.
person.json
{
"name": "Yamada Taro",
"age": 42,
"hobbies": ["base-ball", "judo"]
}
Dans le schéma JSON, les données au format JSON soumises à validation sont appelées une instance JSON. Ici, nous voulons définir les restrictions suivantes sur l'instance JSON ci-dessus qui représente «personne».
name est une chaînehobbies est un tableau et le type d'élément est une chaîne.name ne peut pas être omiseLe schéma JSON exprime ces contraintes comme suit: Le schéma JSON lui-même est également écrit au format JSON.
json:person.schema.json
{
"type": "object",
"properties": {
"name": {
"type": "string"
},
"age": {
"type": "integer",
"minimum": 0
},
"hobbies": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["name"]
}
La spécification de schéma JSON est développée par json-schema-org. La dernière spécification au moment de la rédaction de cet article est Draft-07.
Maintenant validons réellement l'instance JSON selon le schéma JSON. Le code suivant est écrit en Java.
Dans cet article, nous utiliserons Justify comme bibliothèque pour la validation JSON. Cette bibliothèque utilise l'interface du package javax.json fournie par [API Java pour le traitement JSON (JSR 374)] comme pour le chargement des instances JSON. Pour cette raison, les utilisateurs d'API n'ont pas besoin d'être très conscients de la validation.
Ajoutez les deux fichiers suivants en tant que fichiers dépendants à l'application Java à valider. Ceci est un exemple lorsque Maven est utilisé comme outil de construction.
pom.xml
<!--Corps de la bibliothèque-->
<dependency>
<groupId>org.leadpony.justify</groupId>
<artifactId>justify</artifactId>
<version>2.0.0</version>
</dependency>
<!--Implémentation de l'API Java pour le traitement JSON-->
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>jakarta.json</artifactId>
<classifier>module</classifier>
<version>1.1.6</version>
</dependency>
Le deuxième fichier de dépendances est un exemple d'utilisation de Implémentation de référence comme implémentation de [API Java pour le traitement JSON (JSR 374)]. Il est prudent de le remplacer par une autre implémentation compatible telle que Apache Johnzon.
Il existe deux types d'API dans [API Java pour le traitement JSON (JSR 374)]: l'API de streaming et l'API de modèle d'objet. Tout d'abord, validons l'instance JSON à l'aide de l'API de streaming.
Dans l'API de streaming, le contrôle est renvoyé à l'appelant sous forme d'unités de petits événements qui se produisent lors de la lecture de JSON, tels que le début d'un objet, le nom d'une propriété, la valeur d'une propriété, etc. Utilisez l'interface javax.json.stream.JsonParser pour charger l'instance JSON.
import java.nio.file.Paths;
import javax.json.stream.JsonParser;
import org.leadpony.justify.api.JsonSchema;
import org.leadpony.justify.api.JsonValidationService;
import org.leadpony.justify.api.ProblemHandler;
//Créez un service de validation.
JsonValidationService service = JsonValidationService.newInstance();
//Lisez le schéma JSON à partir du fichier.
JsonSchema schema = service.readSchema(Paths.get("person.schema.json"));
//Un gestionnaire qui gère les problèmes détectés lors de la validation.
//Ici, uniquement sortie vers la sortie standard.
ProblemHandler handler = service.createProblemPrinter(System.out::println);
//Créez un analyseur pour lire l'instance JSON.
try (JsonParser parser = service.createParser(Paths.get("person.json"), schema, handler)) {
//Gérer tous les événements de l'analyseur
while (parser.hasNext()) {
//Événement d'analyseur qui s'est produit
JsonParser.Event event = parser.next();
//Gérez les événements.
doSomethingUseful(event);
}
}
À titre de test, essayez de saisir une instance JSON non valide comme suit.
person-bad.json
{
"age": -1,
"hobbies": ["base-ball", "judo"]
}
Les problèmes détectés lors de la validation sont affichés comme suit:
[2 lignes,13 rangées]Le nombre doit être supérieur ou égal à 0.
[4 lignes,1 rangée]L'objet est une propriété"name"Doit avoir.
Si les paramètres régionaux d'exécution sont japonais, le message d'erreur sera également japonais.
Ensuite, examinons un exemple de code utilisant l'API de modèle d'objet.
Dans l'API de modèle d'objet, la lecture d'un JSON crée l'ensemble de l'objet ou du tableau JSON en mémoire. Utilisez l'interface javax.json.JsonReader pour charger l'instance JSON.
import java.nio.file.Paths;
import javax.json.JsonObject;
import javax.json.JsonReader;
import org.leadpony.justify.api.JsonSchema;
import org.leadpony.justify.api.JsonValidationService;
import org.leadpony.justify.api.ProblemHandler;
//Créez un service de validation.
JsonValidationService service = JsonValidationService.newInstance();
//Lisez le schéma JSON à partir du fichier.
JsonSchema schema = service.readSchema(Paths.get("person.schema.json"));
//Un gestionnaire qui gère les problèmes détectés lors de la validation.
//Ici, uniquement sortie vers la sortie standard.
ProblemHandler handler = service.createProblemPrinter(System.out::println);
//Créez un lecteur pour lire l'instance JSON.
try (JsonReader reader = service.createReader(Paths.get("person.json"), schema, handler)) {
//Lire un objet JSON
JsonObject object = reader.readObject();
//Traitez l'objet JSON lu.
doSomethingUseful(object);
}
Même dans le cas de l'API de modèle d'objet, lorsqu'un problème est détecté dans l'instance JSON, un message d'erreur similaire à l'API de streaming est généré.
Java a Java API for JSON Binding (JSR 367) comme spécification d'API pour convertir directement une instance JSON en POJO (Plain Old Java Object). Enfin, validons une instance JSON à l'aide de cette API.
Puisque nous utilisons Yasson comme implémentation de [API Java pour JSON Binding (JSR 367)], ajoutez ceci en tant que fichier dépendant.
pom.xml
<!--Implémentation de l'API Java pour la liaison JSON-->
<dependency>
<groupId>org.eclipse</groupId>
<artifactId>yasson</artifactId>
<version>1.0.2</version>
</dependency>
Ensuite, définissez la classe Person comme POJO de destination.
public class Person {
public String name;
public int age;
public List<String> hobbies;
}
Le code de validation ressemble à ceci:
import java.nio.file.Paths;
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;
import javax.json.spi.JsonProvider;
import org.leadpony.justify.api.JsonSchema;
import org.leadpony.justify.api.JsonValidationService;
//Créez un service de validation.
JsonValidationService service = JsonValidationService.newInstance();
//Lisez le schéma JSON à partir du fichier.
JsonSchema schema = service.readSchema(Paths.get("person.schema.json"));
//Créez une instance de JsonProvider.
JsonProvider provider = service.createJsonProvider(
schema,
parser->service.createProblemPrinter(System.out::println));
//Créez une instance de Jsonb.
Jsonb jsonb = JsonbBuilder.newBuilder().withProvider(provider).build();
//Ouvrez une instance JSON en tant que flux d'entrée.
try (InputStream stream = Files.newInputStream(Paths.get("person.json"))) {
//Convertissez une instance JSON en objet Person.
Person person = jsonb.fromJson(stream, Person.class);
//Traitez l'objet Personne.
doSomethingUseful(person);
}
Semblable au code introduit jusqu'à présent, si un problème est détecté dans l'instance JSON que vous avez entrée, un message d'erreur sera imprimé.
Pour les validateurs JSON basés sur la spécification de schéma JSON, la dernière liste est fournie dans [Implémentations] sur json-schema.org, y compris pour les langages de programmation autres que Java. Le [Justifier] présenté dans cet article a été développé par moi-même.
Recommended Posts