📞 文章简介：一个注解搞定身份证号、手机号等敏感数据脱敏处理
💡 创作目的：公司中CRM的第一版快封版了，基本功能都落实了。接下来就是预防等保了，我负责的是核心业务客户模块这里自然有很多数据要做脱敏。最开始想着service层进行数据处理，但是又繁琐又不够优雅。于是想到了使用注解搭配序列化做一个自动的脱敏处理！！！
📝 每期一言：只要勤奋学习，每天进步一点点，总有一天会成为飞过沧海横过大洋的海鸥。
☀️ 今日天气：2023-01-16 晴前两天的风吹在脸上都疼今天的阳光照在脸上很舒服 🧐

点在哪里跳哪里

🪜第一格(简述)
数据脱敏
脱敏效果展示

🪜第二格(设计)
方案一(数据库处理)
方案二(序列化处理)

🪜第三格(编码)
脱敏工具类：SensitivityUtil
脱敏类型枚举:SensitivityTypeEnum
脱敏注解: SensitivityEncrypt
自定义脱敏序列化:SensitivitySerializer

🪜第四格(测试)
实体类接口测试

🪜第五格(总结)

🪜第一格(简述)

数据脱敏

简单来说就是对一些敏感的数据进行隐藏，
比如说身份证号、手机号、姓名、邮箱、地址等这些不希望被工作人员或者有一些科技手段的人进行爬取利用。

脱敏效果展示

数据脱敏前

数据脱敏后

🪜第二格(设计)

因为等保现在对这个要求很严格,所以这些数据防护是必要的。
最开始想到的是在service层拿到数据后进行数据整理。
但是感觉冗余代码很多,就想了想别的办法。

方案一(数据库处理)

在进行数据库存储的时候将这些敏感数据进行脱敏以后加入到数据库中(在执行添加操作的时候，数据库insert的时候)
- 因为后期会有总表的存在，老板要看这些数据，还会有签署合同、生成在线合同的步骤，还是需要一些敏感数据的。所以这个方法不可取 ❌

方案二(序列化处理)

返回数据的时候每个实体类都实现了序列化，所以可以在返回数据的时候在序列化的时候进行脱敏 ✅

🪜第三格(编码)

设计已经完成，采用序列化+注解的方式进行数据脱敏。
下面我们一起Let's coding

脱敏工具类：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


import lombok.Getter;
 
/**
 * 脱敏类型枚举
 */
@Getter
public enum SensitivityTypeEnum {

  /**
   * 姓名
   */
  NAME,
 
  /**
   * 身份证号
   */
  ID_CARD,

  /**
   * 邮箱
   */
  EMAIL,
 
  /**
   * 手机号
   */
  PHONE,

  /**
   *  自定义（此项需设置脱敏的前置后置长度）
   */
  CUSTOMER,
}

这个枚举主要用于在使用注解的时候指定是什么类型的脱敏方式，后续的序列化中也会根据使用的枚举进行对应的脱敏操作

脱敏注解: SensitivityEncrypt

 
/**
 * 自定义数据脱敏注解
 */
// 作用在字段上
@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 "*";
}

注意:
这里用了jackson 要引入对应依赖

         <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.6.1</version>
        </dependency>

@JsonSerialize 注解使用自定义的序列化进行数据处理
参数的话需要指定基础脱敏的数据类型、脱敏数据保留的位置及自定义脱敏符号

自定义脱敏序列化: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);
  }
}

这是最核心的序列化实现流程，继承了JsonSerializer并限制类型为String，固定参数类型
通过重写createContextual用来读取SensitivityEncrypt注解的值，打造上下文环境所需
重写的serialize的方法是整个数据脱敏的流程，通过判断什么类型从而对数据进行什么样的脱敏效果

🪜第四格(测试)

实体类接口测试

在对应的实体类中添加注解，调用接口进行测试

public class SysUser extends BaseEntity
{
    private static final long serialVersionUID = 1L;
    /** 用户账号 */
    private String userName;

    /** 用户昵称 */
    private String nickName;

    /** 用户邮箱 */
    @SensitivityEncrypt(type = SensitivityTypeEnum.EMAIL)
    private String email;

    /** 手机号码 */
    @SensitivityEncrypt(type = SensitivityTypeEnum.PHONE)
    private String phonenumber;

    /** 用户性别 */
    private String sex;

    /** 用户头像 */
    private String avatar;
}