Groovy - JSON

Ce chapitre explique comment utiliser le langage Groovy pour analyser et produire des objets JSON.

Fonctions JSON

Sr.Non Fonctions et bibliothèques
1

JsonSlurper

JsonSlurper est une classe qui analyse le texte JSON ou le contenu du lecteur en données Groovy

Structures telles que les cartes, les listes et les types primitifs tels que Integer, Double, Boolean et String.
2

JsonOutput

Cette méthode est responsable de la sérialisation des objets Groovy dans des chaînes JSON.

Analyse des données à l'aide de JsonSlurper

JsonSlurper est une classe qui analyse le texte JSON ou le contenu du lecteur dans des structures de données Groovy telles que des cartes, des listes et des types primitifs tels que Integer, Double, Boolean et String.

Syntaxe

def slurper = new JsonSlurper()

JSON slurper analyse le texte ou le contenu du lecteur dans une structure de données de listes et de cartes.

La classe JsonSlurper est fournie avec quelques variantes pour les implémentations d'analyseur. Parfois, vous pouvez avoir des exigences différentes en ce qui concerne l'analyse de certaines chaînes. Prenons un exemple dans lequel il faut lire le JSON qui est renvoyé par la réponse d'un serveur Web. Dans un tel cas, il est avantageux d'utiliser la variante de l'analyseur JsonParserLax. Cet analyseur autorise les commentaires dans le texte JSON ainsi que les chaînes sans guillemets, etc. Pour spécifier ce type d'analyseur, vous devez utiliser le type d'analyseur JsonParserType.LAX lors de la définition d'un objet du JsonSlurper.

Voyons un exemple de cela ci-dessous. L'exemple est pour obtenir des données JSON à partir d'un serveur Web à l'aide du module http. Pour ce type de parcours, la meilleure option est d'avoir le type d'analyseur défini sur la variante JsonParserLax.

http.request( GET, TEXT ) {
   headers.Accept = 'application/json'
   headers.'User-Agent' = USER_AGENT
	
   response.success = { 
      res, rd ->  
      def jsonText = rd.text 
		
      //Setting the parser type to JsonParserLax
      def parser = new JsonSlurper().setType(JsonParserType.LAX)
      def jsonResp = parser.parseText(jsonText)
   }
}

De même, les types d'analyseurs supplémentaires suivants sont disponibles dans Groovy -

  • L'analyseur JsonParserCharArray prend essentiellement une chaîne JSON et opère sur le tableau de caractères sous-jacent. Pendant la conversion de valeur, il copie les sous-tableaux de caractères (un mécanisme connu sous le nom de "hachage") et opère sur eux individuellement.

  • Le JsonFastParser est une variante spéciale du JsonParserCharArray et est l'analyseur le plus rapide. JsonFastParser est également connu comme l'analyseur de superposition d'index. Pendant l'analyse de la chaîne JSON donnée, il essaie aussi fort que possible d'éviter de créer de nouveaux tableaux de caractères ou des instances de chaîne. Il ne conserve que les pointeurs vers le tableau de caractères d'origine sous-jacent uniquement. De plus, il reporte la création d'objet le plus tard possible.

  • Le JsonParserUsingCharacterSource est un analyseur spécial pour les fichiers très volumineux. Il utilise une technique appelée «fenêtrage de caractères» pour analyser les gros fichiers JSON (gros signifie fichiers de plus de 2 Mo dans ce cas) avec des caractéristiques de performances constantes.

Analyse du texte

Jetons un coup d'œil à quelques exemples d'utilisation de la classe JsonSlurper.

import groovy.json.JsonSlurper 

class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def object = jsonSlurper.parseText('{ "name": "John", "ID" : "1"}') 
		
      println(object.name);
      println(object.ID);
   } 
}

Dans l'exemple ci-dessus, nous sommes -

  • Créer d'abord une instance de la classe JsonSlurper

  • Nous utilisons ensuite la fonction parseText de la classe JsonSlurper pour analyser du texte JSON.

  • Lorsque nous obtenons l'objet, vous pouvez voir que nous pouvons réellement accéder aux valeurs de la chaîne JSON via la clé.

La sortie du programme ci-dessus est donnée ci-dessous -

John 
1

Analyse de la liste des nombres entiers

Jetons un coup d'œil à un autre exemple de la méthode d'analyse JsonSlurper. Dans l'exemple suivant, nous passons une liste d'entiers. Vous remarquerez à partir du code suivant que nous sommes en mesure d'utiliser la méthode List de chacun et de lui passer une fermeture.

import groovy.json.JsonSlurper 
class Example {
   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      Object lst = jsonSlurper.parseText('{ "List": [2, 3, 4, 5] }')
      lst.each { println it }
   } 
}

La sortie du programme ci-dessus est donnée ci-dessous -

List=[2, 3, 4, 5]

Analyse de la liste des types de données primitives

L'analyseur JSON prend également en charge les types de données primitifs de chaîne, nombre, objet, vrai, faux et nul. La classe JsonSlurper convertit ces types JSON en types Groovy correspondants.

L'exemple suivant montre comment utiliser JsonSlurper pour analyser une chaîne JSON. Et ici, vous pouvez voir que JsonSlurper est capable d'analyser les éléments individuels dans leurs types primitifs respectifs.

import groovy.json.JsonSlurper 
class Example {

   static void main(String[] args) {
      def jsonSlurper = new JsonSlurper()
      def obj = jsonSlurper.parseText ''' {"Integer": 12, "fraction": 12.55, "double": 12e13}'''
		
      println(obj.Integer);
      println(obj.fraction);
      println(obj.double); 
   } 
}

La sortie du programme ci-dessus est donnée ci-dessous -

12 
12.55 
1.2E+14

JsonOutput

Voyons maintenant comment imprimer la sortie dans Json. Cela peut être fait par la méthode JsonOutput. Cette méthode est responsable de la sérialisation des objets Groovy dans des chaînes JSON.

Syntaxe

Static string JsonOutput.toJson(datatype obj)

Parameters - Les paramètres peuvent être un objet d'un type de données - Nombre, Booléen, caractère, Chaîne, Date, Carte, fermeture etc.

Return type - Le type de retour est une chaîne json.

Exemple

Voici un exemple simple de la manière dont cela peut être réalisé.

import groovy.json.JsonOutput 
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([name: 'John', ID: 1])
      println(output);  
   }
}

La sortie du programme ci-dessus est donnée ci-dessous -

{"name":"John","ID":1}

Le JsonOutput peut également être utilisé pour de vieux objets groovy simples. Dans l'exemple suivant, vous pouvez voir que nous transmettons en fait des objets du type Student à la méthode JsonOutput.

import groovy.json.JsonOutput  
class Example {
   static void main(String[] args) {
      def output = JsonOutput.toJson([ new Student(name: 'John',ID:1),
         new Student(name: 'Mark',ID:2)])
      println(output);  
   } 
}
 
class Student {
   String name
   int ID; 
}

La sortie du programme ci-dessus est donnée ci-dessous -

[{"name":"John","ID":1},{"name":"Mark","ID":2}]