Working with JSON in Groovy – 在Groovy中使用JSON工作

最后修改: 2018年 3月 13日

中文/混合/英文(键盘快捷键：t)

1. Introduction

1.绪论

In this article, we’re going to describe and see examples of how to work with JSON in a Groovy application.

在本文中，我们将描述并查看如何在Groovy应用程序中处理JSON的例子。

First of all, to get the examples of this article up and running, we need to set up our pom.xml:

首先，为了让本文的例子运行起来，我们需要设置我们的pom.xml。

<build>
    <plugins>
        // ...
        <plugin>
            <groupId>org.codehaus.gmavenplus</groupId>
            <artifactId>gmavenplus-plugin</artifactId>
            <version>1.6</version>
        </plugin>
    </plugins>
</build>
<dependencies>
    // ...
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.4.13</version>
    </dependency>
</dependencies>

The most recent Maven plugin can be found here and the latest version of the groovy-all here.

最新的Maven插件可以在这里找到，最新版本的groovy-all这里。

2. Parsing Groovy Objects to JSON

2.将Groovy对象解析为JSON

Converting Objects to JSON in Groovy is pretty simple, let’s assume we have an Account class:

在Groovy中把对象转换为JSON是非常简单的，让我们假设我们有一个Account类。

class Account {
    String id
    BigDecimal value
    Date createdAt
}

To convert an instance of that class to a JSON String, we need to use the JsonOutput class and make a call to the static method toJson():

为了将该类的一个实例转换为JSON 字符串，我们需要使用JsonOutput 类，并调用静态方法toJson()：。

Account account = new Account(
    id: '123', 
    value: 15.6,
    createdAt: new SimpleDateFormat('MM/dd/yyyy').parse('01/01/2018')
) 
println JsonOutput.toJson(account)

As a result, we’ll get the parsed JSON String:

结果，我们将得到解析后的JSON String:。

{"value":15.6,"createdAt":"2018-01-01T02:00:00+0000","id":"123"}

2.1. Customizing the JSON Output

2.1.定制JSON输出

As we can see, the date output isn’t what we wanted. For that purpose, starting with version 2.5, the package groovy.json comes with a dedicated set of tools.

我们可以看到，日期输出并不是我们想要的。为此，从2.5版本开始，软件包groovy.json附带了一套专用工具。

With the JsonGenerator class, we can define options to the JSON output:

通过JsonGenerator类，我们可以定义JSON输出的选项。

JsonGenerator generator = new JsonGenerator.Options()
  .dateFormat('MM/dd/yyyy')
  .excludeFieldsByName('value')
  .build()

println generator.toJson(account)

As a result, we’ll get the formatted JSON without the value field we excluded and with the formatted date:

结果是，我们将得到格式化的JSON，其中没有我们排除的值域，而有格式化的日期。

{"createdAt":"01/01/2018","id":"123"}

2.2. Formatting the JSON Output

2.2.格式化JSON输出

With the methods above we saw that the JSON output was always in a single line, and it can get confusing if a more complex object has to be dealt with.

通过上面的方法，我们看到JSON的输出总是在一行中，如果要处理一个更复杂的对象，就会变得很混乱。

However, we can format our output using the prettyPrint method:

然而，我们可以使用prettyPrint方法来格式化我们的输出。

String json = generator.toJson(account)
println JsonOutput.prettyPrint(json)

And we get the formatted JSON bellow:

然后我们得到了下面这个格式化的JSON。

{
    "value": 15.6,
    "createdAt": "01/01/2018",
    "id": "123"
}

3. Parsing JSON to Groovy Objects

3.将JSON解析为Groovy对象

We’re going to use Groovy class JsonSlurper to convert from JSON to Objects.

我们将使用Groovy类JsonSlurper 来将JSON转换为Objects。

Also, with JsonSlurper we have a bunch of overloaded parse methods and a few specific methods like parseText, parseFile, and others.

另外，通过JsonSlurper，我们有一堆重载的parse方法和一些特定的方法，如parseText、parseFile等。

We’ll use the parseText to parse a String to an Account class:

我们将使用parseText来解析一个String到一个Account类：。

def jsonSlurper = new JsonSlurper()

def account = jsonSlurper.parseText('{"id":"123", "value":15.6 }') as Account

In the above code, we have a method that receives a JSON String and returns an Account object, which can be any Groovy Object.

在上面的代码中，我们有一个方法接收一个JSON String，并返回一个Account对象，它可以是任何Groovy对象。

Also, we can parse a JSON String to a Map, calling it without any cast, and with the Groovy dynamic typing, we can have the same as the object.

另外，我们可以将JSON的String解析为Map,调用它，而不需要任何转换，通过Groovy的动态类型化，我们可以拥有与对象相同的。

3.1. Parsing JSON Input

3.1.解析JSON输入

The default parser implementation for JsonSlurper is JsonParserType.CHAR_BUFFER, but in some cases, we’ll need to deal with a parsing problem.

JsonSlurper的默认解析器实现是JsonParserType.CHAR_BUFFER，但是在某些情况下，我们需要处理一个解析问题。

Let’s look at an example for this: given a JSON String with a date property, JsonSlurper will not correctly create the Object because it will try to parse the date as String:

让我们看一个例子：给定一个带有日期属性的JSON String，JsonSlurper将不能正确地创建对象，因为它将尝试把日期解析为String:。

def jsonSlurper = new JsonSlurper()
def account 
  = jsonSlurper.parseText('{"id":"123","createdAt":"2018-01-01T02:00:00+0000"}') as Account

As a result, the code above will return an Account object with all properties containing null values.

因此，上面的代码将返回一个Account对象，其所有属性都包含null值。

To resolve that problem, we can use the JsonParserType.INDEX_OVERLAY.

为了解决这个问题，我们可以使用JsonParserType.INDEX_OVERLAY.。

As a result, it will try as hard as possible to avoid creation of String or char arrays:

因此，它将尽可能努力避免创建String或char数组。

def jsonSlurper = new JsonSlurper(type: JsonParserType.INDEX_OVERLAY)
def account 
  = jsonSlurper.parseText('{"id":"123","createdAt":"2018-01-01T02:00:00+0000"}') as Account

Now, the code above will return an Account instance appropriately created.

现在，上面的代码将返回一个适当创建的Account实例。

3.2. Parser Variants

3.2. Parser Variants

Also, inside the JsonParserType, we have some other implementations:

另外，在JsonParserType里面，我们还有一些其他的实现。

  • JsonParserType.LAX will allow a more relaxed JSON parsing, with comments, no quote strings, etc.
  • JsonParserType.CHARACTER_SOURCE is used for large file parsing.

4. Conclusion

4.总结

We’ve covered a lot of the JSON processing in a Groovy application with a couple of simple examples.

我们已经通过几个简单的例子介绍了Groovy应用程序中的很多JSON处理。

For more information about the groovy.json package classes we can have a look at the Groovy Documentation.

关于groovy.json包类的更多信息，我们可以看一下Groovy文档。

Check the source code of the classes used in this article, as well as some unit tests, in our GitHub repository.

在我们的GitHub资源库中查看本文中使用的类的源代码以及一些单元测试。