自定义json数据的对象转换器

1. 问题描述

• 当我们从后端获取时间到前端时不是我们想要的格式，于是我们需要在传给前端时要进行格式的转换
• 后端数据表定义的id主键是Long类型，一共有20多位。 前端在接收到后端返回的json数据时，Long类型会默认当做数值类型进行处理。但前端处理20多位的数值会造成精度丢失，于是导致前端查询数据出现问题。

2. 解决

• 在SpringBoot项目中，默认使用Jackson 来序列化和反序列化 json数据，针对上面的问题，在处理日期格式时，我们有两种解决方案，一种是使用@JsonFormat注解，另一个方案是使用自定义对象转换器方式进行格式的统一转换。建议采用自定义对象转换器的方式（因为他可以统一处理，当实体类很多时，不需要我们反复加注解），在后端将数据转为json数据时，将日期格式转换成我们想要的格式再转成json数据返回前端，将Long类型的数据，统一转换为String类型，再转为json数据返回，避免前端处理Long类型数据造成精度丢失。

3. Demo演示

3.1. @JsonFormat

• pojo用于我们封装数据，并在日期上设置注解@JsonFormat(pattern = "yyyy-MM-dd HH:mm")

package com.example.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer id;
    private String username;
    private String password;
    private String phone;
    private Integer status;
    private Integer balance;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
    private LocalDateTime createTime;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
    private LocalDateTime updateTime;
}

• 测试

package com.example.controller;

import com.example.entity.User;
import com.example.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;


    @GetMapping("/{id}")
    public User getById(@PathVariable Integer id){
        User user =  userService.getById(id);
        System.out.println(user.getCreateTime());
        return user;
    }
}

加上注解，确实是我们设置想要的格式

不加注解时，可以看到不是我们想要的格式

3.2. 自定义json数据的对象转换器

对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象

将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]

从Java对象生成JSON的过程称为 [序列化Java对象到JSON]

• 在上面的基础我们只需注释掉@JsonFormat以排除对这次操作的影响。首先编写JacksonObjectMapper对象转换器

该自定义的对象转换器, 主要指定了在进行json数据序列化及反序列化时, LocalDateTime、LocalDate、LocalTime的处理方式，以及BigInteger和Long类型数据，在序列化时直接转换为字符串。

package com.example.json;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import java.math.BigInteger;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {
    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        SimpleModule simpleModule = new SimpleModule()
        // 反序列化时的处理
        .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
        .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
        .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))

        // 序列化时的处理
        // 处理 BigInteger 类型
        .addSerializer(BigInteger.class, ToStringSerializer.instance)
        // 处理 Long 类型
        .addSerializer(Long.class, ToStringSerializer.instance)

        .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
        .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
        .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
        //注册功能模块，添加自定义序列化与反序列化器
        this.registerModule(simpleModule);
    }
}

• 在WebMvcConfig中重写方法extendMessageConverters，添加自定义对象转换器

package com.example.config;

import com.example.json.JacksonObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;

@Configuration
@Slf4j
public class WebMvcConfiguration implements WebMvcConfigurer {

    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        log.info("扩展消息转换器");
        //创建消息转换器对象
        MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        //设置对象转换器，底层使用Jackson将Java对象转为json
        messageConverter.setObjectMapper(new JacksonObjectMapper());
        //将上面的消息转换器对象追加到mvc框架的转换器集合中
        converters.add(0,messageConverter);

    }
}

• 测试