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

分享仅供学习使用，不做其他用途！

Tip（显示导航栏）：

 

 数据脱敏：把系统里的一些敏感数据进行加密处理后再返回，达到保护隐私作用，实现效果图如下：
 

用 jackson 的序列化来实现

(class PrivacySerializer extends JsonSerializer<String> implements ContextualSerializer)

快速导航

1. 创建隐私数据类型枚举：PrivacyTypeEnum 
2. 创建自定义隐私注解：PrivacyEncrypt
3. 创建自定义序列化器：PrivacySerializer
4. 隐私数据隐藏工具类：PrivacyUtil
5. 注解使用 @PrivacyEncrypt

---

1. PrivacyTypeEnum

   
   public enum PrivacyTypeEnum {
       /** 自定义（此项需设置脱敏的范围）*/
       CUSTOMER,
   
       /** 姓名 */
       NAME,
   
       /** 身份证号 */
       ID_CARD,
   
       /** 手机号 */
       PHONE,
   
       /** 邮箱 */
       EMAIL;
   
       PrivacyTypeEnum() {
       }
   }

2. 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 "*";
   }

3. PrivacySerializer

   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.zk.common.core.domain.enumerate.PrivacyTypeEnum;
   import com.zk.common.core.utils.PrivacyUtil;
   import java.io.IOException;
   import java.util.Objects;
   import org.apache.commons.lang3.StringUtils;
   
   public class PrivacySerializer extends JsonSerializer<String> implements ContextualSerializer {
   
       // 脱敏类型
       private PrivacyTypeEnum privacyTypeEnum;
       // 前几位不脱敏
       private Integer prefixNoMaskLen;
       // 最后几位不脱敏
       private Integer suffixNoMaskLen;
       // 用什么打码
       private String symbol;
   
       public PrivacySerializer() {
       }
   
       public PrivacySerializer(PrivacyTypeEnum privacyTypeEnum, Integer prefixNoMaskLen, Integer suffixNoMaskLen, String symbol) {
           this.privacyTypeEnum = privacyTypeEnum;
           this.prefixNoMaskLen = prefixNoMaskLen;
           this.suffixNoMaskLen = suffixNoMaskLen;
           this.symbol = 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);
       }
   }

4. PrivacyUtil

   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();
       }
   
       public static void main(String[] args) {
           System.out.println(hideChineseName("张三三"));
       }
   }

5. @PrivacyEncry

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

   public class People {
   
       private Integer id;
   
       private String name;
   
       private Integer sex;
   
       private Integer age;
   
       @PrivacyEncrypt(type = PrivacyTypeEnum.PHONE) // 隐藏手机号
       private String phone;
   
       @PrivacyEncrypt(type = PrivacyTypeEnum.EMAIL) // 隐藏邮箱
       private String email;
   
       private String sign;
   }