Maravilloso - JSON

Este capítulo cubre cómo podemos usar el lenguaje Groovy para analizar y producir objetos JSON.

Funciones JSON

No Señor	Función y bibliotecas
1	JsonSlurper JsonSlurper es una clase que analiza el texto JSON o el contenido del lector en datos Groovy Estructuras como mapas, listas y tipos primitivos como Integer, Double, Boolean y String.
2	JsonOutput Este método es responsable de serializar objetos Groovy en cadenas JSON.

Analizar datos con JsonSlurper

JsonSlurper es una clase que analiza el texto JSON o el contenido del lector en estructuras de datos Groovy, como mapas, listas y tipos primitivos como Integer, Double, Boolean y String.

Sintaxis

def slurper = new JsonSlurper()

JSON slurper analiza el texto o el contenido del lector en una estructura de datos de listas y mapas.

La clase JsonSlurper viene con un par de variantes para implementaciones del analizador. A veces, puede tener diferentes requisitos cuando se trata de analizar ciertas cadenas. Tomemos una instancia en la que se necesita leer el JSON que se devuelve de la respuesta de un servidor web. En tal caso, es beneficioso utilizar la variante del analizador JsonParserLax. Este analizador permite comentarios en el texto JSON, así como sin cadenas de comillas, etc. Para especificar este tipo de analizador, debe utilizar el tipo de analizador JsonParserType.LAX al definir un objeto de JsonSlurper.

Veamos un ejemplo de esto a continuación. El ejemplo es para obtener datos JSON de un servidor web utilizando el módulo http. Para este tipo de recorrido, la mejor opción es establecer el tipo de analizador en 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 manera similar, los siguientes tipos de analizadores adicionales están disponibles en Groovy:

El analizador JsonParserCharArray básicamente toma una cadena JSON y opera en la matriz de caracteres subyacente. Durante la conversión de valor, copia las submatrices de caracteres (un mecanismo conocido como "cortar") y las opera individualmente.
JsonFastParser es una variante especial de JsonParserCharArray y es el analizador más rápido. JsonFastParser también se conoce como el analizador de superposición de índices. Durante el análisis de la cadena JSON dada, intenta con todas sus fuerzas evitar la creación de nuevas matrices de caracteres o instancias de cadenas. Solo mantiene los punteros a la matriz de caracteres original subyacente únicamente. Además, pospone la creación de objetos lo más tarde posible.
JsonParserUsingCharacterSource es un analizador especial para archivos muy grandes. Utiliza una técnica llamada "ventana de caracteres" para analizar archivos JSON de gran tamaño (grandes significa archivos de más de 2 MB en este caso) con características de rendimiento constantes.

Analizar texto

Echemos un vistazo a algunos ejemplos de cómo podemos usar la clase 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);
   } 
}

En el ejemplo anterior, somos:

Primero creando una instancia de la clase JsonSlurper
Luego usamos la función parseText de la clase JsonSlurper para analizar texto JSON.
Cuando obtenemos el objeto, puede ver que en realidad podemos acceder a los valores en la cadena JSON a través de la clave.

La salida del programa anterior se da a continuación:

John 
1

Análisis de la lista de enteros

Echemos un vistazo a otro ejemplo del método de análisis JsonSlurper. En el siguiente ejemplo, estamos pasando una lista de números enteros. Notará en el siguiente código que podemos usar el método List de cada uno y pasarle un cierre.

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 salida del programa anterior se da a continuación:

List=[2, 3, 4, 5]

Lista de análisis de tipos de datos primitivos

El analizador JSON también admite los tipos de datos primitivos de cadena, número, objeto, verdadero, falso y nulo. La clase JsonSlurper convierte estos tipos JSON en los tipos Groovy correspondientes.

El siguiente ejemplo muestra cómo usar JsonSlurper para analizar una cadena JSON. Y aquí puede ver que JsonSlurper puede analizar los elementos individuales en sus respectivos tipos primitivos.

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 salida del programa anterior se da a continuación:

12 
12.55 
1.2E+14

JsonOutput

Ahora hablemos sobre cómo imprimir la salida en Json. Esto se puede hacer mediante el método JsonOutput. Este método es responsable de serializar objetos Groovy en cadenas JSON.

Sintaxis

Static string JsonOutput.toJson(datatype obj)

Parameters - Los parámetros pueden ser un objeto de un tipo de datos: número, booleano, carácter, cadena, fecha, mapa, cierre, etc.

Return type - El tipo de retorno es una cadena json.

Ejemplo

A continuación se muestra un ejemplo sencillo de cómo se puede lograr esto.

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

La salida del programa anterior se da a continuación:

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

El JsonOutput también se puede utilizar para objetos sencillos y maravillosos. En el siguiente ejemplo, puede ver que en realidad estamos pasando objetos del tipo Student al método 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 salida del programa anterior se da a continuación:

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

↰ Previous page Next page ↱