Groovy - JSON

Questo capitolo spiega come utilizzare il linguaggio Groovy per analizzare e produrre oggetti JSON.

Funzioni JSON

Suor n Funzioni e librerie
1

JsonSlurper

JsonSlurper è una classe che analizza il testo JSON o il contenuto del lettore in dati Groovy

Strutture come mappe, elenchi e tipi primitivi come Integer, Double, Boolean e String.
2

JsonOutput

Questo metodo è responsabile della serializzazione di oggetti Groovy in stringhe JSON.

Analisi dei dati utilizzando JsonSlurper

JsonSlurper è una classe che analizza il testo JSON o il contenuto del lettore in strutture dati Groovy come mappe, elenchi e tipi primitivi come Integer, Double, Boolean e String.

Sintassi

def slurper = new JsonSlurper()

Lo slurper JSON analizza il testo o il contenuto del lettore in una struttura di dati di elenchi e mappe.

La classe JsonSlurper viene fornita con un paio di varianti per le implementazioni del parser. A volte potresti avere requisiti diversi quando si tratta di analizzare determinate stringhe. Prendiamo un'istanza in cui è necessario leggere il JSON restituito dalla risposta da un server web. In tal caso è utile utilizzare la variante parser JsonParserLax. Questo parsee consente commenti nel testo JSON così come nessuna stringa di virgolette ecc. Per specificare questo tipo di parser è necessario utilizzare il tipo di parser JsonParserType.LAX quando si definisce un oggetto di JsonSlurper.

Vediamo un esempio di questo dato di seguito. L'esempio è per ottenere dati JSON da un server Web utilizzando il modulo http. Per questo tipo di attraversamento, l'opzione migliore è impostare il tipo di parser sulla 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)
   }
}

Allo stesso modo i seguenti tipi di parser aggiuntivi sono disponibili in Groovy:

  • Il parser JsonParserCharArray prende fondamentalmente una stringa JSON e opera sulla matrice di caratteri sottostante. Durante la conversione del valore, copia i sotto-array di caratteri (un meccanismo noto come "taglio") e opera su di essi individualmente.

  • JsonFastParser è una variante speciale di JsonParserCharArray ed è il parser più veloce. JsonFastParser è anche noto come parser di overlay dell'indice. Durante l'analisi della stringa JSON data, cerca il più possibile di evitare di creare nuovi array di caratteri o istanze di stringa. Mantiene solo i puntatori all'array di caratteri originale sottostante. Inoltre, differisce la creazione dell'oggetto il più tardi possibile.

  • JsonParserUsingCharacterSource è un parser speciale per file di grandi dimensioni. Utilizza una tecnica chiamata "windowing dei caratteri" per analizzare file JSON di grandi dimensioni (in questo caso grandi significa file di dimensioni superiori a 2 MB) con prestazioni costanti.

Analisi del testo

Diamo un'occhiata ad alcuni esempi di come possiamo usare 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);
   } 
}

Nell'esempio sopra, siamo:

  • Prima creazione di un'istanza della classe JsonSlurper

  • Stiamo quindi utilizzando la funzione parseText della classe JsonSlurper per analizzare del testo JSON.

  • Quando otteniamo l'oggetto, puoi vedere che possiamo effettivamente accedere ai valori nella stringa JSON tramite la chiave.

L'output del programma di cui sopra è dato di seguito:

John 
1

Elenco di analisi di numeri interi

Diamo un'occhiata a un altro esempio del metodo di analisi JsonSlurper. Nell'esempio seguente, stiamo passando un elenco di numeri interi. Noterai dal seguente codice che siamo in grado di utilizzare il metodo List di ciascuno e di chiuderlo.

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

L'output del programma di cui sopra è dato di seguito:

List=[2, 3, 4, 5]

Elenco di analisi dei tipi di dati primitivi

Il parser JSON supporta anche i tipi di dati primitivi di stringa, numero, oggetto, vero, falso e null. La classe JsonSlurper converte questi tipi JSON nei corrispondenti tipi Groovy.

L'esempio seguente mostra come utilizzare JsonSlurper per analizzare una stringa JSON. E qui puoi vedere che JsonSlurper è in grado di analizzare i singoli elementi nei rispettivi tipi primitivi.

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

L'output del programma di cui sopra è dato di seguito:

12 
12.55 
1.2E+14

JsonOutput

Ora parliamo di come stampare l'output in Json. Questo può essere fatto con il metodo JsonOutput. Questo metodo è responsabile della serializzazione di oggetti Groovy in stringhe JSON.

Sintassi

Static string JsonOutput.toJson(datatype obj)

Parameters - I parametri possono essere un oggetto di un tipo di dati: numero, booleano, carattere, stringa, data, mappa, chiusura ecc.

Return type - Il tipo restituito è una stringa json.

Esempio

Di seguito è riportato un semplice esempio di come questo può essere ottenuto.

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

L'output del programma di cui sopra è dato di seguito:

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

JsonOutput può essere utilizzato anche per semplici oggetti vecchi e groovy. Nell'esempio seguente, puoi vedere che stiamo effettivamente passando oggetti del tipo Student al metodo 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; 
}

L'output del programma di cui sopra è dato di seguito:

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