行业资讯

Jackson的基础核心用法有哪些

发布时间：2021-12-13 19:12:12 作者：柒染
来源：亿速云 阅读：206

Jackson的基础核心用法有哪些

Jackson是一个用于处理JSON数据的Java库，它提供了强大的功能来将Java对象序列化为JSON字符串，以及将JSON字符串反序列化为Java对象。Jackson库的核心功能包括数据绑定、树模型处理、流式API等。本文将详细介绍Jackson的基础核心用法，帮助开发者快速上手并掌握其基本功能。

1. Jackson简介

Jackson是一个开源的Java库，由FasterXML公司开发和维护。它主要用于处理JSON数据，支持将Java对象序列化为JSON字符串，以及将JSON字符串反序列化为Java对象。Jackson库具有高性能、灵活性和易用性，广泛应用于各种Java项目中。

Jackson库的核心模块包括：

2. 基本用法

2.1 添加依赖

在使用Jackson之前，首先需要在项目中添加Jackson库的依赖。如果使用Maven进行项目管理，可以在pom.xml文件中添加以下依赖：

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

jackson-databind模块已经包含了jackson-core和jackson-annotations模块，因此只需要添加这一个依赖即可。

2.2 基本数据绑定

Jackson的核心功能之一是数据绑定，即将Java对象与JSON数据相互转换。下面通过一个简单的例子来演示如何使用Jackson进行数据绑定。

2.2.1 定义Java类

首先，定义一个简单的Java类Person：

public class Person {
    private String name;
    private int age;

    // 无参构造函数
    public Person() {}

    // 全参构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

2.2.2 序列化

将Java对象序列化为JSON字符串的过程称为序列化。使用Jackson进行序列化非常简单，只需创建一个ObjectMapper对象，并调用其writeValueAsString方法即可。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个Person对象
        Person person = new Person("Alice", 30);

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Person对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(person);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

运行上述代码，输出结果为：

{"name":"Alice","age":30}

2.2.3 反序列化

将JSON字符串反序列化为Java对象的过程称为反序列化。使用Jackson进行反序列化同样非常简单，只需调用ObjectMapper对象的readValue方法即可。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // JSON字符串
        String jsonString = "{\"name\":\"Alice\",\"age\":30}";

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将JSON字符串反序列化为Person对象
        Person person = objectMapper.readValue(jsonString, Person.class);

        // 输出Person对象
        System.out.println(person);
    }
}

运行上述代码，输出结果为：

Person{name='Alice', age=30}

2.3 处理复杂对象

在实际开发中，我们经常需要处理包含嵌套对象或集合的复杂对象。Jackson同样可以轻松处理这些情况。

2.3.1 定义复杂Java类

定义一个包含嵌套对象和集合的复杂Java类Company：

import java.util.List;

public class Company {
    private String name;
    private List<Person> employees;

    // 无参构造函数
    public Company() {}

    // 全参构造函数
    public Company(String name, List<Person> employees) {
        this.name = name;
        this.employees = employees;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Person> getEmployees() {
        return employees;
    }

    public void setEmployees(List<Person> employees) {
        this.employees = employees;
    }

    @Override
    public String toString() {
        return "Company{name='" + name + "', employees=" + employees + "}";
    }
}

2.3.2 序列化复杂对象

将包含嵌套对象和集合的复杂对象序列化为JSON字符串：

import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.List;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建Person对象
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);

        // 创建Company对象
        Company company = new Company("Tech Corp", Arrays.asList(person1, person2));

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Company对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(company);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

运行上述代码，输出结果为：

{"name":"Tech Corp","employees":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}

2.3.3 反序列化复杂对象

将包含嵌套对象和集合的JSON字符串反序列化为复杂对象：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // JSON字符串
        String jsonString = "{\"name\":\"Tech Corp\",\"employees\":[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]}";

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将JSON字符串反序列化为Company对象
        Company company = objectMapper.readValue(jsonString, Company.class);

        // 输出Company对象
        System.out.println(company);
    }
}

运行上述代码，输出结果为：

Company{name='Tech Corp', employees=[Person{name='Alice', age=30}, Person{name='Bob', age=25}]}

2.4 处理日期和时间

在实际开发中，日期和时间的处理是一个常见的需求。Jackson提供了多种方式来处理日期和时间。

2.4.1 使用默认日期格式

默认情况下，Jackson会将java.util.Date对象序列化为时间戳（毫秒数）。例如：

import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Date;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个包含日期的对象
        Event event = new Event("Meeting", new Date());

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Event对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(event);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

class Event {
    private String name;
    private Date eventDate;

    // 无参构造函数
    public Event() {}

    // 全参构造函数
    public Event(String name, Date eventDate) {
        this.name = name;
        this.eventDate = eventDate;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getEventDate() {
        return eventDate;
    }

    public void setEventDate(Date eventDate) {
        this.eventDate = eventDate;
    }

    @Override
    public String toString() {
        return "Event{name='" + name + "', eventDate=" + eventDate + "}";
    }
}

运行上述代码，输出结果为：

{"name":"Meeting","eventDate":1672502400000}

2.4.2 自定义日期格式

如果希望使用自定义的日期格式，可以通过@JsonFormat注解来实现。例如：

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Date;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个包含日期的对象
        Event event = new Event("Meeting", new Date());

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Event对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(event);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

class Event {
    private String name;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private Date eventDate;

    // 无参构造函数
    public Event() {}

    // 全参构造函数
    public Event(String name, Date eventDate) {
        this.name = name;
        this.eventDate = eventDate;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getEventDate() {
        return eventDate;
    }

    public void setEventDate(Date eventDate) {
        this.eventDate = eventDate;
    }

    @Override
    public String toString() {
        return "Event{name='" + name + "', eventDate=" + eventDate + "}";
    }
}

运行上述代码，输出结果为：

{"name":"Meeting","eventDate":"2023-01-01 00:00:00"}

2.5 处理枚举类型

Jackson可以轻松处理枚举类型。默认情况下，Jackson会将枚举类型序列化为其名称。例如：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个包含枚举类型的对象
        Order order = new Order(1, Status.PENDING);

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Order对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(order);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

class Order {
    private int id;
    private Status status;

    // 无参构造函数
    public Order() {}

    // 全参构造函数
    public Order(int id, Status status) {
        this.id = id;
        this.status = status;
    }

    // Getter和Setter方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "Order{id=" + id + ", status=" + status + "}";
    }
}

enum Status {
    PENDING, PROCESSING, COMPLETED
}

运行上述代码，输出结果为：

{"id":1,"status":"PENDING"}

2.6 处理空值和默认值

在实际开发中，我们经常需要处理空值和默认值。Jackson提供了多种方式来处理这些情况。

2.6.1 忽略空值

默认情况下，Jackson会序列化所有字段，包括空值。如果希望忽略空值，可以通过@JsonInclude注解来实现。例如：

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个包含空值的对象
        Person person = new Person(null, 30);

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Person对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(person);

        // 输出JSON字符串
        System.out.println(jsonString);
    }
}

@JsonInclude(JsonInclude.Include.NON_NULL)
class Person {
    private String name;
    private int age;

    // 无参构造函数
    public Person() {}

    // 全参构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

运行上述代码，输出结果为：

{"age":30}

2.6.2 设置默认值

如果希望在反序列化时为某些字段设置默认值，可以通过@JsonSetter注解来实现。例如：

import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // JSON字符串
        String jsonString = "{\"age\":30}";

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将JSON字符串反序列化为Person对象
        Person person = objectMapper.readValue(jsonString, Person.class);

        // 输出Person对象
        System.out.println(person);
    }
}

class Person {
    private String name;
    private int age;

    // 无参构造函数
    public Person() {}

    // 全参构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    @JsonSetter("name")
    public void setName(String name) {
        this.name = name == null ? "Unknown" : name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

运行上述代码，输出结果为：

Person{name='Unknown', age=30}

2.7 处理多态类型

在实际开发中，我们经常需要处理多态类型。Jackson提供了多种方式来处理多态类型。

2.7.1 使用@JsonTypeInfo注解

通过@JsonTypeInfo注解，可以在序列化和反序列化时处理多态类型。例如：

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        // 创建一个Animal对象
        Animal animal = new Dog("Buddy", 3);

        // 创建ObjectMapper对象
        ObjectMapper objectMapper = new ObjectMapper();

        // 将Animal对象序列化为JSON字符串
        String jsonString = objectMapper.writeValueAsString(animal);

        // 输出JSON字符串
        System.out.println(jsonString);

        // 将JSON字符串反序列化为Animal对象
        Animal deserializedAnimal = objectMapper.readValue(jsonString, Animal.class);

        // 输出反序列化后的Animal对象
        System.out.println(deserializedAnimal);
    }
}

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.PROPERTY,
        property = "type"
)
@JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "cat")
})
abstract class Animal {
    private String name;

    // 无参构造函数
    public Animal() {}

    // 全参构造函数
    public Animal(String name) {
        this.name = name;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal{name='" + name + "'}";
    }
}

class Dog extends Animal {
    private int age;

    // 无参构造函数
    public Dog() {}

    // 全参构造函数
    public Dog(String name, int age) {
        super(name);
        this.age = age;
    }

    // Getter和Setter方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{name='" + getName() + "', age=" + age + "}";
    }
}

class Cat extends Animal {
    private String color;

    // 无参构造函数
    public Cat() {}

    // 全参构造函数
    public Cat(String name, String color) {
        super(name);
        this.color = color;
    }

    // Getter和Setter方法
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat{name='" + getName() + "', color='" + color + "'}";
    }
}

运行上述代码，输出结果为：

”`json {“type”:“dog”,“name”:“Bud

推荐阅读：
  1. expect的基础用法
  2. layui框架的flow组件的核心用法有哪些？

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

jackson

上一篇：9个爱不释手的JSON工具分别是什么

下一篇：egg.js开发中ctx返回格式及中间件的示例分析

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号