配置全局序列化/反序列化策略

背景

后端以json格式响应前端请求时，有些类型需要指定序列化策略，否则会有精度丢失、日期格式不规范等问题。

问题示例

定义一个Order类

@Data
public class Order {
    /**
     * 订单id
     */
    private Long orderId;

    /**
     * 单价
     */
    private BigDecimal unitPrice;

    /**
     * 创建日期
     */
    private Date createDate;
}

后端提供一个查询订单的接口

@GetMapping("queryOrder")
public Order queryOrder (){
    Order order = new Order();
    order.setOrderId(123456789123456789L);
    order.setCreateDate(new Date());
    order.setUnitPrice(BigDecimal.valueOf(12.34));
    return order;
}

按项目默认序列化策略，返回给前端的json可能如下

{
    "orderId": 123456789123456789,
    "unitPrice": 12.34,
    "createDate": "2023-02-05 16:10:57"
}

该json有以下问题

orderId和unitPrice传输到浏览器时，由于是数值类型，有时会出现精度丢失（即后面几位小数被置为0）
createDate的日期格式，取决于项目的默认策略，有时会在不知情的情况下发生变化导致bug（比如升级springboot版本）
createDate的日期格式体现不出时区，在国际化项目中会有歧义
假设一个项目，拆分为若干微服务，不同微服务返回给前端的日期格式不同，导致用户体验不一致，或者前端需要额外兼容成本

解决思路

数值在返回给前端前，应序列化为字符串，避免精度丢失
日期在返回给前端前，应该有统一的序列化策略，统一格式，并且能体现时区，建议使用ISO8061格式作为标准格式

正例如下

{
    "orderId": "123456789123456789",
    "unitPrice": "12.34",
    "createDate": "2023-02-06T00:04:00.839+0800"
}

ISO8601是一种国际通用的无歧义的格式
2023-02-06T00:04:00.839+0800最后的+800表示该时间是UTC+8时区时间
如果是UTC时间，可以在最后加一个Z，比如2023-02-06T00:04:00.839Z

代码示例

spring-boot-starter-parent版本为2.0.2.RELEASE

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.module.SimpleModule;
import org.apache.commons.lang3.StringUtils;
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.WebMvcConfigurationSupport;

import java.io.IOException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**
 * 全局序列化反序列化策略
 */
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {

    /**
     * 以ISO8061格式作为标准格式，示例如1998-12-12T00:00:00+01:00
     */
    private static final String STANDARD_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";

    /**
     * 常见日期格式
     */
    private static final String[] DATE_PATTERNS = {"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", "yyyy-MM-dd'T'HH:mm:ss.SSSZ", "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
            "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss",
            "yyyy.MM.dd HH:mm", "yyyy.MM", "yyyy-MM-dd HH:mm:ss.S"};

    /**
     * 使用jackson进行序列化反序列化
     * @return
     */
    public MappingJackson2HttpMessageConverter jackson2HttpMessageConverter() {
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule simpleModule = new SimpleModule();

        // Date类型序列化和反序列化
        simpleModule.addSerializer(Date.class, new DateJsonSerializer());
        simpleModule.addDeserializer(Date.class, new DateJsonDeserializer());

        // Long类型序列化
        simpleModule.addSerializer(Long.class, new LongSerializer());
        simpleModule.addSerializer(long.class, new LongSerializer());

        // BigDecimal类型序列化
        simpleModule.addSerializer(BigDecimal.class, new BigDecimalSerializer());

        objectMapper.registerModule(simpleModule);
        converter.setObjectMapper(objectMapper);
        return converter;
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(jackson2HttpMessageConverter());
    }

    /**
     * Date类型序列化
     */
    static class DateJsonSerializer extends JsonSerializer<Date> {

        @Override
        public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            if (value == null) {
                return;
            }

            SimpleDateFormat formatter = new SimpleDateFormat(STANDARD_TIME_FORMAT);
            gen.writeString(formatter.format(value));
        }
    }

    /**
     * Date类型反序列化
     */
    static class DateJsonDeserializer extends JsonDeserializer<Date> {

        @Override
        public Date deserialize(JsonParser p, DeserializationContext ctx) throws IOException, JsonProcessingException {
            String text = p.getText();
            if (StringUtils.isBlank(text)) {
                return null;
            }

            // 尝试用时间戳解析
            try {
                long timestamp = Long.parseLong(text);
                return new Date(timestamp);
            } catch (Exception e) {

            }

            // 遍历常用时间格式，逐个解析
            for (String pattern: DATE_PATTERNS) {
                try {
                    SimpleDateFormat formatter = new SimpleDateFormat(pattern);
                    return formatter.parse(text);
                } catch (Exception e) {

                }
            }

            throw new IllegalArgumentException("illegal date format");
        }
    }

    /**
     * Long类型序列化
     */
    static class LongSerializer extends JsonSerializer<Long> {

        @Override
        public void serialize(Long value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            if (value == null) {
                return;
            }
            gen.writeString(String.valueOf(value));
        }
    }

    /**
     * BigDecimal类型序列化
     */
    static class BigDecimalSerializer extends JsonSerializer<BigDecimal> {

        @Override
        public void serialize(BigDecimal value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            if (value == null) {
                return;
            }
            String str = value.stripTrailingZeros().toPlainString();
            gen.writeString(str);
        }
    }
}