Jackson ObjectMapper的使用

Jackson ObjectMapper的使用

1. 概述

本文将介绍如何使用Jackson的ObjectMapper类将Java对象序列化为Json以及将Json反序列化为Java对象。

2. Maven依赖

1
2
3
4
5
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.1</version>
</dependency>

此依赖项将在类路径中可传递地添加以下库:

  • jackson-annotations-2.10.1.jar
  • jackson-core-2.10.1.jar
  • jackson-databind-2.10.1.jar

    3. 使用ObjectMapper进行序列化和反序列化

    让我们从基本的读写操作开始。
  • 我们可以使用ObjectMapper的readValue来将JSON内容解析或反序列化为Java对象。
  • 我们可以使用writeValue将任何Java对象序列化为JSON输出。
    在本文中,我们将使用以下带有两个字段的Car类作为对象来序列化或反序列化:
    1
    2
    3
    4
    5
    6
    7
    public class Car {

    private String color;
    private String type;

    // getters/setters
    }

3.1. Java对象转JSON

让我们来看一个使用ObjectMapper类的writeValue方法将Java对象序列化为JSON的示例:

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

文件中的内容是:

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

ObjectMapper类的writeValueAsString和writeValueAsBytes方法从Java对象生成一个JSON,并将生成的JSON作为字符串或字节数组返回:

1
String carAsString = objectMapper.writeValueAsString(car);

3.2. JSON转为Json对象

以下是使用ObjectMapper类将JSON字符串转换为Java对象的简单示例:

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

readValue()函数还接受其他形式的输入,例如包含JSON字符串的文件:

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

或者是URL

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

3.3. JSON转Jackson JsonNode

另外,可以将JSON解析为JsonNode对象,并用于从特定节点检索数据:

1
2
3
4
String json = "{ \"color\" : \"Black\", \"type\" : \"FIAT\" }";
JsonNode jsonNode = objectMapper.readTree(json);
String color = jsonNode.get("color").asText();
// Black

3.4. Json转为Java List

我们可以使用TypeReference将数组形式的JSON解析为Java对象列表:

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

3.5. Json转为Java Map

同样,我们可以将JSON解析为Java Map:

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

4. 高级特性

Jackson库的最大优势之一就是高度可定制的序列化和反序列化过程。
在本节中,我们将介绍一些高级功能,其中输入或输出JSON数据可能不同于生成或使用数据的对象。

4.1. 配置序列化和反序列化

在将JSON对象转换为Java类时,如果JSON字符串具有一些新字段,则默认过程将导致异常,比如Car中没有year属性:

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

上面示例中的默认解析过程中,针对Class Car的Java对象的JSON字符串将导致UnrecognizedPropertyException异常。

通过configure方法,我们可以扩展默认过程以忽略新字段:

1
2
3
4
5
6
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的,它定义了是否允许类的属性为空值:

    1
    objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);
  • 同样,FAIL_ON_NUMBERS_FOR_ENUM控制是否允许将枚举值序列化/反序列化为数字:

    1
    objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

我们可以在官方网站上找到序列化和反序列化功能的完整列表。

4.2. 自定义序列化和反序列化器

ObjectMapper类的另一个基本功能是能够注册自定义序列化器和反序列化器。在输入或输出JSON的结构不同于必须对其进行序列化或反序列化的Java类的结构时,自定义序列化器和反序列化器非常有用。

以下是自定义JSON序列化器的示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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();
}
}

此自定义序列化器可以这样调用:

1
2
3
4
5
6
7
8
9
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);
System.out.println(carJson); // {"car_brand":"renault"}

我们再自定义JSON反序列化器:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class CustomCarDeserializer extends StdDeserializer<Car> {

public CustomCarDeserializer() {
this(null);
}

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

@Override
public Car deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException {
Car car = new Car();
ObjectCodec codec = parser.getCodec();
JsonNode node = codec.readTree(parser);

JsonNode colorNode = node.get("color");
String color = colorNode.asText();
car.setColor(color);
return car;
}
}

可以通过以下方式调用此自定义反序列化器:

1
2
3
4
5
6
7
8
9
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);
System.out.println(car); // Car类中只有color属性有值

4.3. 处理日期格式

java.util.Date的默认序列化产生一个数字,即纪元时间戳(自1970年1月1日起,以UTC为单位的毫秒数)。但这不是人类可读的,并且需要进一步转换以人类可读的格式显示。
让我们定义一个类:

1
2
3
4
5
6
7
public class Request 
{
private Car car;
private Date datePurchased;

// getters/setters
}

不加日期处理时

1
2
3
4
5
6
7
8
9
        final ObjectMapper objectMapper = new ObjectMapper();
final Car car = new Car("yellow", "renault");
final Request request = new Request();
request.setCar(car);
request.setDatePurchased(new Date());

String value = objectMapper.writeValueAsString(request);
System.out.println(value);
// {"car":{"color":"yellow","type":"renault"},"datePurchased":1583050561145}

添加日期格式处理

1
2
3
4
5
6
7
8
9
10
11
12
        final ObjectMapper objectMapper = new ObjectMapper();
final Car car = new Car("yellow", "renault");
final Request request = new Request();
request.setCar(car);
request.setDatePurchased(new Date());

DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
objectMapper.setDateFormat(df);

String value = objectMapper.writeValueAsString(request);
System.out.println(value);
// {"car":{"color":"yellow","type":"renault"},"datePurchased":"2020-03-01 16:18 下午 CST"}

4.4. 处理集合

DeserializationFeature类提供的另一个小而有用的功能是能够从JSON Array生成所需类型的集合的功能。
例如,我们可以将Json生成为数组:

1
2
3
4
5
6
7
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);

System.out.println(cars);

或者转换为Java List

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

Xiuming Lee wechat
欢迎您扫一扫上面的微信公众号订阅,更多惊喜等着您哦!
-------------本文结束感谢您的阅读-------------