CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-codehaus-groovy--groovy-all

Apache Groovy - A powerful multi-faceted programming language for the JVM platform with comprehensive module support

—

Pending
Overview
Eval results
Files

json.mddocs/

JSON Processing

Groovy provides comprehensive JSON support through JsonSlurper for parsing and JsonBuilder for generation, with multiple parser types and flexible configuration options.

JSON Parsing

JsonSlurper

Primary class for parsing JSON from various sources with configurable parser types.

class JsonSlurper {
    JsonSlurper()
    
    // Core parsing methods
    Object parseText(String text)
    Object parse(File file)
    Object parse(File file, String charset)
    Object parse(InputStream inputStream)
    Object parse(InputStream inputStream, String charset)
    Object parse(URL url)
    Object parse(URL url, String charset)
    Object parse(Reader reader)
    Object parse(char[] chars)
    Object parse(byte[] bytes)
    Object parse(byte[] bytes, String charset)
    Object parse(Path path)
    Object parse(Path path, String charset)
    
    // URL parsing with parameters
    Object parse(URL url, Map params)
    Object parse(Map params, URL url)
    Object parse(URL url, Map params, String charset)
    Object parse(Map params, URL url, String charset)
    
    // Configuration methods
    JsonSlurper setType(JsonParserType type)
    JsonParserType getType()
    
    int getMaxSizeForInMemory()
    JsonSlurper setMaxSizeForInMemory(int maxSizeForInMemory)
    
    boolean isChop()
    JsonSlurper setChop(boolean chop)
    
    boolean isLazyChop()
    JsonSlurper setLazyChop(boolean lazyChop)
    
    boolean isCheckDates()
    JsonSlurper setCheckDates(boolean checkDates)
}

JsonParserType

Enumeration of available JSON parser implementations.

enum JsonParserType {
    CHAR_BUFFER,        // Default parser type
    CHARACTER_SOURCE,
    INDEX_OVERLAY,
    LAX
}

Usage examples:

import groovy.json.JsonSlurper

def jsonSlurper = new JsonSlurper()

// Parse JSON string
def jsonText = '{"name": "John", "age": 30, "city": "New York"}'
def result = jsonSlurper.parseText(jsonText)
assert result.name == 'John'
assert result.age == 30

// Parse JSON from file
def file = new File('data.json')
def data = jsonSlurper.parse(file)

// Parse JSON from URL
def url = new URL('https://api.example.com/data.json')
def apiData = jsonSlurper.parse(url)

// Use different parser types
def laxSlurper = new JsonSlurper().setType(JsonParserType.LAX)
def relaxedJson = laxSlurper.parseText('{name: "John", age: 30}') // Unquoted keys allowed

// Configure parser settings
def configuredSlurper = new JsonSlurper()
    .setType(JsonParserType.LAX)
    .setMaxSizeForInMemory(1000000)
    .setChop(true)
    .setCheckDates(false)

// Parse with URL parameters
def params = [timeout: 5000, maxRetries: 3]
def apiData = jsonSlurper.parse(url, params)

JSON Generation

JsonBuilder

Builder for constructing JSON data structures programmatically.

class JsonBuilder implements Writable {
    JsonBuilder() 
    JsonBuilder(Object content)
    
    Object call()
    Object call(Closure c)
    Object call(Object... args)
    Object call(Iterable coll, Closure c)
    Object call(Object[] array, Closure c)
    Object call(Map m)
    Object call(Map m, Closure c)
    Object call(List l)
    Object call(List l, Closure c)
    
    String toString()
    String toPrettyString()
    Writer writeTo(Writer out)
    
    Object getContent()
}

Usage examples:

import groovy.json.JsonBuilder

// Simple object construction
def builder = new JsonBuilder()
builder {
    name 'John'
    age 30
    city 'New York'
    hobbies(['reading', 'swimming'])
}
println builder.toPrettyString()

// Array of objects
builder = new JsonBuilder()
builder([
    [name: 'John', age: 30],
    [name: 'Jane', age: 25]
])

// Nested structures
builder = new JsonBuilder()
builder {
    user {
        name 'John'
        details {
            age 30
            address {
                street '123 Main St'
                city 'New York'
            }
        }
    }
}

// Dynamic content with closures
def users = [
    [name: 'John', age: 30],
    [name: 'Jane', age: 25]
]

builder = new JsonBuilder(users) { person ->
    name person.name
    age person.age
    adult person.age >= 18
}

StreamingJsonBuilder

Memory-efficient JSON builder for large data structures using streaming output.

class StreamingJsonBuilder implements Writable {
    StreamingJsonBuilder(Writer writer)
    StreamingJsonBuilder(Writer writer, JsonGenerator generator)
    
    Object call(Closure c)
    Object call(Object... args)
    Object call(Iterable coll, Closure c)
    Object call(Object[] array, Closure c)
    Object call(Map m)
    Object call(Map m, Closure c)
    Object call(List l)
    Object call(List l, Closure c)
    
    Writer writeTo(Writer out)
    Writer getWriter()
}

Usage example:

import groovy.json.StreamingJsonBuilder

def writer = new StringWriter()
def builder = new StreamingJsonBuilder(writer)

builder {
    users([
        [name: 'John', age: 30],
        [name: 'Jane', age: 25]
    ]) { user ->
        name user.name
        age user.age
        adult user.age >= 18
    }
}

println writer.toString()

JSON Utilities

JsonOutput

Utility class for JSON serialization and formatting.

class JsonOutput {
    static String toJson(Object object)
    static String prettyPrint(String jsonPayload)
    static void prettyPrint(String jsonPayload, Writer writer)
    
    static String toJson(Map m)
    static String toJson(Collection c)
    static String toJson(Object[] array)
    static String toJson(boolean b)
    static String toJson(Number n)
    static String toJson(Character c)
    static String toJson(String s)
    static String toJson(Date date)
    static String toJson(Calendar cal)
    static String toJson(UUID uuid)
    static String toJson(URL url)
    static String toJson(Closure closure)
}

Usage examples:

import groovy.json.JsonOutput

// Convert objects to JSON
def person = [name: 'John', age: 30, hobbies: ['reading', 'swimming']]
def json = JsonOutput.toJson(person)
println json  // {"name":"John","age":30,"hobbies":["reading","swimming"]}

// Pretty print JSON
def prettyJson = JsonOutput.prettyPrint(json)
println prettyJson

// Convert various types
assert JsonOutput.toJson([1, 2, 3]) == '[1,2,3]'
assert JsonOutput.toJson(true) == 'true'
assert JsonOutput.toJson(null) == 'null'
assert JsonOutput.toJson('hello') == '"hello"'

JsonGenerator

Configurable JSON generator for customizing serialization behavior.

class JsonGenerator {
    static interface Converter {
        boolean handles(Class<?> type)
        Object convert(Object value, String key)
    }
    
    static class Options {
        Options addConverter(Converter converter)
        Options excludeNulls()
        Options excludeFieldsByName(String... fieldNames)
        Options excludeFieldsByType(Class... types)
        Options dateFormat(String format)
        Options dateFormat(String format, Locale locale)
        Options timezone(String timezone)
        Options disableUnicodeEscaping()
    }
    
    static Options options()
    String toJson(Object object)
    String toJson(Object object, Options options)
}

Usage example:

import groovy.json.JsonGenerator

def generator = new JsonGenerator.Options()
    .excludeNulls()
    .dateFormat('yyyy-MM-dd')
    .build()

def person = [
    name: 'John',
    age: 30,
    birthDate: new Date(),
    spouse: null  // Will be excluded due to excludeNulls()
]

def json = generator.toJson(person)
println json

Error Handling

Common JSON processing exceptions and error patterns:

import groovy.json.JsonException
import groovy.json.JsonSlurper

try {
    def slurper = new JsonSlurper()
    def result = slurper.parseText('{"invalid": json}')  // Invalid JSON
} catch (JsonException e) {
    println "JSON parsing error: ${e.message}"
}

// Handle missing properties gracefully
def json = '{"name": "John"}'
def slurper = new JsonSlurper()
def person = slurper.parseText(json)
def age = person.age ?: 0  // Default to 0 if age is missing

Advanced Usage Patterns

Custom Object Serialization

import groovy.json.JsonBuilder
import groovy.transform.ToString

@ToString
class Person {
    String name
    int age
    Date birthDate
    
    // Custom JSON representation
    def toJsonMap() {
        [
            name: name,
            age: age,
            birthYear: birthDate.year + 1900
        ]
    }
}

def person = new Person(name: 'John', age: 30, birthDate: new Date())
def builder = new JsonBuilder(person.toJsonMap())
println builder.toPrettyString()

Working with Large JSON Files

import groovy.json.JsonSlurper
import groovy.json.StreamingJsonBuilder

// Parse large JSON file efficiently
def slurper = new JsonSlurper()
new File('large-data.json').withInputStream { stream ->
    def data = slurper.parse(stream)
    // Process data in chunks
    data.records.each { record ->
        // Process individual records
        processRecord(record) 
    }
}

// Generate large JSON files efficiently  
new File('output.json').withWriter { writer ->
    def builder = new StreamingJsonBuilder(writer)
    builder {
        records(largeDataSet) { record ->
            id record.id
            name record.name
            // Include only necessary fields
        }
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-codehaus-groovy--groovy-all

docs

ast-transforms.md

cli.md

core-language.md

index.md

json.md

sql.md

swing.md

templates.md

xml.md

tile.json