当前位置：首页 > news >正文

Jackson使用

news 来源：原创 2025/4/30 21:06:13

Jackson 是一个功能强大的 JSON 处理库，除了基本的序列化和反序列化功能外，它还提供了许多其他功能，以满足不同的需求。以下是一些常用的高级功能：

0.普通序列化反序列化

序列化
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            User user = new User("Alice", 30);
            // 将 User 对象序列化为 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


反序列化

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            String jsonString = "{\"name\":\"Alice\",\"age\":30}";
            // 将 JSON 字符串反序列化为 User 对象
            User user = objectMapper.readValue(jsonString, User.class);
            System.out.println("Name: " + user.getName());
            System.out.println("Age: " + user.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

集合

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            String jsonArrayString = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]";
            // 将 JSON 数组反序列化为 List<User>
            List<User> users = objectMapper.readValue(jsonArrayString, new TypeReference<List<User>>() {});
            for (User user : users) {
                System.out.println("Name: " + user.getName() + ", Age: " + user.getAge());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1. 自定义序列化和反序列化

你可以通过实现 `JsonSerializer` 和 `JsonDeserializer` 接口来自定义序列化和反序列化的过程。

#### 自定义序列化示例
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

import java.io.IOException;

public class UserSerializer extends JsonSerializer<User> {
    @Override
    public void serialize(User user, JsonGenerator jsonGenerator, SerializerProvider serializers) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("fullName", user.getName());
        jsonGenerator.writeNumberField("yearsOld", user.getAge());
        jsonGenerator.writeEndObject();
    }
}
#### 自定义反序列化示例
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

import java.io.IOException;

@JsonDeserialize(using = UserDeserializer.class)
public class User {
    // ... 其他代码 ...

    // 反序列化
    public static class UserDeserializer extends JsonDeserializer<User> {
        @Override
        public User deserialize(com.fasterxml.jackson.core.JsonParser p, DeserializationContext ctxt) throws IOException {
            // 自定义反序列化逻辑
            // 解析 JSON 并返回 User 对象
        }
    }
}

2. 使用注解

Jackson 提供了多种注解，以便更好地控制序列化和反序列化的行为。

- `@JsonProperty` ：指定字段在 JSON 中的名称。
- `@JsonIgnore` ：忽略某个字段。
- `@JsonInclude` ：指定序列化时的包含策略。
- `@JsonFormat` ：指定日期格式。

示例：
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
    @JsonProperty("full_name")
    private String name;

    @JsonIgnore
    private int age;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    private Date birthDate;

    // ... 其他代码 ...
}

3. 处理复杂类型

Jackson 可以处理复杂类型，例如嵌套对象和集合。
public class Group {
private String groupName;
private List<User> users;

// ... 其他代码 ...
}

4. 读取和写入 JSON 文件

Jackson 还可以直接读取和写入 JSON 文件。

#### 写入 JSON 文件
objectMapper.writeValue(new File("user.json"), user);
#### 读取 JSON 文件
User user = objectMapper.readValue(new File("user.json"), User.class);

5. 配置 ObjectMapper

你可以通过配置 `ObjectMapper` 来定制 Jackson 的行为，例如启用或禁用特性、设置默认视图等。

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.enable(SerializationFeature.INDENT_OUTPUT); // 美化输出
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); //

忽略未知属性

6. 处理多态类型

Jackson 支持多态类型的处理，可以使用 `@JsonTypeInfo` 和 `@JsonSubTypes` 注解来处理。

@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")
})
public abstract class Animal {
    // ...
}

`@JsonTypeInfo` 是 Jackson 提供的一个注解，用于在序列化和反序列化过程中处理多态类型。它的主要作用是告诉 Jackson 如何在 JSON 数据中包含类型信息，以便在反序列化时能够正确地识别和实例化具体的子类。

### 主要功能

1. **指定类型信息的使用方式**：

- `use` ：指定类型信息的类型，通常使用 `JsonTypeInfo.Id.NAME` 表示使用类名或其他名称作为类型信息。
- `include` ：指定类型信息在 JSON 中的包含方式。常见的选项包括：
- `JsonTypeInfo.As.PROPERTY` ：将类型信息作为一个属性包含在 JSON 对象中。
- `JsonTypeInfo.As.EXISTING_PROPERTY` ：使用一个已经存在的属性作为类型信息。
- `JsonTypeInfo.As.WRAPPER_OBJECT` ：将类型信息作为一个包装对象。
- `JsonTypeInfo.As.WRAPPER_ARRAY` ：将类型信息作为一个包装数组。

2. **指定类型信息的属性名称**：

- `property` ：指定在 JSON 中用作类型信息的属性名称。例如，可以将类型信息放在一个名为 `type` 的字段中。

### 示例以下是一个使用 `@JsonTypeInfo` 的示例：

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

@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")
})
public abstract class Animal {
    public abstract String makeSound();
}

public class Dog extends Animal {
    @Override
    public String makeSound() {
        return "Woof!";
    }
}

public class Cat extends Animal {
    @Override
    public String makeSound() {
        return "Meow!";
    }
}
### 序列化和反序列化

在序列化时， `Animal`  的子类会生成包含类型信息的 JSON：
ObjectMapper objectMapper = new ObjectMapper();

Animal dog = new Dog();
String jsonDog = objectMapper.writeValueAsString(dog);
System.out.println(jsonDog); // 输出: {"type":"dog"}

Animal cat = new Cat();
String jsonCat = objectMapper.writeValueAsString(cat);
System.out.println(jsonCat); // 输出: {"type":"cat"}
在反序列化时，Jackson 会根据  `type`  属性的值来确定使用哪个具体的子类：
String jsonDog = "{\"type\":\"dog\"}";
Animal animal = objectMapper.readValue(jsonDog, Animal.class);
System.out.println(animal.makeSound()); // 输出: Woof!

String jsonCat = "{\"type\":\"cat\"}";
animal = objectMapper.readValue(jsonCat, Animal.class);
System.out.println(animal.makeSound()); // 输出: Meow!

`@JsonTypeInfo` 注解在处理多态类型时非常有用，它确保在序列化和反序列化过程中能够正确地识别和实例化对象的具体类型。这对于构建复杂的数据模型和处理继承结构的数据非常重要。