Spring Boot Json序列化终极配置

现在的Web应用都是通过json序列化，SpringBoot内置Jackson工具提供json -> bean 或者 bean -> json序列化的。在SpringBoot序列化中，我们可以自定义json的序列化过程，比如增加脱敏，忽略字段，格式化时间，类型转化等。

解决数据库bigint类型JS会丢失精度问题

如果我们的数据库主键采用雪花算法生成的id，该id在数据库中是bigint类型，在Java代码中的表现形式是Long类型。但是我们把这个id传给前端的话，前端用JS接受会丢失精度，使得最后两位变成0，这就造成了前端在用这个id进行操作的时候，会给我们一个错误的id，如果要解决这个方法，有两种方式。

• 方式一

  // 注解处理，这里可以配置公共 baseEntity 处理
  @JsonSerialize(using=ToStringSerializer.class)
  public long getId() {
      return id;
  }

• 方式二

  //添加对长整型的转换关系
  ObjectMapper objectMapper = new ObjectMapper();
  ToStringSerializer stringSerializer = ToStringSerializer.instance;
  simpleModule.addSerializer(BigInteger.class, stringSerializer);
  simpleModule.addSerializer(Long.class, stringSerializer);
  simpleModule.addSerializer(Long.TYPE, stringSerializer);
  objectMapper.registerModule(simpleModule);

个人更推荐方式二，毕竟我本人并不喜欢在实体类里面加一些关于json的注解。

格式化时间

中国时间的格式一般返回yyyy-MM-dd HH:mm:ss  格式，实现时间格式化转换，也有好几种方式。

• 方式一

  private static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  
  ObjectMapper objectMapper = new ObjectMapper();
  JavaTimeModule javaTimeModule = new JavaTimeModule();
  javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  objectMapper.registerModule(javaTimeModule).registerModule(new ParameterNamesModule());

• 方式二

  spring:
    jackson:
      date-format: yyyy-MM-dd HH:mm:ss
      time-zone: GMT+8

• 方式三

  @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
  private LocalDateTime createTime;

个人更推荐方式一，对实体类或者VO、DTO类的代码没有侵入

忽略字段

在返回给前端的字段中，有可能我们会将数据库的实体类返回，实体类中，有一些无关紧要的字段，比如 createTime, updateTime, deleted等通用字段，我们可以在json序列化的时候忽略掉

// 设置过滤字段
SimpleBeanPropertyFilter fieldFilter = SimpleBeanPropertyFilter.serializeAllExcept("create_time", "update_time", "deleted");
SimpleFilterProvider filterProvider = new SimpleFilterProvider().addFilter("defaultValue", fieldFilter);
objectMapper.setFilterProvider(filterProvider).addMixIn(BaseEntity.class, PropertyFilterMixIn.class);

@JsonFilter("defaultValue")
interface PropertyFilterMixIn {
}

除了上述方法，也可以在实体类上添加@JsonIgnore注解，但是我不喜欢。

脱敏

利用json序列化，我们可以定制一些高级的功能，比如敏感字段不全部显示，中间显示 ***等，好比手机号: 156****2570这种效果。

• 先定义一些枚举，表示要脱敏字段的类型

  public enum SensitiveTypeEnum {
  
  
      /**
       * 身份证号
       */
      ID_CARD,
      /**
       * 密码
       */
      PASSWORD,
      /**
       * 手机号
       */
      MOBILE_PHONE,
      /**
       * 电子邮件
       */
      EMAIL,
      /**
       * 真实姓名
       */
      NAME,
      /**
       * 账户信息
       */
      ACCOUNT_NO;
  }
  

• 脱敏的工具类

  public class SensitiveUtils {
  
      /**
       * [真实姓名] 显示最后四位，其他隐藏。共计18位或者15位。<例子：*************5762>
       */
      public static String realName(final String realName) {
          if (StringUtils.isBlank(realName)) {
              return "";
          }
          return dealString(realName, 1, 0);
      }
  
      /**
       * [身份证号] 显示最后四位，其他隐藏。共计18位或者15位。<例子：*************5762>
       */
      public static String idCard(final String idCard) {
          if (StringUtils.isBlank(idCard)) {
              return "";
          }
          return dealString(idCard, 3, 4);
      }
  
      /**
       * [手机号] 显示最后四位，其他隐藏。共计18位或者15位。<例子：*************5762>
       */
      public static String mobilePhone(final String idCard) {
          if (StringUtils.isBlank(idCard)) {
              return "";
          }
          return dealString(idCard, 3, 4);
      }
  
      /**
       * [邮箱] 显示最后四位，其他隐藏。共计18位或者15位。<例子：*************5762>
       */
      public static String email(final String email) {
          if (StringUtils.isBlank(email)) {
              return "";
          }
          int index = email.indexOf("@");
          return dealString(email, 3, email.length() - index);
      }
  
      /**
       * [账号] 显示最后四位，其他隐藏。共计18位或者15位。<例子：*************5762>
       */
      public static String acctNo(final String idCard) {
          if (StringUtils.isBlank(idCard)) {
              return "";
          }
          final String name = StringUtils.left(idCard, 1);
          return StringUtils.rightPad(name, StringUtils.length(idCard), "*");
      }
  
      /**
       * [密码] 隐藏。<例子：*************>
       */
      public static String password(final String password) {
          if (StringUtils.isBlank(password)) {
              return "";
          }
          return "*";
      }
  
  
      private static String dealString(String str, int headOff, int tailOff) {
          int length = str.length();
          StringBuilder sb = new StringBuilder();
          final String head = StringUtils.left(str, headOff);
          String tail = StringUtils.right(str, tailOff);
          sb.append(head);
          int size = length - (headOff + tailOff);
          if (size > 0) {
              while (size > 0) {
                  sb.append("*");
                  size--;
              }
          }
          sb.append(tail);
          return sb.toString();
      }
  
  
      /**
       * 提供给外部进行直接脱敏处理
       * @param type
       * @param value
       * @return
       */
      public static String sensitveValue(SensitiveTypeEnum type, String value) {
          switch (type) {
              case NAME: {
                  return realName(String.valueOf(value));
              }
              case ID_CARD: {
                  return idCard(String.valueOf(value));
              }
              case MOBILE_PHONE: {
                  return mobilePhone(String.valueOf(value));
              }
              case EMAIL: {
                  return email(String.valueOf(value));
              }
              case ACCOUNT_NO: {
                  return acctNo(String.valueOf(value));
              }
              case PASSWORD: {
                  return password(String.valueOf(value));
              }
              default:
                  return String.valueOf(value);
          }
  
      }
  
  
  }
  

此工具类可以单独使用

• 将脱敏过程绑定到json序列化

  import com.fasterxml.jackson.core.JsonGenerator;
  import com.fasterxml.jackson.databind.BeanProperty;
  import com.fasterxml.jackson.databind.JsonMappingException;
  import com.fasterxml.jackson.databind.JsonSerializer;
  import com.fasterxml.jackson.databind.SerializerProvider;
  import com.fasterxml.jackson.databind.ser.ContextualSerializer;
  import com.storyhasyou.kratos.annotation.Sensitive;
  import com.storyhasyou.kratos.enums.SensitiveTypeEnum;
  import com.storyhasyou.kratos.utils.SensitiveUtils;
  
  import java.io.IOException;
  import java.util.Objects;
  
  
  public class SensitiveSerialize extends JsonSerializer<Object> implements ContextualSerializer {
  
      private final SensitiveTypeEnum type;
  
      public SensitiveSerialize(final SensitiveTypeEnum type) {
          this.type = type;
      }
  
      public SensitiveSerialize() {
          this.type = SensitiveTypeEnum.NAME;
      }
  
  
      @Override
      public void serialize(Object value, JsonGenerator jsonGenerator, SerializerProvider serializers) throws IOException {
          switch (this.type) {
              case ID_CARD: {
                  jsonGenerator.writeString(SensitiveUtils.idCard(String.valueOf(value)));
                  break;
              }
              case MOBILE_PHONE: {
                  jsonGenerator.writeString(SensitiveUtils.mobilePhone(String.valueOf(value)));
                  break;
              }
              case EMAIL: {
                  jsonGenerator.writeString(SensitiveUtils.email(String.valueOf(value)));
                  break;
              }
              case ACCOUNT_NO: {
                  jsonGenerator.writeString(SensitiveUtils.acctNo(String.valueOf(value)));
                  break;
              }
              case PASSWORD: {
                  jsonGenerator.writeString(SensitiveUtils.password(String.valueOf(value)));
                  break;
              }
              case NAME: {
                  jsonGenerator.writeString(SensitiveUtils.realName(String.valueOf(value)));
                  break;
              }
              default:
                  jsonGenerator.writeString(String.valueOf(value));
  
          }
  
      }
  
      @Override
      public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
  
          if (beanProperty != null) {
  
              // 非 String 类直接跳过
              if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                  Sensitive sensitiveInfo = beanProperty.getAnnotation(Sensitive.class);
                  if (sensitiveInfo == null) {
                      sensitiveInfo = beanProperty.getContextAnnotation(Sensitive.class);
                  }
                  // 如果能得到注解，就将注解的 value 传入 SensitiveInfoSerialize
                  if (sensitiveInfo != null) {
  
                      return new SensitiveSerialize(sensitiveInfo.value());
                  }
              }
              return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
          }
          return serializerProvider.findNullValueSerializer(beanProperty);
  
      }
  }
  

• 最后添加一个注解

  import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
  import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  import com.storyhasyou.kratos.toolkit.SensitiveSerialize;
  import com.storyhasyou.kratos.enums.SensitiveTypeEnum;
  
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  
  
  @Retention(RetentionPolicy.RUNTIME)
  @JacksonAnnotationsInside
  @JsonSerialize(using = SensitiveSerialize.class)
  public @interface Sensitive {
  
      SensitiveTypeEnum value() default SensitiveTypeEnum.PASSWORD;
  
  }
  

将需要脱敏的字段，打上这个注解，就可以在json序列化中，进行脱敏操作。

一个生产环境json配置文件

import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import com.storyhasyou.kratos.base.BaseEntity;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;

import java.math.BigInteger;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;


@Configuration
public class JacksonConfig {

    private static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    private static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";

    @Bean
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
        ObjectMapper objectMapper = new ObjectMapper();
        //定义Json转换器
        MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        // 设置Jackson序列化和反序列化的时候，使用下划线分割
        objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
        objectMapper.registerModule(javaTimeModule).registerModule(new ParameterNamesModule());

        // 设置过滤字段
        SimpleBeanPropertyFilter fieldFilter = SimpleBeanPropertyFilter.serializeAllExcept("create_time", "update_time", "deleted");
        SimpleFilterProvider filterProvider = new SimpleFilterProvider().addFilter("defaultValue", fieldFilter);
        objectMapper.setFilterProvider(filterProvider).addMixIn(BaseEntity.class, PropertyFilterMixIn.class);

        SimpleModule simpleModule = new SimpleModule();
        //添加对长整型的转换关系
        ToStringSerializer stringSerializer = ToStringSerializer.instance;
        simpleModule.addSerializer(BigInteger.class, stringSerializer);
        simpleModule.addSerializer(Long.class, stringSerializer);
        simpleModule.addSerializer(Long.TYPE, stringSerializer);
        //将对象模型添加至对象映射器
        objectMapper.registerModule(simpleModule);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        objectMapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);
        //将对象映射器添加至Json转换器
        jackson2HttpMessageConverter.setObjectMapper(objectMapper);
        return jackson2HttpMessageConverter;
    }

    @JsonFilter("defaultValue")
    interface PropertyFilterMixIn {
    }


}