Jackson ObjectMapper的使用

于 2020-03-01 16:34:45 发布
阅读量798 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 个人笔记 Jackson 文章标签： json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/XiumingLee/article/details/104594735
本文详细介绍了如何使用Jackson库的ObjectMapper类进行Java对象与JSON之间的序列化和反序列化，包括基本使用、高级配置及自定义序列化器等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 概述

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

2. Maven依赖

        <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类作为对象来序列化或反序列化：
public class Car {
 
    private String color;
    private String type;
 
    // getters/setters
}

3.1. Java对象转JSON

让我们来看一个使用ObjectMapper类的writeValue方法将Java对象序列化为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和writeValueAsBytes方法从Java对象生成一个JSON，并将生成的JSON作为字符串或字节数组返回：

String carAsString = objectMapper.writeValueAsString(car);

3.2. JSON转为Json对象

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

ObjectMapper objectMapper = new ObjectMapper();
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.3. JSON转Jackson JsonNode

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

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对象列表：

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：

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属性：

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

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

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

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的，它定义了是否允许类的属性为空值：
objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);
  • 同样，FAIL_ON_NUMBERS_FOR_ENUM控制是否允许将枚举值序列化/反序列化为数字：
objectMapper.configure(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

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

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

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

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

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();
    }
}

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

        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反序列化器：

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;
    }
}

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

        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为单位的毫秒数）。但这不是人类可读的，并且需要进一步转换以人类可读的格式显示。
让我们定义一个类：

public class Request 
{
    private Car car;
    private Date datePurchased;
 
    // getters/setters
}

不加日期处理时

        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}

添加日期格式处理

        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生成为数组：

        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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值