一、简述

数据脱敏：数据脱敏，指对某些敏感信息通过脱敏规则进行数据的变形，实现敏感隐私数据的可靠保护。这样就可以在开发、测试和其它非生产环境以及外包环境中安全地使用脱敏后的真实数据集。

脱敏工具类

SensitivityUtil

public class SensitivityUtil {
    /**
     * 【中文姓名】只显示第一个汉字，其他隐藏为星号，比如：才**
     */
    public static String hideChineseName(String chineseName) {
        if (chineseName == null) {
            return null;
        }
        return desValue(chineseName, 1, 0, "*");
    }
 
    /**
     * 隐藏邮箱
     */
    public static String hideEmail(String email) {
        return email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
    }
 
    /**
     * 隐藏手机号中间四位
     */
    public static String hidePhone(String phone) {
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }
 
    /**
     * 隐藏身份证
     */
    public static String hideIDCard(String idCard) {
        return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1*****$2");
    }
 
    /**
     * 对字符串进行脱敏操作
     *
     * @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();
    }
}

脱敏类型枚举

SensitivityTypeEnum

@Getter
public enum SensitivityTypeEnum {
 
    /**
     * 姓名
     */
    NAME,
 
    /**
     * 身份证号
     */
    ID_CARD,
 
    /**
     * 邮箱
     */
    EMAIL,
 
    /**
     * 手机号
     */
    PHONE,
 
    /**
     *  自定义（此项需设置脱敏的前置后置长度）
     */
    CUSTOMER,
}

脱敏注解

SensitivityEncrypt

/**
 * 自定义数据脱敏注解
 * @author 10419
 */
// 作用在字段上
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = SensitivitySerializer.class) // 该注解使用序列化的方式
public @interface SensitivityEncrypt {
 
    /**
     * 脱敏数据类型（必须指定类型）
     */
    SensitivityTypeEnum type();
 
    /**
     * 前面有多少不需要脱敏的长度
     */
    int prefixNoMaskLen() default 1;
 
    /**
     * 后面有多少不需要脱敏的长度
     */
    int suffixNoMaskLen() default 1;
 
    /**
     * 用什么符号进行打码
     */
    String symbol() default "*";
}

自定义脱敏序列化

SensitivitySerializer

@NoArgsConstructor
@AllArgsConstructor
public class SensitivitySerializer extends JsonSerializer<String> implements ContextualSerializer {
 
    // 脱敏类型
    private SensitivityTypeEnum sensitivityTypeEnum;
    // 前几位不脱敏
    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 != sensitivityTypeEnum) {
            //判断脱敏类型，进入对应类型的数据处理
            switch (sensitivityTypeEnum) {
                case CUSTOMER:
                    jsonGenerator.writeString(SensitivityUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, symbol));
                    break;
                case NAME:
                    jsonGenerator.writeString(SensitivityUtil.hideChineseName(origin));
                    break;
                case ID_CARD:
                    jsonGenerator.writeString(SensitivityUtil.hideIDCard(origin));
                    break;
                case PHONE:
                    jsonGenerator.writeString(SensitivityUtil.hidePhone(origin));
                    break;
                case EMAIL:
                    jsonGenerator.writeString(SensitivityUtil.hideEmail(origin));
                    break;
                default:
                    throw new IllegalArgumentException("unknown privacy type enum " + sensitivityTypeEnum);
            }
        } else {
            //如果脱敏类型为空则赋值空，要不然会导致序列化错误
            jsonGenerator.writeString("");
        }
    }
 
    /**
     * 读取自定义注解SensitivityEncrypt 创建上下文所需
     */
    @Override
    public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider,
                                              final BeanProperty beanProperty) throws JsonMappingException {
        if (beanProperty != null) {
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                SensitivityEncrypt sensitivityEncrypt = beanProperty.getAnnotation(SensitivityEncrypt.class);
                if (sensitivityEncrypt == null) {
                    sensitivityEncrypt = beanProperty.getContextAnnotation(SensitivityEncrypt.class);
                }
                if (sensitivityEncrypt != null) {
                    return new SensitivitySerializer(sensitivityEncrypt.type(), sensitivityEncrypt.prefixNoMaskLen(),
                            sensitivityEncrypt.suffixNoMaskLen(), sensitivityEncrypt.symbol());
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(null);
    }
}

使用教程

    /**
     * 学生姓名
     */
    @TableField("STUDENT_NAME")
    @SensitivityEncrypt(type = SensitivityTypeEnum.NAME)
    private String studentName;

来源