Java Jackson库

Jackson是Java生态系统中处理JSON数据最流行、功能最全面的库之一。它提供了简单易用的API，让开发者能够轻松地在JSON数据和Java对象之间进行转换。无论你是要构建RESTful API，还是处理来自第三方服务的JSON数据，掌握Jackson都将大大提高你的开发效率。

Jackson简介

Jackson框架由三个核心模块组成：

Jackson-core: 提供基础的流式API和解析功能
Jackson-annotations: 包含标准的Jackson注解
Jackson-databind: 提供数据绑定功能，实现JSON与Java对象之间的转换

备注

Jackson的名字取自作者的儿子，并不是指美国总统Andrew Jackson。

添加Jackson依赖

要在项目中使用Jackson，首先需要添加相应的依赖。如果你使用Maven，可以在pom.xml中添加以下依赖：

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

如果使用Gradle，则在build.gradle中添加：

groovy
implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'

提示

添加jackson-databind会自动引入jackson-core和jackson-annotations两个模块，所以通常不需要单独添加它们。

创建ObjectMapper

Jackson的核心类是ObjectMapper，它是线程安全的，一般在应用中可以创建一个单例使用：

java
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    // 后续方法...
}

JSON序列化（Java对象转JSON）

基本序列化

将Java对象转换为JSON字符串是Jackson最基本的功能之一：

java
public static String toJson(Object object) throws Exception {
    return objectMapper.writeValueAsString(object);
}

// 使用示例
public static void main(String[] args) throws Exception {
    Person person = new Person("张三", 25);
    String json = toJson(person);
    System.out.println(json);
}

输出：

{"name":"张三","age":25}

将JSON写入文件

java
public static void writeJsonToFile(Object object, String filePath) throws Exception {
    objectMapper.writeValue(new File(filePath), object);
}

// 使用示例
public static void main(String[] args) throws Exception {
    Person person = new Person("李四", 30);
    writeJsonToFile(person, "person.json");
    System.out.println("JSON已写入到person.json文件");
}

JSON反序列化（JSON转Java对象）

基本反序列化

从JSON字符串转换为Java对象：

java
public static <T> T fromJson(String json, Class<T> clazz) throws Exception {
    return objectMapper.readValue(json, clazz);
}

// 使用示例
public static void main(String[] args) throws Exception {
    String json = "{\"name\":\"王五\",\"age\":35}";
    Person person = fromJson(json, Person.class);
    System.out.println("姓名: " + person.getName() + ", 年龄: " + person.getAge());
}

输出：

姓名: 王五, 年龄: 35

从文件读取JSON

java
public static <T> T readJsonFromFile(String filePath, Class<T> clazz) throws Exception {
    return objectMapper.readValue(new File(filePath), clazz);
}

// 使用示例
public static void main(String[] args) throws Exception {
    Person person = readJsonFromFile("person.json", Person.class);
    System.out.println("从文件读取: " + person.getName() + ", " + person.getAge());
}

处理复杂JSON结构

处理JSON数组

将Java集合转换为JSON数组：

java
public static void main(String[] args) throws Exception {
    List<Person> persons = Arrays.asList(
        new Person("张三", 25),
        new Person("李四", 30),
        new Person("王五", 35)
    );
    
    String json = objectMapper.writeValueAsString(persons);
    System.out.println(json);
}

输出：

[{"name":"张三","age":25},{"name":"李四","age":30},{"name":"王五","age":35}]

将JSON数组转换为Java集合：

java
public static void main(String[] args) throws Exception {
    String json = "[{\"name\":\"张三\",\"age\":25},{\"name\":\"李四\",\"age\":30}]";
    
    // 使用TypeReference处理泛型
    List<Person> persons = objectMapper.readValue(json, 
        new TypeReference<List<Person>>(){});
    
    for (Person person : persons) {
        System.out.println(person.getName() + ": " + person.getAge());
    }
}

输出：

张三: 25
李四: 30

处理嵌套JSON对象

java
public class Department {
    private String name;
    private Person manager;
    private List<Person> employees;
    
    // 构造函数、getter和setter方法省略
}

public static void main(String[] args) throws Exception {
    Person manager = new Person("张总", 40);
    List<Person> employees = Arrays.asList(
        new Person("小王", 25),
        new Person("小李", 27)
    );
    
    Department dept = new Department();
    dept.setName("研发部");
    dept.setManager(manager);
    dept.setEmployees(employees);
    
    String json = objectMapper.writeValueAsString(dept);
    System.out.println(json);
}

输出：

{"name":"研发部","manager":{"name":"张总","age":40},"employees":[{"name":"小王","age":25},{"name":"小李","age":27}]}

Jackson注解的使用

Jackson提供了一系列注解，用于控制JSON序列化和反序列化的行为：

@JsonProperty

用于指定字段的JSON属性名：

java
public class User {
    @JsonProperty("user_name")
    private String name;
    
    @JsonProperty("user_age")
    private int age;
    
    // 构造函数、getter和setter方法省略
}

// 使用示例
public static void main(String[] args) throws Exception {
    User user = new User("张三", 25);
    String json = objectMapper.writeValueAsString(user);
    System.out.println(json);
}

输出：

{"user_name":"张三","user_age":25}

@JsonIgnore

用于排除某个字段，不进行序列化和反序列化：

java
public class User {
    private String name;
    
    @JsonIgnore
    private String password;
    
    private int age;
    
    // 构造函数、getter和setter方法省略
}

@JsonFormat

用于格式化日期类型：

java
public class Event {
    private String name;
    
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private Date timestamp;
    
    // 构造函数、getter和setter方法省略
}

// 使用示例
public static void main(String[] args) throws Exception {
    Event event = new Event();
    event.setName("系统启动");
    event.setTimestamp(new Date());
    
    String json = objectMapper.writeValueAsString(event);
    System.out.println(json);
}

输出：

{"name":"系统启动","timestamp":"2023-09-15 14:30:00"}

实际应用案例

RESTful API数据处理

假设我们正在开发一个用户管理系统的RESTful API：

java
@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;
    private final ObjectMapper objectMapper;
    
    // 构造函数注入
    public UserController(UserService userService, ObjectMapper objectMapper) {
        this.userService = userService;
        this.objectMapper = objectMapper;
    }
    
    @PostMapping
    public ResponseEntity<String> createUser(@RequestBody String userJson) {
        try {
            User user = objectMapper.readValue(userJson, User.class);
            User savedUser = userService.saveUser(user);
            return ResponseEntity.ok(objectMapper.writeValueAsString(savedUser));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body("{\"error\":\"" + e.getMessage() + "\"}");
        }
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<String> getUser(@PathVariable Long id) {
        try {
            User user = userService.getUserById(id);
            if (user == null) {
                return ResponseEntity.notFound().build();
            }
            return ResponseEntity.ok(objectMapper.writeValueAsString(user));
        } catch (Exception e) {
            return ResponseEntity.status(500).body("{\"error\":\"" + e.getMessage() + "\"}");
        }
    }
}

配置文件处理

使用Jackson读取JSON格式的配置文件：

java
public class AppConfig {
    private static final String CONFIG_FILE = "config.json";
    private static Configuration config;
    
    static {
        try {
            ObjectMapper mapper = new ObjectMapper();
            config = mapper.readValue(new File(CONFIG_FILE), Configuration.class);
        } catch (Exception e) {
            System.err.println("Failed to load configuration: " + e.getMessage());
            // 使用默认配置
            config = new Configuration();
        }
    }
    
    public static Configuration getConfig() {
        return config;
    }
    
    // Configuration类定义
    public static class Configuration {
        private String apiUrl = "http://localhost:8080/api";
        private int timeout = 30;
        private boolean debug = false;
        
        // getter和setter方法省略
    }
}

Jackson的高级特性

自定义序列化和反序列化

有时候默认的序列化行为可能不符合你的需求，Jackson允许你自定义这个过程：

java
public class CustomDateSerializer extends JsonSerializer<Date> {
    private static final SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
    
    @Override
    public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(formatter.format(value));
    }
}

public class Person {
    private String name;
    
    @JsonSerialize(using = CustomDateSerializer.class)
    private Date birthdate;
    
    // 构造函数、getter和setter方法省略
}

处理未知属性

默认情况下，如果JSON中包含Java类没有的属性，Jackson会抛出异常。可以配置ObjectMapper来忽略这些未知属性：

java
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

或者使用注解：

java
@JsonIgnoreProperties(ignoreUnknown = true)
public class Person {
    // 字段定义
}

总结

Jackson是Java中处理JSON数据的强大工具，它提供了：

简单的API，用于Java对象和JSON之间的转换
强大的注解系统，用于控制序列化和反序列化行为
灵活的自定义选项，以适应各种复杂场景
出色的性能和可靠性

通过本教程，你已经学会了Jackson的基本用法和一些高级特性。这些知识将帮助你在Java应用程序中有效地处理JSON数据。随着你的不断实践，你会发现Jackson能够满足几乎所有与JSON相关的需求。

练习

创建一个Book类，包含标题、作者、出版年份和价格字段，使用Jackson将其序列化为JSON。
编写代码从以下JSON字符串反序列化为Course对象：{"courseName":"Java编程","duration":8,"teacher":{"name":"李老师","subject":"计算机科学"}}。
使用@JsonFormat注解格式化日期，将当前时间序列化为"yyyy年MM月dd日"格式。
创建一个包含嵌套对象和数组的复杂JSON结构，然后编写代码将其反序列化。

延伸阅读

掌握了Jackson，你将能够更加自信地处理Java应用中的JSON数据，为构建现代的网络应用和微服务打下坚实的基础。

Jackson简介​

添加Jackson依赖​

创建ObjectMapper​

JSON序列化（Java对象转JSON）​

基本序列化​

将JSON写入文件​

JSON反序列化（JSON转Java对象）​

基本反序列化​

从文件读取JSON​

处理复杂JSON结构​

处理JSON数组​

处理嵌套JSON对象​

Jackson注解的使用​

@JsonProperty​

@JsonIgnore​

@JsonFormat​

实际应用案例​

RESTful API数据处理​

配置文件处理​

Jackson的高级特性​

自定义序列化和反序列化​

处理未知属性​

总结​

练习​

延伸阅读​