Jackson中ObjectMapper的用法-jackson-zhong-objectmapper-de-yong-fa

1. 概述

本文主要介绍 ObjectMapper 如何序列化一个Java对象和反序列化一个JSON字符串。

2. Maven

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.1</version>
</dependency>

jackson-datebind 讲自动引入下面两个库

1. jackson-annotations
2. jackson-core

3. 使用 ObjectMapper 进行 reading 和 writing

我们先从最基础的 reading 和 writing 操作开始，使用 ObjectMapper 的 readVlue API 能解析(反序列化) JSON 字符串为一个 Java 对象。
使用 writeValue API 能将任何一个 Java 对象序列化为 JSON 字符串。
我们将反复序列化和反序列化 Car 对象

@Date
public class Car {

    private String color;
    private String type;

}

1. JavaObject 转 JSON
   我们来看一个使用 writeValue 方法将 JavaObject 转 JSON 字符串的例子

ObjectMapper objectMapper = new ObjectMapper();
Car car = new Car("yellow", "renault");
objectMapper.writeValue(new File("target/car.json"), car);

输出的内容如下

{"color":"yellow","type":"renault"}

ObjectMapper 的 writeValueAsString 和 writeVlaueAsBytes 方法会将一个 JavaObject 转换成 JSON 字符串或者一个 byte 数组

String carAsString = objectMapper.writeValueAsString(car);

2. JSON 转 JavaObject
   下面将使用 ObjectMapper 将 JSON 字符串转换为 JavaObject

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Car car = objectMapper.readValue(json, Car.class);

readValue 方法也可以接受其他方式的输入，比如一个 JSON 文件

Car car = objectMapper.readValue(new File("src/test/resources/json_car.json"), Car.class);

或者一个URL

Car car = objectMapper.readValue(new URL("file:src/test/resources/json_car.json"), Car.class);

3. JSON 转 Jackson JsonNode
   JSON 字符串也能被解析成一个 JsonNode 对象，接下来可以从特定的 Node 取节点信息

String json = "{ \"color\" : \"Black\", \"type\" : \"FIAT\" }";
JsonNode jsonNode = objectMapper.readTree(json);
String color = jsonNode.get("color").asText();
// Output: color -> Black

4. JSONArray 字符串转 JavaList
   我们也可以使用 TypeReference 将 JSONArray 字符串解析成 JavaList

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
List<Car> listCar = objectMapper.readValue(jsonCarArray, new TypeReference<List<Car>>(){});

5. JSON 字符串转 JavaMap
   类似，也可以将 JSON 字符串解析成 JavaMap

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
Map<String, Object> map 
  = objectMapper.readValue(json, new TypeReference<Map<String,Object>>(){});

4. 高级特性

Jackson 库最大的一个优势在于提供了高度可自定义的序列化和反序列化

1. 配置序列化和反序列化的细节
   当我们将 JSON 转为 JavaObject 时，例子中的 JSON 有新的字段，默认的处理将会抛出异常

String jsonString 
  = "{ \"color\" : \"Black\", \"type\" : \"Fiat\", \"year\" : \"1970\" }";

上面的例子在默认的解析过程中将导致 UnrecognizedPropertyException
通过配置默认的流程我们可以忽略 year 字段

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Car car = objectMapper.readValue(jsonString, Car.class);

JsonNode jsonNodeRoot = objectMapper.readTree(jsonString);
JsonNode jsonNodeYear = jsonNodeRoot.get("year");
String year = jsonNodeYear.asText();

FAIL_ON_NULL_FOR_PRIMITIVES 配置能允许 null

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

FAIL_ON_NUMBERS_FOR_ENUM 可以允许一个枚举值 序列化/反序列化 成一个数字

objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

更多配置列表请参考 Jackson 官网
2. 定制一个序列化器或反序列化器
ObjectMapper 还可以注册一个自定义的序列化器和反序列化器。自定义 serializers 和 deserializers 在需要针对不同 JavaClass 有不同的 JSON 输入或输出的场景下非常有用。
下面的例子自定义了一个 serializer

public class CustomCarSerializer extends StdSerializer<Car> {
    
    public CustomCarSerializer() {
        this(null);
    }

    public CustomCarSerializer(Class<Car> t) {
        super(t);
    }

    @Override
    public void serialize(
      Car car, JsonGenerator jsonGenerator, SerializerProvider serializer) {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("car_brand", car.getType());
        jsonGenerator.writeEndObject();
    }
}

自定义的 serializer 这样使用

ObjectMapper mapper = new ObjectMapper();
SimpleModule module = 
  new SimpleModule("CustomCarSerializer", new Version(1, 0, 0, null, null, null));
module.addSerializer(Car.class, new CustomCarSerializer());
mapper.registerModule(module);
Car car = new Car("yellow", "renault");
String carJson = mapper.writeValueAsString(car);
//carJson looks like： {"car_brand":"renault"}

还有一个自定义的 deserializer

public class CustomCarDeserializer extends StdDeserializer<Car> {
    
    public CustomCarDeserializer() {
        this(null);
    }

    public CustomCarDeserializer(Class<?> vc) {
        super(vc);
    }

    @Override
    public Car deserialize(JsonParser parser, DeserializationContext deserializer) {
        Car car = new Car();
        ObjectCodec codec = parser.getCodec();
        JsonNode node = codec.readTree(parser);
        
        // try catch block
        JsonNode colorNode = node.get("color");
        String color = colorNode.asText();
        car.setColor(color);
        return car;
    }
}

deserialer 这样使用

String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
ObjectMapper mapper = new ObjectMapper();
SimpleModule module =
  new SimpleModule("CustomCarDeserializer", new Version(1, 0, 0, null, null, null));
module.addDeserializer(Car.class, new CustomCarDeserializer());
mapper.registerModule(module);
Car car = mapper.readValue(json, Car.class);

3. 日期格式化
   java.util.Date 的默认序列化产生一个数字，即时间戳(UTC 1970年1月1日为起点的毫秒数)。但阅读性很差，需要进一步转换可读的格式。
   先将 Car 和 date 合并成一个 request 对象

@Date
public class Request 
{
    private Car car;
    private Date datePurchased;
}

接下来将日期格式化为 yyyy-MM-dd HH:mm

ObjectMapper objectMapper = new ObjectMapper();
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
objectMapper.setDateFormat(df);
String carAsString = objectMapper.writeValueAsString(request);
// output: {"car":{"color":"yellow","type":"renault"},"datePurchased":"2016-07-03 11:43 AM CEST"}

4. 集合
   还有一个非常有用的特性，DeserializationFeature 可以将一个 JSONArray 转换成指定类型的集合。
   举个例子，转换 JSONArray 为一个数组

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
Car[] cars = objectMapper.readValue(jsonCarArray, Car[].class);
// print cars

或者一个 List

String jsonCarArray = 
  "[{ \"color\" : \"Black\", \"type\" : \"BMW\" }, { \"color\" : \"Red\", \"type\" : \"FIAT\" }]";
ObjectMapper objectMapper = new ObjectMapper();
List<Car> listCar = objectMapper.readValue(jsonCarArray, new TypeReference<List<Car>>(){});
// print cars

5. 总结

Jackson 是非常成熟的 JSON 序列化/反序列化库，ObjectMapper API提供了一种简单的方法来解析和生成JSON响应对象，具有很强的灵活性。