Springboot JSON 转换：Jackson篇

乎语百科 2022-10-21 20:20:45 244 0

本案例基于 Springboot 2.5.7 单元测试场景下进行

<!-- SpringMVC默认使用Jacson，只需要引用web启动器即可，无序单独引用Jackson -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Springboot单元测试 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>
<!-- Lombok工具类 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!-- Hutool工具类 -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.3</version>
</dependency>

在后面的测试中会用到的实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserEntity {
    private Integer id;
    private String username;
    private String password;
    private Date birthday;
    private LocalDateTime lastLoginDate;
    private DeptEntity dept;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeptEntity {
    private Integer id;
    private String name;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> {

    private int code;
    private String msg;
    private T data;

    public static <T> Result<T> success(T data) {
        return new Result<>(200, "请求成功", data);
    }

}

IOC 容器中可以直接获取到 Jackson 的 ObjectMapper 实例

@SpringBootTest
public class SpringTest {
    @Autowired
    private ObjectMapper mapper;
}

基础类型转换

简单来说就是实体类转换，无论是实体类还是实体类嵌套方法都是一样的

实体类转换

@Test
void test() throws JsonProcessingException {
    // 实体类
    DeptEntity dept = new DeptEntity(10001, "部门A");
    // 序列化
    String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(dept);
    // 反序列化
    System.out.println(mapper.readValue(json, DeptEntity.class));
}

实体类嵌套转换

@Test
void test() {
    // 实体类
    Date birthday = new Date();
    LocalDateTime lastLoginDate = LocalDateTime.now();
    DeptEntity dept = new DeptEntity(10001, "部门A");
    UserEntity user = new UserEntity(10001, "用户A", null, birthday, lastLoginDate, dept);
    // 序列化
    String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
    // 反序列化
    System.out.println(mapper.readValue(json, UserEntity.class));
}

集合类型转换

集合转换简单了解这两种就够了，复杂一点的后面会提到

Collection 集合转换

@Test
void test() throws JsonProcessingException {
    // 构建List集合
    List<DeptEntity> source = CollUtil.newArrayList();
    for (int i = 1; i <= 5; i++) {
        source.add(new DeptEntity(10000 + i, "用户" + i));
    }
    // 序列化
    String json = mapper.writeValueAsString(source);
    // 构建Type对象
    CollectionType type = mapper.getTypeFactory().constructCollectionType(List.class, DeptEntity.class);
    // 反序列化
    List<DeptEntity> target = mapper.readValue(json, type);
    System.out.println(target);
}

Map 集合转换

@Test
void test() throws JsonProcessingException {
    // 构建List集合
    Map<String, String> source = MapUtil.newHashMap();
    source.put("aaa", "哈哈");
    source.put("bbb", "呵呵");
    // 序列化
    String json = mapper.writeValueAsString(source);
    // 构建Type对象
    MapLikeType type = mapper.getTypeFactory().constructMapLikeType(HashMap.class, String.class, String.class);
    // 反序列化
    Map<String, String> target = mapper.readValue(json, type);
    System.out.println(target);
}

复杂类型转换

这个部分的功能掌握了，类型转换就基本没啥问题了

带有泛型的序列化

@Test
void test() throws JsonProcessingException {
    // 实体类
    Result<DeptEntity> source = Result.success(new DeptEntity(10001, "部门A"));
    // 序列化
    String json = mapper.writeValueAsString(source);
    // 构建Type对象
    JavaType type = mapper.getTypeFactory().constructParametricType(Result.class, DeptEntity.class);
    // 反序列化
    Result<DeptEntity> target = mapper.readValue(json, type);
    System.out.println(target.getData().getClass());
    System.out.println(target);
}

泛型嵌套的序列化

@Test
void test() throws JsonProcessingException {
    String key = "res";
    // 重头戏来了 泛型嵌套的List集合
    List<Map<String, Result<DeptEntity>>> source = CollUtil.newArrayList();
    Map<String, Result<DeptEntity>> map = MapUtil.newHashMap();
    Result<DeptEntity> res = Result.success(new DeptEntity(10001, "部门A"));
    map.put(key, res);
    source.add(map);
    // 序列化
    String json = mapper.writeValueAsString(source);
    // 构建Type对象
    SimpleType stringType = SimpleType.constructUnsafe(String.class);
    JavaType result = mapper.getTypeFactory().constructParametricType(Result.class, DeptEntity.class);
    MapLikeType mapType = mapper.getTypeFactory().constructMapLikeType(HashMap.class, stringType, result);
    CollectionType type = mapper.getTypeFactory().constructCollectionType(List.class, mapType);
    // 反序列化
    List<Map<String, Result<DeptEntity>>> target = mapper.readValue(json, type);
    System.out.println(target.get(0).get(key).getData().getClass());
    System.out.println(target.get(0).get(key).getClass());
    System.out.println(target.get(0).getClass());
    System.out.println(target.getClass());
    System.out.println(target);
}

Jackson 的配置项

常见的用法是把 Controller 回传给前端的 JSON 进行一些处理，例如时间格式化、忽略 NULL 值等等

这些配置可以在配置文件中完成，可以重新注入ObjectMapper，也可以使用实体类注解单独配置

这部分内容用到哪些配置项，想起来就补充，随缘更新

配置文件

spring:
  jackson:
    # 格式化日期时使用的时区
    time-zone: GMT+8
    # 格式化
    date-format: yyyy-MM-dd HH:mm:ss.SSS
    # 用于格式化的语言环境
    locale: zh_CN
    serialization:
      # 是否开启格式化输出
      indent_output: false

重新注入 ObjectMapper

@Bean
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
    // 通过该方法对mapper对象进行设置，所有序列化的对象都将该规则进行序列化
    ObjectMapper objectMapper = builder.createXmlMapper(false).build();
    // Include.Include.ALWAYS 默认
    // Include.NON_DEFAULT 属性为默认值不序列化
    // Include.NON_EMPTY 属性为 空（""） 或者为 NULL 都不序列化，则返回的json是没有这个字段的。这样对移动端会更省流量
    // Include.NON_NULL 属性为NULL 不序列化
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    return objectMapper;
}

实体类注解

注解	作用
@JsonIgnoreProperties	批量设置转 JSON 时忽略的属性
@JsonIgnore	转 JSON 时忽略当前属性
@JsonProperty	修改转换后的 JSON 的属性名
@JsonFormat	转 JSON 时格式化属性的值

标签：