实现 SpringBoot 项目中的隐私数据脱敏

什么是数据脱敏

为了避免“用户信息泄露”的风险项（就是后台系统里用户的一些隐私数据直接明文显示了），其实指的就是要做数据脱敏。数据脱敏：把系统里的一些敏感数据进行加密处理后再返回，达到保护隐私作用。

如何实现数据脱敏

拿到数据后在序列化的时候再进行脱敏（如用 fastjson、jackson），以下是选择使用选用 jackson 的序列化来实现。

• 创建隐私数据类型枚举：PrivacyTypeEnum，分为常用的姓名、身份证号、邮箱、手机号、自定义。

package com.cbex.partyconstruction.privacyencrypt;

import lombok.Getter;

/**
 * 隐私数据类型枚举
 */
@Getter
public enum PrivacyTypeEnum {
    /** 自定义（此项需设置脱敏的范围）,也可以设置脱敏使用的字符*/
    CUSTOMER,

    /** 姓名 */
    NAME,

    /** 身份证号 */
    ID_CARD,

    /** 手机号 */
    PHONE,

    /** 邮箱 */
    EMAIL,
}

• 创建自定义隐私注解：PrivacyEncrypt，注解定义了参数包括脱敏的数据类型、前置不需要打码的长度、后置不需要打码的长度、用什么打码，当脱敏数据类型为自定义时可以设置需要打码的长度和打码使用的字符。

package com.cbex.partyconstruction.privacyencrypt;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义数据脱敏注解
 */
@Target(ElementType.FIELD) // 作用在字段上
@Retention(RetentionPolicy.RUNTIME) // class文件中保留，运行时也保留，能通过反射读取到
@JacksonAnnotationsInside // 表示自定义自己的注解PrivacyEncrypt
@JsonSerialize(using = PrivacySerializer.class) // 该注解使用序列化的方式
public @interface PrivacyEncrypt {

    /**
     * 脱敏数据类型（没给默认值，所以使用时必须指定type）
     */
    PrivacyTypeEnum type();

    /**
     * 前置不需要打码的长度
     */
    int prefixNoMaskLen() default 1;

    /**
     * 后置不需要打码的长度
     */
    int suffixNoMaskLen() default 1;

    /**
     * 用什么打码
     */
    String symbol() default "*";
}

• 创建自定义序列化器：PrivacySerializer
  1、这里是具体的实现过程，因为要脱敏的数据都是 String 类型的，所以继承 JsonSerializer 时的类型填 String。
  2、重写的 serialize 方法是实现脱敏的核心，根据类型 type 的不同去设置序列化后的值
  3、重写的 createContextual 方法就是去读取我们自定义的 PrivacyEncrypt 注解，打造一个上下文的环境。

package com.cbex.partyconstruction.privacyencrypt;

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 lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.util.Objects;

@NoArgsConstructor
@AllArgsConstructor
public class PrivacySerializer extends JsonSerializer<String> implements ContextualSerializer {

    // 脱敏类型
    private PrivacyTypeEnum privacyTypeEnum;
    // 前几位不脱敏
    private Integer prefixNoMaskLen;
    // 最后几位不脱敏
    private Integer suffixNoMaskLen;
    // 用什么打码
    private String symbol;

    @Override
    public void serialize(final String origin, final JsonGenerator jsonGenerator,
                          final SerializerProvider serializerProvider) throws IOException {
        if (StringUtils.isNotBlank(origin) && null != privacyTypeEnum) {
            switch (privacyTypeEnum) {
                case CUSTOMER:
                    jsonGenerator.writeString(PrivacyUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, symbol));
                    break;
                case NAME:
                    jsonGenerator.writeString(PrivacyUtil.hideChineseName(origin));
                    break;
                case ID_CARD:
                    jsonGenerator.writeString(PrivacyUtil.hideIDCard(origin));
                    break;
                case PHONE:
                    jsonGenerator.writeString(PrivacyUtil.hidePhone(origin));
                    break;
                case EMAIL:
                    jsonGenerator.writeString(PrivacyUtil.hideEmail(origin));
                    break;
                default:
                    throw new IllegalArgumentException("unknown privacy type enum " + privacyTypeEnum);
            }
        }
    }

    @Override
    public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider,
                                              final BeanProperty beanProperty) throws JsonMappingException {
        if (beanProperty != null) {
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                PrivacyEncrypt privacyEncrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
                if (privacyEncrypt == null) {
                    privacyEncrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
                }
                if (privacyEncrypt != null) {
                    return new PrivacySerializer(privacyEncrypt.type(), privacyEncrypt.prefixNoMaskLen(),
                            privacyEncrypt.suffixNoMaskLen(), privacyEncrypt.symbol());
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(null);
    }
}

• 隐私数据隐藏工具类：PrivacyUtil

package com.cbex.partyconstruction.privacyencrypt;

public class PrivacyUtil {

    /**
     * 隐藏手机号中间四位
     */
    public static String hidePhone(String phone) {
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }

    /**
     * 隐藏邮箱
     */
    public static String hideEmail(String email) {
        return email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
    }

    /**
     * 隐藏身份证
     */
    public static String hideIDCard(String idCard) {
        return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1*****$2");
    }

    /**
     * 【中文姓名】只显示第一个汉字，其他隐藏为星号，比如：任**
     */
    public static String hideChineseName(String chineseName) {
        if (chineseName == null) {
            return null;
        }
        return desValue(chineseName, 1, 0, "*");
    }

//    /**
//     * 【身份证号】显示前4位, 后2位
//     */
//    public static String hideIdCard(String idCard) {
//        return desValue(idCard, 4, 2, "*");
//    }

//    /**
//     * 【手机号码】前三位，后四位，其他隐藏。
//     */
//    public static String hidePhone(String phone) {
//        return desValue(phone, 3, 4, "*");
//    }

    /**
     * 对字符串进行脱敏操作
     * @param origin          原始字符串
     * @param prefixNoMaskLen 左侧需要保留几位明文字段
     * @param suffixNoMaskLen 右侧需要保留几位明文字段
     * @param maskStr         用于遮罩的字符串, 如'*'
     * @return 脱敏后结果
     */
    public static String desValue(String origin, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
        if (origin == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0, n = origin.length(); i < n; i++) {
            if (i < prefixNoMaskLen) {
                sb.append(origin.charAt(i));
                continue;
            }
            if (i > (n - suffixNoMaskLen - 1)) {
                sb.append(origin.charAt(i));
                continue;
            }
            sb.append(maskStr);
        }
        return sb.toString();
    }


}

这个工具类其实可以自己定，根据自己的业务去扩展

在自定义注解 PrivacyEncrypt 里，只有 type 的值为 PrivacyTypeEnum.CUSTOMER（自定义）时，才需要指定脱敏范围，即 prefixNoMaskLen 和 suffixNoMaskLen 的值，像邮箱、手机号这种隐藏格式都采用固定的

注解使用demo

1、使用固定类型的脱敏方式

public class StaffInfoPo {
    @ApiModelProperty(value = "主键")
    private Long id;

    @ApiModelProperty(value = "职工姓名")
    private String name;

    @ApiModelProperty(value = "职工手机号")
    @FieldEncrypt
    @PrivacyEncrypt(type = PrivacyTypeEnum.PHONE)
    private String phone;

}

2、使用自定义的脱敏方式

public class StaffInfoPo {
    @ApiModelProperty(value = "主键")
    private Long id;

    @ApiModelProperty(value = "职工姓名")
    private String name;

    @ApiModelProperty(value = "职工手机号")
    @PrivacyEncrypt(type = PrivacyTypeEnum.CUSTOMER,symbol = "?",prefixNoMaskLen = 2,suffixNoMaskLen = 2)
    private String phone;
    
}