1.自定义脱敏注解

标注在实体类 具体 需要脱敏 字段上
其中用到Jackson的两个注解, 并标明使用我们自定义脱敏策略即序列化后脱敏

  1. import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
  2. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * 对象脱敏注解
  11.  *
  12.  * @version v1.0
  13.  **/
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Target(ElementType.FIELD)
  16. @JacksonAnnotationsInside
  17. @JsonSerialize(using = SensitiveSerialize.class)
  18. public @interface Sensitive {
  20.     /**
  21.      * 脱敏数据类型, 非Customer时, 将忽略 refixNoMaskLen 和 suffixNoMaskLen 和 maskStr
  22.      */
  23.     SensitiveTypeEnum type() default SensitiveTypeEnum.CUSTOMER;
  25.     /**
  26.      * 前置不需要打码的长度
  27.      */
  28.     int prefixNoMaskLen() default 0;
  30.     /**
  31.      * 后置不需要打码的长度
  32.      */
  33.     int suffixNoMaskLen() default 0;
  35.     /**
  36.      * 用什么打码
  37.      */
  38.     String maskStr() default "*";
  40. }

注解按生命周期来划分可分为3类：
1、RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；
2、RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期；
3、RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在；

2.自定义脱敏逻辑

借助Jackson类和接口实现序列化才脱敏

  1. import com.fasterxml.jackson.core.JsonGenerator;
  2. import com.fasterxml.jackson.databind.BeanProperty;
  3. import com.fasterxml.jackson.databind.JsonMappingException;
  4. import com.fasterxml.jackson.databind.JsonSerializer;
  5. import com.fasterxml.jackson.databind.SerializerProvider;
  6. import com.fasterxml.jackson.databind.ser.ContextualSerializer;
  7. import com.pofly.air.common.core.util.DesensitizedUtils;
  8. import lombok.AllArgsConstructor;
  9. import lombok.NoArgsConstructor;
  11. import java.io.IOException;
  12. import java.util.Objects;
  14. /**
  15.  * <p>
  16.  * 脱敏序列化
  17.  */
  18. @NoArgsConstructor
  19. @AllArgsConstructor
  20. public class SensitiveSerialize extends JsonSerializer<String> implements ContextualSerializer {
  22.     private SensitiveTypeEnum type;
  24.     private Integer prefixNoMaskLen;
  26.     private Integer suffixNoMaskLen;
  28.     private String maskStr;
  30.     @Override
  31.     public void serialize(final String origin, final JsonGenerator jsonGenerator,
  32.             final SerializerProvider serializerProvider) throws IOException {
  33.         switch (type) {
  34.         case CHINESE_NAME:
  35.             jsonGenerator.writeString(DesensitizedUtils.chineseName(origin));
  36.             break;
  37.         case ID_CARD:
  38.             jsonGenerator.writeString(DesensitizedUtils.idCardNum(origin));
  39.             break;
  40.         case FIXED_PHONE:
  41.             jsonGenerator.writeString(DesensitizedUtils.fixedPhone(origin));
  42.             break;
  43.         case MOBILE_PHONE:
  44.             jsonGenerator.writeString(DesensitizedUtils.mobilePhone(origin));
  45.             break;
  46.         case ADDRESS:
  47.             jsonGenerator.writeString(DesensitizedUtils.address(origin));
  48.             break;
  49.         case EMAIL:
  50.             jsonGenerator.writeString(DesensitizedUtils.email(origin));
  51.             break;
  52.         case BANK_CARD:
  53.             jsonGenerator.writeString(DesensitizedUtils.bankCard(origin));
  54.             break;
  55.         case PASSWORD:
  56.             jsonGenerator.writeString(DesensitizedUtils.password(origin));
  57.             break;
  58.         case KEY:
  59.             jsonGenerator.writeString(DesensitizedUtils.key(origin));
  60.             break;
  61.         case CUSTOMER:
  62.             jsonGenerator.writeString(DesensitizedUtils.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, maskStr));
  63.             break;
  64.         default:
  65.             throw new IllegalArgumentException("Unknow sensitive type enum " + type);
  66.         }
  67.     }
  69.     @Override
  70.     public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider,
  71.             final BeanProperty beanProperty) throws JsonMappingException {
  72.         if (beanProperty != null) {
  73.             if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
  74.                 Sensitive sensitive = beanProperty.getAnnotation(Sensitive.class);
  75.                 if (sensitive == null) {
  76.                     sensitive = beanProperty.getContextAnnotation(Sensitive.class);
  77.                 }
  78.                 if (sensitive != null) {
  79.                     return new SensitiveSerialize(sensitive.type(), sensitive.prefixNoMaskLen(),
  80.                             sensitive.suffixNoMaskLen(), sensitive.maskStr());
  81.                 }
  82.             }
  83.             return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
  84.         }
  85.         return serializerProvider.findNullValueSerializer(null);
  86.     }
  88. }

3.脱敏枚举类

  1. /**
  2.  * 敏感信息枚举类
  3.  *
  4.  * @version v1.0
  5.  **/
  6. public enum SensitiveTypeEnum {
  8.     /**
  9.      * 自定义
  10.      */
  11.     CUSTOMER,
  12.     /**
  13.      * 用户名, 刘*华, 徐*
  14.      */
  15.     CHINESE_NAME,
  16.     /**
  17.      * 身份证号, 110110********1234
  18.      */
  19.     ID_CARD,
  20.     /**
  21.      * 座机号, ****1234
  22.      */
  23.     FIXED_PHONE,
  24.     /**
  25.      * 手机号, 176****1234
  26.      */
  27.     MOBILE_PHONE,
  28.     /**
  29.      * 地址, 北京********
  30.      */
  31.     ADDRESS,
  32.     /**
  33.      * 电子邮件, s*****o@xx.com
  34.      */
  35.     EMAIL,
  36.     /**
  37.      * 银行卡, 622202************1234
  38.      */
  39.     BANK_CARD,
  40.     /**
  41.      * 密码, 永远是 ******, 与长度无关
  42.      */
  43.     PASSWORD,
  44.     /**
  45.      * 密钥, 【密钥】密钥除了最后三位其他都是***, 与长度无关
  46.      */
  47.     KEY
  49. }

4.脱敏工具类

  1. import cn.hutool.core.util.StrUtil;
  3. /**
  4.  * 脱敏工具类
  5.  *
  6.  * @version v1.0
  7.  **/
  8. public class DesensitizedUtils {
  10.     /**
  11.      * 对字符串进行脱敏操作
  12.      * @param origin 原始字符串
  13.      * @param prefixNoMaskLen 左侧需要保留几位明文字段
  14.      * @param suffixNoMaskLen 右侧需要保留几位明文字段
  15.      * @param maskStr 用于遮罩的字符串, 如'*'
  16.      * @return 脱敏后结果
  17.      */
  18.     public static String desValue(String origin, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
  19.         if (origin == null) {
  20.             return null;
  21.         }
  23.         StringBuilder sb = new StringBuilder();
  24.         for (int i = 0, n = origin.length(); i < n; i++) {
  25.             if (i < prefixNoMaskLen) {
  26.                 sb.append(origin.charAt(i));
  27.                 continue;
  28.             }
  29.             if (i > (n - suffixNoMaskLen - 1)) {
  30.                 sb.append(origin.charAt(i));
  31.                 continue;
  32.             }
  33.             sb.append(maskStr);
  34.         }
  35.         return sb.toString();
  36.     }
  38.     /**
  39.      * 【中文姓名】只显示最后一个汉字，其他隐藏为星号，比如：**梦
  40.      * @param fullName 姓名
  41.      * @return 结果
  42.      */
  43.     public static String chineseName(String fullName) {
  44.         if (fullName == null) {
  45.             return null;
  46.         }
  47.         return desValue(fullName, 0, 1, "*");
  48.     }
  50.     /**
  51.      * 【身份证号】显示前六位, 四位，其他隐藏。共计18位或者15位，比如：340304*******1234
  52.      * @param id 身份证号码
  53.      * @return 结果
  54.      */
  55.     public static String idCardNum(String id) {
  56.         return desValue(id, 6, 4, "*");
  57.     }
  59.     /**
  60.      * 【固定电话】后四位，其他隐藏，比如 ****1234
  61.      * @param num 固定电话
  62.      * @return 结果
  63.      */
  64.     public static String fixedPhone(String num) {
  65.         return desValue(num, 0, 4, "*");
  66.     }
  68.     /**
  69.      * 【手机号码】前三位，后四位，其他隐藏，比如135****6810
  70.      * @param num 手机号码
  71.      * @return 结果
  72.      */
  73.     public static String mobilePhone(String num) {
  74.         return desValue(num, 3, 4, "*");
  75.     }
  77.     /**
  78.      * 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
  79.      * @param address 地址
  80.      * @return 结果
  81.      */
  82.     public static String address(String address) {
  83.         return desValue(address, 6, 0, "*");
  84.     }
  86.     /**
  87.      * 【电子邮箱 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
  88.      * @param email 电子邮箱
  89.      * @return 结果
  90.      */
  91.     public static String email(String email) {
  92.         if (email == null) {
  93.             return null;
  94.         }
  95.         int index = StrUtil.indexOf(email, '@');
  96.         if (index <= 1) {
  97.             return email;
  98.         }
  99.         String preEmail = desValue(email.substring(0, index), 1, 0, "*");
  100.         return preEmail + email.substring(index);
  102.     }
  104.     /**
  105.      * 【银行卡号】前六位，后四位，其他用星号隐藏每位1个星号，比如：622260**********1234
  106.      * @param cardNum 银行卡号
  107.      * @return 结果
  108.      */
  109.     public static String bankCard(String cardNum) {
  110.         return desValue(cardNum, 6, 4, "*");
  111.     }
  113.     /**
  114.      * 【密码】密码的全部字符都用*代替，比如：******
  115.      * @param password 密码
  116.      * @return 结果
  117.      */
  118.     public static String password(String password) {
  119.         if (password == null) {
  120.             return null;
  121.         }
  122.         return "******";
  123.     }
  125.     /**
  126.      * 【密钥】密钥除了最后三位，全部都用*代替，比如：***xdS 脱敏后长度为6，如果明文长度不足三位，则按实际长度显示，剩余位置补*
  127.      * @param key 密钥
  128.      * @return 结果
  129.      */
  130.     public static String key(String key) {
  131.         if (key == null) {
  132.             return null;
  133.         }
  134.         int viewLength = 6;
  135.         StringBuilder tmpKey = new StringBuilder(desValue(key, 0, 3, "*"));
  136.         if (tmpKey.length() > viewLength) {
  137.             return tmpKey.substring(tmpKey.length() - viewLength);
  138.         }
  139.         else if (tmpKey.length() < viewLength) {
  140.             int buffLength = viewLength - tmpKey.length();
  141.             for (int i = 0; i < buffLength; i++) {
  142.                 tmpKey.insert(0, "*");
  143.             }
  144.             return tmpKey.toString();
  145.         }
  146.         else {
  147.             return tmpKey.toString();
  148.         }
  149.     }
  151. }