Java Jackson-jr库指南 | Baeldung中文网

概述

Jackson-jr是针对Java开发的一个轻量级JSON处理库，旨在提供比原始Jackson库更简单、更小巧的替代方案。凭借其小体积和易于使用的API，Jackson-jr非常适合于轻松处理JSON读写场景。

本指南将探讨Jackson-jr的关键特性和用法，包括示例和最佳实践。

1. Jackson-jr入门

在Java应用中，Jackson-jr提供了轻量级且高效的JSON数据处理方式。它为处理JSON对象和数组提供了简单易用的API，使得解析、生成和操作JSON数据更为便捷。

首先，我们需要在项目中添加Jackson-jr库。可以在项目的构建配置文件中（如Maven的pom.xml或Gradle的build.gradle）添加对应版本的依赖：

Maven

<dependency>
    <groupId>com.fasterxml.jackson.jr</groupId>
    <artifactId>jackson-jr-all</artifactId>
    <version>2.15.2</version>
</dependency>

Gradle

implementation 'com.fasterxml.jackson.jr:jackson-jr-all:2.15.2'

2. 使用Jackson-jr处理JSON对象

Jackson-jr的基础对象是JSONObject。一个重要的事实是，JSONObject实例是完全不可变且线程安全的。我们可以根据需要使用它们，例如作为单例实例、Spring Bean，或者构造单独的对象。由于其不可变性，可以安全地在不同线程间传递。

2.1. 创建JSON对象和数组

Jackson-jr提供了一套方便的API来创建JSON对象和数组，例如使用LinkedHashMap表示JSON对象，ArrayList表示JSON数组。

JSONObject基于LinkedHashMap，我们可以通过LinkedHashMap.put()方法添加属性，并通过LinkedHashMap.get()方法获取属性。

String json = JSON.std
  .with(JSON.Feature.PRETTY_PRINT_OUTPUT)
  .asString(new LinkedHashMap<String, Object>() {{
      put("name", "John Doe");
      put("age", 30);
      put("email", "[email protected]");
  }});

2.2. Jackson-jr Composer

另一个Jackson-jr的亮点是引入了Composer接口，以构建器风格生成JSON内容：

String json = JSON.std.with(JSON.Feature.PRETTY_PRINT_OUTPUT)
  .composeString()
  .startObject()
  .startArrayField("objectArray")
  .startObject()
  .put("name", "name1")
  .put("age", 11)
  .end()  
  .startObject()
  .put("name", "name2")
  .put("age", 12)
  .end()  
  .end()  
  .startArrayField("array")
  .add(1) 
  .add(2) 
  .add(3) 
  .end()  
  .startObjectField("object")
  .put("name", "name3")
  .put("age", 13)
  .end()  
  .put("last", true)
  .end()  
  .finish();

这段构建器生成的JSON如下：

{
  "objectArray" : [ {
    "name" : "name1",
    "age" : 11
  }, {
    "name" : "name2",
    "age" : 12
  } ],
  "array" : [ 1, 2, 3 ],
  "object" : {
    "name" : "name3",
    "age" : 13
  },
  "last" : true
}

3. 序列化与反序列化

Jackson-jr允许我们轻松地将Java对象转换为JSON字符串，反之亦然。我们可以配置写入器以设置所需的选项，如美化输出或自定义日期格式，然后将其用于将对象写为JSON字符串。

Jackson-jr支持复杂的对象结构，包括嵌套对象和数组。通过正确定义Java类及其关系的结构，Jackson-jr能够处理复杂JSON数据的序列化和反序列化。

// Serialization
String json = JSON.std.with(JSON.Feature.PRETTY_PRINT_OUTPUT)
  .asString(person);

// Deserialization
json = "{\"name\":\"John Doe\",\"age\":30}";
Person person1 = JSON.std.with(JSON.Feature.PRETTY_PRINT_OUTPUT)
  .beanFrom(Person.class, json);

3.1. Jackson-jr定制

Jackson-jr支持诸如@JsonProperty等注解，用于定制序列化和反序列化过程。这些注解允许我们控制属性名称、指定日期和时间格式，以及处理其他定制场景。有关所有支持注解的详细信息，请查看他们在官方GitHub项目中的文档。

Jackson-jr提供了一系列功能定制选项，用于调整序列化和反序列化的输入和输出，比如美化输出、写入null属性等。查看这些选项的最佳途径是在基础代码中。

JSON jsonMapper = JSON.std.with(JSON.Feature.PRETTY_PRINT_OUTPUT)
  .with(JSON.Feature.WRITE_NULL_PROPERTIES)
  .with(JSON.Feature.FAIL_ON_DUPLICATE_MAP_KEYS);
String json = jsonMapper.asString(person);

Jackson-jr允许我们创建自定义序列化器和反序列化器来处理特定的数据类型或复杂的序列化场景。通过实现适当的接口，如ValueWriter，并扩展提供的类，如ValueReader和ReadWriterProvider，我们可以定义如何序列化和反序列化我们的自定义对象。

Jackson-jr不支持java.time.*包，但可以通过自定义序列化器和反序列化器添加支持：

public class CustomDateSerializer implements ValueWriter {
    @Override
    public void writeValue (JSONWriter jsonWriter, JsonGenerator jsonGenerator, Object o) throws IOException {
        jsonGenerator.writeString(o.toString());
    }

    @Override
    public Class<?> valueType () {
        return LocalDate.class;
    }
}

public class CustomDateDeserializer extends ValueReader {
    private final static DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MMM-dd");

    public CustomDateDeserializer () {
        super(LocalDate.class);
    }

    @Override
    public Object read (JSONReader jsonReader, JsonParser jsonParser) throws IOException {
        return LocalDate.parse(jsonParser.getText(), dtf);
    }
}

注册后，我们可以开始序列化和反序列化LocalDate对象：

public class MyHandlerProvider extends ReaderWriterProvider {

    @Override
    public ValueWriter findValueWriter (JSONWriter writeContext, Class<?> type) {
        if (type == LocalDate.class) {
            return new CustomDateSerializer();
        }
        return null;
    }

    @Override
    public ValueReader findValueReader (JSONReader readContext, Class<?> type) {
        if (type.equals(LocalDate.class)) {
            return new CustomDateDeserializer();
        }
        return null;
    }
}

Person person = new Person("John Doe", 30, LocalDate.now());

JSON jsonMapper = JSON.builder().register(new JacksonJrExtension() {
    @Override
    protected void register (ExtensionContext extensionContext) {
        extensionContext.insertProvider(new MyHandlerProvider());
    }   
}).build().with(JSON.Feature.PRETTY_PRINT_OUTPUT);

String json = jsonMapper.asString(person);
Person deserializedPerson = jsonMapper.beanFrom(Person.class, json);

4. Jackson-jr与Jackson比较

Jackson-jr	Jackson
更小的jar	更大的jar
较少的功能	更多复杂功能
适合简单的序列化和反序列化	适合更复杂的序列化和反序列化
更快的启动时间	更慢的启动时间
更简洁的API	更复杂的API

5. 结论

Jackson-jr为Java应用程序中的JSON处理提供了一个轻量级且用户友好的方法。其简化了的API、可定制选项以及高效性能，使其成为需要轻量级JSON处理库但不牺牲功能的开发者的理想选择。

如往常一样，示例代码可在GitHub上找到。

Persistence

REST

Security

概述