自定义Jackson序列化器进行数据脱敏

前言

Jackson 是用来序列化和反序列化 json 的 Java 的开源框架。Spring MVC 的默认 json 解析器便是 Jackson。与其他 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比较快；Jackson 运行时占用内存比较低，性能比较好；Jackson 有灵活的 API，可以很容易进行扩展和定制。
在有些业务场景下，后台保存的敏感数据不适宜在前端（或传输）直接展示，需要将敏感数据脱敏后返回，比较简单的方式是自定义Jackson序列化器进行数据脱敏。

自定义注解

package com.cube.share.jackson.annotation;

import com.cube.share.jackson.serializer.SensitiveDataSerializer;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.lang.annotation.*;

/**
 * @author poker.li
 * @date 2021/8/16 15:44
 * 

 * 需要脱密的字段注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@JacksonAnnotationsInside
@Target(ElementType.FIELD)
@JsonSerialize(using = SensitiveDataSerializer.class)
public @interface SensitiveData {

    /**
     * 默认的字段脱敏替换字符串
     */
    String DEFAULT_REPLACE_STRING = "*";

    /**
     * 脱敏策略
     */
    Strategy strategy() default Strategy.TOTAL;

    /**
     * 脱敏长度,在Strategy.TOTAL策略下忽略该字段
     */
    int length() default 0;

    /**
     * 脱敏字段替换字符
     */
    String replaceStr() default DEFAULT_REPLACE_STRING;

    enum Strategy {
        /**
         * 全部
         */
        TOTAL,
        /**
         * 从左边开始
         */
        LEFT,
        /**
         * 从右边开始
         */
        RIGHT
    }
}

这个注解比较简单，注释很详细就不赘述了。

自定义序列化器

package com.cube.share.jackson.serializer;

import com.cube.share.jackson.annotation.SensitiveData;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;

/**
 * @author poker.li
 * @date 2021/8/16 19:32
 * 

 * 脱敏字段序列化器
 */
public class SensitiveDataSerializer extends JsonSerializer implements ContextualSerializer {

    private SensitiveData sensitiveData;

    public SensitiveDataSerializer(SensitiveData sensitiveData) {
        this.sensitiveData = sensitiveData;
    }

    public SensitiveDataSerializer() {
    }


    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (StringUtils.isBlank(value)) {
            gen.writeString(value);
            return;
        }

        if (sensitiveData != null) {
            final SensitiveData.Strategy strategy = sensitiveData.strategy();
            final int length = sensitiveData.length();
            final String replaceString = sensitiveData.replaceStr();
            gen.writeString(getValue(value, strategy, length, replaceString));
        } else {
            gen.writeString(value);
        }

    }

    @Override
    public JsonSerializer createContextual(SerializerProvider prov, BeanProperty property) {
        SensitiveData annotation = property.getAnnotation(SensitiveData.class);

        if (annotation != null) {
            return new SensitiveDataSerializer(annotation);
        }
        return this;
    }

    private String getValue(String rawStr, SensitiveData.Strategy strategy, int length, String replaceString) {
        switch (strategy) {
            case TOTAL:
                return rawStr.replaceAll("[\\s\\S]", replaceString);
            case LEFT:
                return replaceByLength(rawStr, length, replaceString, true);
            case RIGHT:
                return replaceByLength(rawStr, length, replaceString, false);
            default:
                throw new IllegalArgumentException("Illegal Sensitive Strategy");
        }
    }

    private String replaceByLength(String rawStr, int length, String replaceString, boolean fromLeft) {
        if (StringUtils.isBlank(rawStr)) {
            return rawStr;
        }
        if (rawStr.length() <= length) {
            return rawStr.replaceAll("[\\s\\S]", replaceString);
        }

        if (fromLeft) {
            return getSpecStringSequence(length, replaceString) + rawStr.substring(length);
        } else {
            return rawStr.substring(0, length) + getSpecStringSequence(length, replaceString);
        }
    }

    private String getSpecStringSequence(int length, String str) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < length; i++) {
            stringBuilder.append(str);
        }
        return stringBuilder.toString();
    }
}

通过自定义序列化器改变使用注解 @SensitiveData字段在序列化时的表现，将其全部或部分使用特殊字符替换，从而达到脱敏的效果。

这里有必要提一下ContextualSerializer这个接口，ContextualSerializer内只有一个方法createContextual,自定义JsonSerializer实现ContextualSerializer后，该序列化器可以根据所要序列化属性（实体类的属性）的类型或者配置的注解类型来改变该属性的序列化行为；方法createContextual的声明如下：

public JsonSerializer createContextual(SerializerProvider prov, BeanProperty property)
        throws JsonMappingException;

参数SerializerProvider prov表示序列化器提供者，用于获取序列化配置或者其他序列化器，参数BeanProperty property表示代表这个属性的方法或者字段，用于获取要序列化的值。该方法的返回结果是一个序列化器，根据所要实现的序列化行为来决定是返回当前序列化器还是新建一个序列化器，从而改变序列化时的行为。
因此，在实现自定义序列化器时，可以通过判断某一字段上是否具有 @SensitiveData，如果有，获取该注解的属性并新建一个序列化器，改变当前字段在序列化时的行为。

测试

实体类声明如下：

package com.cube.share.jackson.entity;

import com.cube.share.jackson.annotation.SensitiveData;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonUnwrapped;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.time.LocalDateTime;

/**
 * @author poker.li
 * @date 2021/8/16 14:16
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Person {

    private Long id;

    private String name;

    private String address;

    private Integer age;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createAt;

    private LocalDateTime updateAt;

    @JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate lastLoginDate;

    @SensitiveData(strategy = SensitiveData.Strategy.LEFT, length = 6, replaceStr = "*")
    private String mobile;

    @JsonUnwrapped
    private Role role;
}

其中，字段手机号的前六位需要进行脱敏处理，并且使用'*'填充前六位。

package com.cube.share.jackson.controller;

import com.cube.share.base.templates.ApiResult;
import com.cube.share.jackson.entity.Person;
import com.cube.share.jackson.entity.Role;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.time.LocalDateTime;

/**
 * @author poker.li
 * @date 2021/8/16 14:17
 */
@RestController
@RequestMapping("/person")
@Slf4j
public class PersonController {

    @GetMapping("/detail/{id}")
    public ApiResult detail(@PathVariable("id") Long id) {
        Role role = new Role();
        role.setId(12L);
        role.setRoleName("管理员");
        return ApiResult.success(Person.builder()
                .id(id)
                .age(18)
                .name("lis")
                .address("北京")
                .createAt(LocalDateTime.now())
                .updateAt(LocalDateTime.now())
                .lastLoginDate(LocalDate.now())
                .mobile("15824984456")
                .role(role)
                .build());
    }

    @PostMapping("/save")
    public ApiResult save(@RequestBody Person person) {
        log.info("用户信息: {}", person);
        return ApiResult.success();
    }
}

调用详情接口响应如下：

{
code: 200,
msg: null,
data: {
id: 1,
name: "lis",
address: "北京",
age: 18,
createAt: "2021-08-18 21:53:04",
updateAt: "2021-08-18T21:53:04.346",
lastLoginDate: "2021-08-18",
mobile: "******84456",
roleName: "管理员",
desc: null,
roleId: 12
}
}

可以看出手机号返回值已经脱敏。

示例代码：https://gitee.com/li-cube/share/tree/master/jackson