Groovy - JSON

This chapter covers how to we can use the Groovy language for parsing and producing JSON objects.

JSON Functions

Parsing Data using JsonSlurper

JsonSlurper is a class that parses JSON text or reader content into Groovy data Structures such as maps, psts and primitive types pke Integer, Double, Boolean and String.

Syntax

def slurper = new JsonSlurper()

JSON slurper parses text or reader content into a data structure of psts and maps.

The JsonSlurper class comes with a couple of variants for parser implementations. Sometimes you may have different requirements when it comes to parsing certain strings. Let’s take an instance wherein one needs to read the JSON which is returned from the response from a web server. In such a case it’s beneficial to use the parser JsonParserLax variant. This parsee allows comments in the JSON text as well as no quote strings etc. To specify this sort of parser you need to use JsonParserType.LAX parser type when defining an object of the JsonSlurper.

Let’s see an example of this given below. The example is for getting JSON data from a web server using the http module. For this type of traversal, the best option is to have the parser type set to JsonParserLax variant.

http.request( GET, TEXT ) {
   headers.Accept =  apppcation/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)
   }
}

Similarly the following additional parser types are available in Groovy −

The JsonParserCharArray parser basically takes a JSON string and operates on the underlying character array. During value conversion it copies character sub-arrays (a mechanism known as "chopping") and operates on them inspanidually.

The JsonFastParser is a special variant of the JsonParserCharArray and is the fastest parser. JsonFastParser is also known as the index-overlay parser. During parsing of the given JSON String it tries as hard as possible to avoid creating new char arrays or String instances. It just keeps pointers to the underlying original character array only. In addition, it defers object creation as late as possible.

The JsonParserUsingCharacterSource is a special parser for very large files. It uses a technique called "character windowing" to parse large JSON files (large means files over 2MB size in this case) with constant performance characteristics.

Parsing Text

Let’s have a look at some examples of how we can use the JsonSlurper class.

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

John 
1

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

List=[2, 3, 4, 5]

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

12 
12.55 
1.2E+14 

Static string JsonOutput.toJson(datatype obj)

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

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

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

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