• Java实现数据脱敏

    前言

      在开发系统过程中，经常会接触到大量的数据信息，这些数据信息可能包含身份证号、手机号、姓名、卡号等各种敏感信息。而有些用户需求是不允许，这些敏感信息数据为了保护用户个人信息的安全。对这些数据需要进行特殊处理。

    一、什么是数据脱敏？

    数据脱敏又称数据去隐私化或数据变形，是在给定的规则、策略下对敏感数据进行变换、修改的技术机制，能够在很大程度上解决敏感数据在非可信环境中使用的问题。根据数据保护规范和脱敏策略．对业务数据中的敏感信息实施自动变形．实现对敏感信息的隐藏。

    二、实现

    适合单个字段

    1、枚举需要脱敏的字段类型

    1.  
    2. /**
    3.  * 需要脱敏的字段类型
    4.  *
    5.  * @author xh
    6.  * @Date 2022/7/20
    7.  */
    8. public enum SensitiveTypeEnum {
    9.     /**
    10.      * 中文名
    11.      */
    12.     CHINESE_NAME,
    13.     /**
    14.      * 身份证号
    15.      */
    16.     ID_CARD,
    17.     /**
    18.      * 座机号
    19.      */
    20.     FIXED_PHONE,
    21.     /**
    22.      * 手机号
    23.      */
    24.     MOBILE_PHONE,
    25.     /**
    26.      * 地址
    27.      */
    28.     ADDRESS,
    29.     /**
    30.      * 电子邮件
    31.      */
    32.     EMAIL,
    33.     /**
    34.      * 银行卡
    35.      */
    36.     BANK_CARD,
    37.     /**
    38.      * 虚拟账号
    39.      */
    40.     ACCOUNT,
    41.     /**
    42.      * 密码
    43.      */
    44.     PASSWORD;
    45. }
    46.

    2、创建注解，标识需要脱敏的字段

    1. import com.artboy.project.common.enums.SensitiveTypeEnum;
    2.  
    3. import java.lang.annotation.*;
    4.  
    5. /**
    6.  * @author xh
    7.  * @Date 2022/7/20
    8.  */
    9. // 指定在注解使用的位置
    10. @Target({ElementType.FIELD, ElementType.METHOD})
    11. // 指定注解保存的范围
    12. @Retention(RetentionPolicy.RUNTIME)
    13. // 可以被子类继承
    14. @Inherited
    15. // 设置为文档说明
    16. @Documented
    17. public @interface Desensitized {
    18.     /*脱敏类型(规则)*/
    19.     SensitiveTypeEnum type();
    20.  
    21.     /*判断注解是否生效的方法*/
    22.     String isEffictiveMethod() default "";
    23. }

    创建Object工具类

    用于复制对象和对对象的其他操作,注意使用fastjson实现深拷贝对于复杂的对象会出现栈溢出,这里修改为了Gson

    1. package com.artboy.project.common.utils;
    2.  
    3. import com.google.gson.Gson;
    4. import org.apache.commons.lang3.StringUtils;
    5.  
    6. import java.io.*;
    7. import java.lang.reflect.Array;
    8. import java.lang.reflect.Field;
    9. import java.lang.reflect.InvocationTargetException;
    10. import java.lang.reflect.Modifier;
    11. import java.util.*;
    12.  
    13. /**
    14.  * @author xh
    15.  * @Date 2022/7/26
    16.  */
    17. public class DesensitizedObjectUtils {
    18.     /**
    19.      * 用序列化-反序列化方式实现深克隆
    20.      * 缺点：1、被拷贝的对象必须要实现序列化
    21.      *
    22.      * @param obj
    23.      * @return
    24.      */
    25.     @SuppressWarnings("unchecked")
    26.     public static <T> T deepCloneObject(T obj) {
    27.         T t = (T) new Object();
    28.         try {
    29.             ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
    30.             ObjectOutputStream out = new ObjectOutputStream(byteOut);
    31.             out.writeObject(obj);
    32.             out.close();
    33.             ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
    34.             ObjectInputStream in = new ObjectInputStream(byteIn);
    35.             t = (T) in.readObject();
    36.             in.close();
    37.         } catch (IOException e) {
    38.             e.printStackTrace();
    39.         } catch (ClassNotFoundException e) {
    40.             e.printStackTrace();
    41.         }
    42.         return t;
    43.     }
    44.  
    45.     /**
    46.      * 用序列化-反序列化的方式实现深克隆
    47.      * 这里使用GSON来取代FAST-JSON
    48.      * 缺点：1、当实体中存在接口类型的参数，并且这个接口指向的实例为枚举类型时，会报错"com.alibaba.fastjson.JSONException: syntax error, expect {, actual string, pos 171, fieldName iLimitKey"
    49.      *
    50.      * @param objSource
    51.      * @return
    52.      */
    53.     public static Object deepCloneByFastJson(Object objSource) {
    54. //        String tempJson = JSON.toJSONString(objSource);
    55. //        Object clone = JSON.parseObject(tempJson, objSource.getClass());
    56.         Gson gson = new Gson();
    57.         String tempJson = gson.toJson(objSource);
    58.         Object clone = gson.fromJson(tempJson, objSource.getClass());
    59.         return clone;
    60.     }
    61.  
    62.     /**
    63.      * 深度克隆对象
    64.      *
    65.      * @throws IllegalAccessException
    66.      * @throws InstantiationException
    67.      */
    68.     public static Object deepClone(Object objSource) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    69.         if (null == objSource) return null;
    70.         //是否jdk类型、基础类型、枚举类型
    71.         if (isJDKType(objSource.getClass())
    72.                 || objSource.getClass().isPrimitive()
    73.                 || objSource instanceof Enum<?>) {
    74.             if ("java.lang.String".equals(objSource.getClass().getName())) {//目前只支持String类型深复制
    75.                 return new String((String) objSource);
    76.             } else {
    77.                 return objSource;
    78.             }
    79.         }
    80.         // 获取源对象类型
    81.         Class<?> clazz = objSource.getClass();
    82.         Object objDes = clazz.newInstance();
    83.         // 获得源对象所有属性
    84.         Field[] fields = getAllFields(objSource);
    85.         // 循环遍历字段，获取字段对应的属性值
    86.         for (Field field : fields) {
    87.             field.setAccessible(true);
    88.             if (null == field) continue;
    89.             Object value = field.get(objSource);
    90.             if (null == value) continue;
    91.             Class<?> type = value.getClass();
    92.             if (isStaticFinal(field)) {
    93.                 continue;
    94.             }
    95.             try {
    96.  
    97.                 //遍历集合属性
    98.                 if (type.isArray()) {//对数组类型的字段进行递归过滤
    99.                     int len = Array.getLength(value);
    100.                     if (len < 1) continue;
    101.                     Class<?> c = value.getClass().getComponentType();
    102.                     Array newArray = (Array) Array.newInstance(c, len);
    103.                     for (int i = 0; i < len; i++) {
    104.                         Object arrayObject = Array.get(value, i);
    105.                         Array.set(newArray, i, deepClone(arrayObject));
    106.                     }
    107.                 } else if (value instanceof Collection<?>) {
    108.                     Collection newCollection = (Collection) value.getClass().newInstance();
    109.                     Collection<?> c = (Collection<?>) value;
    110.                     Iterator<?> it = c.iterator();
    111.                     while (it.hasNext()) {
    112.                         Object collectionObj = it.next();
    113.                         newCollection.add(deepClone(collectionObj));
    114.                     }
    115.                     field.set(objDes, newCollection);
    116.                     continue;
    117.                 } else if (value instanceof Map<?, ?>) {
    118.                     Map newMap = (Map) value.getClass().newInstance();
    119.                     Map<?, ?> m = (Map<?, ?>) value;
    120.                     Set<?> set = m.entrySet();
    121.                     for (Object o : set) {
    122.                         Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
    123.                         Object mapVal = entry.getValue();
    124.                         newMap.put(entry.getKey(), deepClone(mapVal));
    125.                     }
    126.                     field.set(objDes, newMap);
    127.                     continue;
    128.                 }
    129.  
    130.                 //是否jdk类型或基础类型
    131.                 if (isJDKType(field.get(objSource).getClass())
    132.                         || field.getClass().isPrimitive()
    133.                         || isStaticType(field)
    134.                         || value instanceof Enum<?>) {
    135.                     if ("java.lang.String".equals(value.getClass().getName())) {//目前只支持String类型深复制
    136.                         field.set(objDes, new String((String) value));
    137.                     } else {
    138.                         field.set(objDes, field.get(objSource));
    139.                     }
    140.                     continue;
    141.                 }
    142.  
    143.                 //是否枚举
    144.                 if (value.getClass().isEnum()) {
    145.                     field.set(objDes, field.get(objSource));
    146.                     continue;
    147.                 }
    148.  
    149.                 //是否自定义类
    150.                 if (isUserDefinedType(value.getClass())) {
    151.                     field.set(objDes, deepClone(value));
    152.                     continue;
    153.                 }
    154.  
    155.             } catch (Exception e) {
    156.                 e.printStackTrace();
    157.             }
    158.         }
    159.         return objDes;
    160.     }
    161.  
    162.  
    163.     /**
    164.      * 是否静态变量
    165.      *
    166.      * @param field
    167.      * @return
    168.      */
    169.     private static boolean isStaticType(Field field) {
    170.         return field.getModifiers() == 8 ? true : false;
    171.     }
    172.  
    173.     private static boolean isStaticFinal(Field field) {
    174.         return Modifier.isFinal(field.getModifiers()) && Modifier.isStatic(field.getModifiers());
    175.     }
    176.  
    177.     /**
    178.      * 是否jdk类型变量
    179.      *
    180.      * @param clazz
    181.      * @return
    182.      * @throws IllegalAccessException
    183.      */
    184.     private static boolean isJDKType(Class clazz) throws IllegalAccessException {
    185.         //Class clazz = field.get(objSource).getClass();
    186.         return org.apache.commons.lang3.StringUtils.startsWith(clazz.getPackage().getName(), "javax.")
    187.                 || org.apache.commons.lang3.StringUtils.startsWith(clazz.getPackage().getName(), "java.")
    188.                 || org.apache.commons.lang3.StringUtils.startsWith(clazz.getName(), "javax.")
    189.                 || org.apache.commons.lang3.StringUtils.startsWith(clazz.getName(), "java.");
    190.     }
    191.  
    192.     /**
    193.      * 是否用户自定义类型
    194.      *
    195.      * @param clazz
    196.      * @return
    197.      */
    198.     private static boolean isUserDefinedType(Class<?> clazz) {
    199.         return
    200.                 clazz.getPackage() != null
    201.                         && !org.apache.commons.lang3.StringUtils.startsWith(clazz.getPackage().getName(), "javax.")
    202.                         && !org.apache.commons.lang3.StringUtils.startsWith(clazz.getPackage().getName(), "java.")
    203.                         && !org.apache.commons.lang3.StringUtils.startsWith(clazz.getName(), "javax.")
    204.                         && !StringUtils.startsWith(clazz.getName(), "java.");
    205.     }
    206.  
    207.     /**
    208.      * 获取包括父类所有的属性
    209.      *
    210.      * @param objSource
    211.      * @return
    212.      */
    213.     public static Field[] getAllFields(Object objSource) {
    214.         /*获得当前类的所有属性(private、protected、public)*/
    215.         List<Field> fieldList = new ArrayList<Field>();
    216.         Class tempClass = objSource.getClass();
    217.         while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {//当父类为null的时候说明到达了最上层的父类(Object类).
    218.             fieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
    219.             tempClass = tempClass.getSuperclass(); //得到父类,然后赋给自己
    220.         }
    221.         Field[] fields = new Field[fieldList.size()];
    222.         fieldList.toArray(fields);
    223.         return fields;
    224.     }
    225.  
    226.     /**
    227.      * 深度克隆对象
    228.      *
    229.      * @throws IllegalAccessException
    230.      * @throws InstantiationException
    231.      */
    232.     @Deprecated
    233.     public static Object copy(Object objSource) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    234.  
    235.         if (null == objSource) return null;
    236.         // 获取源对象类型
    237.         Class<?> clazz = objSource.getClass();
    238.         Object objDes = clazz.newInstance();
    239.         // 获得源对象所有属性
    240.         Field[] fields = getAllFields(objSource);
    241.         // 循环遍历字段，获取字段对应的属性值
    242.         for (Field field : fields) {
    243.             field.setAccessible(true);
    244.             // 如果该字段是 static + final 修饰
    245.             if (field.getModifiers() >= 24) {
    246.                 continue;
    247.             }
    248.             try {
    249.                 // 设置字段可见，即可用get方法获取属性值。
    250.                 field.set(objDes, field.get(objSource));
    251.             } catch (Exception e) {
    252.                 e.printStackTrace();
    253.             }
    254.         }
    255.         return objDes;
    256.     }
    257. }
    258.

    创建脱敏工具类

    1. package com.artboy.project.common.utils;
    2.  
    3. import com.artboy.project.common.annotation.Desensitized;
    4. import com.google.gson.Gson;
    5. import org.apache.commons.lang3.StringUtils;
    6.  
    7. import java.lang.reflect.Array;
    8. import java.lang.reflect.Field;
    9. import java.lang.reflect.InvocationTargetException;
    10. import java.lang.reflect.Method;
    11. import java.util.*;
    12.  
    13. /**
    14.  * @author xh
    15.  * @Date 2022/7/26
    16.  */
    17. public class DesensitizedUtils {
    18.     /**
    19.      * 获取脱敏json串(递归引用会导致java.lang.StackOverflowError)
    20.      *
    21.      * @param javaBean
    22.      * @return
    23.      */
    24.     public static String getJson(Object javaBean) {
    25.         String json = null;
    26.         if (null != javaBean) {
    27.             try {
    28.                 if (javaBean.getClass().isInterface()) return json;
    29.                 /* 克隆出一个实体进行字段修改，避免修改原实体 */
    30.                 //Object clone =DesensitizedObjectUtils.deepCloneObject(javaBean);
    31.                 //Object clone =DesensitizedObjectUtils.deepCloneByFastJson(javaBean);
    32.                 Object clone = DesensitizedObjectUtils.deepClone(javaBean);
    33.  
    34.                 /* 定义一个计数器，用于避免重复循环自定义对象类型的字段 */
    35.                 Set<Integer> referenceCounter = new HashSet<Integer>();
    36.  
    37.                 /* 对克隆实体进行脱敏操作 */
    38.                 DesensitizedUtils.replace(DesensitizedObjectUtils.getAllFields(clone), clone, referenceCounter);
    39.  
    40.                 /* 利用fastjson对脱敏后的克隆对象进行序列化 */
    41. //                json = JSON.toJSONString(clone, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullListAsEmpty);
    42.                 json = new Gson().toJson(clone);
    43.  
    44.                 /* 清空计数器 */
    45.                 referenceCounter.clear();
    46.                 referenceCounter = null;
    47.             } catch (Throwable e) {
    48.                 e.printStackTrace();
    49.             }
    50.         }
    51.         return json;
    52.     }
    53.  
    54.     public static <T> T getObj(T javaBean) {
    55.         T clone = null;
    56.         if (null != javaBean) {
    57.             try {
    58.                 if (javaBean.getClass().isInterface()) return null;
    59.                 /* 克隆出一个实体进行字段修改，避免修改原实体 */
    60.                 //Object clone =DesensitizedObjectUtils.deepCloneObject(javaBean);
    61.                 //Object clone =DesensitizedObjectUtils.deepCloneByFastJson(javaBean);
    62.                 clone = (T) DesensitizedObjectUtils.deepClone(javaBean);
    63.  
    64.                 /* 定义一个计数器，用于避免重复循环自定义对象类型的字段 */
    65.                 Set<Integer> referenceCounter = new HashSet<Integer>();
    66.  
    67.                 /* 对克隆实体进行脱敏操作 */
    68.                 DesensitizedUtils.replace(DesensitizedObjectUtils.getAllFields(clone), clone, referenceCounter);
    69.  
    70.                 /* 清空计数器 */
    71.                 referenceCounter.clear();
    72.                 referenceCounter = null;
    73.             } catch (Throwable e) {
    74.                 e.printStackTrace();
    75.             }
    76.         }
    77.         return clone;
    78.     }
    79.  
    80.     /**
    81.      * 对需要脱敏的字段进行转化
    82.      *
    83.      * @param fields
    84.      * @param javaBean
    85.      * @param referenceCounter
    86.      * @throws IllegalArgumentException
    87.      * @throws IllegalAccessException
    88.      */
    89.     private static void replace(Field[] fields, Object javaBean, Set<Integer> referenceCounter) throws IllegalArgumentException, IllegalAccessException {
    90.         if (null != fields && fields.length > 0) {
    91.             for (Field field : fields) {
    92.                 field.setAccessible(true);
    93.                 if (null != field && null != javaBean) {
    94.                     Object value = field.get(javaBean);
    95.                     if (null != value) {
    96.                         Class<?> type = value.getClass();
    97.                         //处理子属性，包括集合中的
    98.                         if (type.isArray()) {//对数组类型的字段进行递归过滤
    99.                             int len = Array.getLength(value);
    100.                             for (int i = 0; i < len; i++) {
    101.                                 Object arrayObject = Array.get(value, i);
    102.                                 if (isNotGeneralType(arrayObject.getClass(), arrayObject, referenceCounter)) {
    103.                                     replace(DesensitizedObjectUtils.getAllFields(arrayObject), arrayObject, referenceCounter);
    104.                                 }
    105.                             }
    106.                         } else if (value instanceof Collection<?>) {//对集合类型的字段进行递归过滤
    107.                             Collection<?> c = (Collection<?>) value;
    108.                             Iterator<?> it = c.iterator();
    109.                             while (it.hasNext()) {// TODO: 待优化
    110.                                 Object collectionObj = it.next();
    111.                                 if (isNotGeneralType(collectionObj.getClass(), collectionObj, referenceCounter)) {
    112.                                     replace(DesensitizedObjectUtils.getAllFields(collectionObj), collectionObj, referenceCounter);
    113.                                 }
    114.                             }
    115.                         } else if (value instanceof Map<?, ?>) {//对Map类型的字段进行递归过滤
    116.                             Map<?, ?> m = (Map<?, ?>) value;
    117.                             Set<?> set = m.entrySet();
    118.                             for (Object o : set) {
    119.                                 Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
    120.                                 Object mapVal = entry.getValue();
    121.                                 if (isNotGeneralType(mapVal.getClass(), mapVal, referenceCounter)) {
    122.                                     replace(DesensitizedObjectUtils.getAllFields(mapVal), mapVal, referenceCounter);
    123.                                 }
    124.                             }
    125.                         } else if (value instanceof Enum<?>) {
    126.                             continue;
    127.                         }
    128.  
    129.                         /*除基础类型、jdk类型的字段之外，对其他类型的字段进行递归过滤*/
    130.                         else {
    131.                             if (!type.isPrimitive()
    132.                                     && type.getPackage() != null
    133.                                     && !StringUtils.startsWith(type.getPackage().getName(), "javax.")
    134.                                     && !StringUtils.startsWith(type.getPackage().getName(), "java.")
    135.                                     && !StringUtils.startsWith(field.getType().getName(), "javax.")
    136.                                     && !StringUtils.startsWith(field.getName(), "java.")
    137.                                     && referenceCounter.add(value.hashCode())) {
    138.                                 replace(DesensitizedObjectUtils.getAllFields(value), value, referenceCounter);
    139.                             }
    140.                         }
    141.                     }
    142.  
    143.                     //脱敏操作
    144.                     setNewValueForField(javaBean, field, value);
    145.  
    146.                 }
    147.             }
    148.         }
    149.     }
    150.  
    151.     /**
    152.      * 排除基础类型、jdk类型、枚举类型的字段
    153.      *
    154.      * @param clazz
    155.      * @param value
    156.      * @param referenceCounter
    157.      * @return
    158.      */
    159.     private static boolean isNotGeneralType(Class<?> clazz, Object value, Set<Integer> referenceCounter) {
    160.         return !clazz.isPrimitive()
    161.                 && clazz.getPackage() != null
    162.                 && !clazz.isEnum()
    163.                 && !StringUtils.startsWith(clazz.getPackage().getName(), "javax.")
    164.                 && !StringUtils.startsWith(clazz.getPackage().getName(), "java.")
    165.                 && !StringUtils.startsWith(clazz.getName(), "javax.")
    166.                 && !StringUtils.startsWith(clazz.getName(), "java.")
    167.                 && referenceCounter.add(value.hashCode());
    168.     }
    169.  
    170.     /**
    171.      * 脱敏操作（按照规则转化需要脱敏的字段并设置新值）
    172.      * 目前只支持String类型的字段，如需要其他类型如BigDecimal、Date等类型，可以添加
    173.      *
    174.      * @param javaBean
    175.      * @param field
    176.      * @param value
    177.      * @throws IllegalAccessException
    178.      */
    179.     public static void setNewValueForField(Object javaBean, Field field, Object value) throws IllegalAccessException {
    180.         //处理自身的属性
    181.         Desensitized annotation = field.getAnnotation(Desensitized.class);
    182.         if (field.getType().equals(String.class) && null != annotation && executeIsEffictiveMethod(javaBean, annotation)) {
    183.             String valueStr = (String) value;
    184.             if (StringUtils.isNotBlank(valueStr)) {
    185.                 switch (annotation.type()) {
    186.                     case CHINESE_NAME: {
    187.                         field.set(javaBean, DesensitizedUtils.chineseName(valueStr));
    188.                         break;
    189.                     }
    190.                     case ID_CARD: {
    191.                         field.set(javaBean, DesensitizedUtils.idCardNum(valueStr));
    192.                         break;
    193.                     }
    194.                     case FIXED_PHONE: {
    195.                         field.set(javaBean, DesensitizedUtils.fixedPhone(valueStr));
    196.                         break;
    197.                     }
    198.                     case MOBILE_PHONE: {
    199.                         field.set(javaBean, DesensitizedUtils.mobilePhone(valueStr));
    200.                         break;
    201.                     }
    202.                     case ADDRESS: {
    203.                         field.set(javaBean, DesensitizedUtils.address(valueStr, 7));
    204.                         break;
    205.                     }
    206.                     case EMAIL: {
    207.                         field.set(javaBean, DesensitizedUtils.email(valueStr));
    208.                         break;
    209.                     }
    210.                     case BANK_CARD: {
    211.                         field.set(javaBean, DesensitizedUtils.bankCard(valueStr));
    212.                         break;
    213.                     }
    214.                     case PASSWORD: {
    215.                         field.set(javaBean, DesensitizedUtils.password(valueStr));
    216.                         break;
    217.                     }case ACCOUNT:{
    218.                         field.set(javaBean, DesensitizedUtils.account(valueStr));
    219.                         break;
    220.                     }
    221.                 }
    222.             }
    223.         }
    224.     }
    225.  
    226.     /**
    227.      * 执行某个对象中指定的方法
    228.      *
    229.      * @param javaBean     对象
    230.      * @param desensitized
    231.      * @return
    232.      */
    233.     private static boolean executeIsEffictiveMethod(Object javaBean, Desensitized desensitized) {
    234.         boolean isAnnotationEffictive = true;//注解默认生效
    235.         if (desensitized != null) {
    236.             String isEffictiveMethod = desensitized.isEffictiveMethod();
    237.             if (isNotEmpty(isEffictiveMethod)) {
    238.                 try {
    239.                     Method method = javaBean.getClass().getMethod(isEffictiveMethod);
    240.                     method.setAccessible(true);
    241.                     isAnnotationEffictive = (Boolean) method.invoke(javaBean);
    242.                 } catch (NoSuchMethodException e) {
    243.                     e.printStackTrace();
    244.                 } catch (IllegalAccessException e) {
    245.                     e.printStackTrace();
    246.                 } catch (InvocationTargetException e) {
    247.                     e.printStackTrace();
    248.                 }
    249.             }
    250.         }
    251.         return isAnnotationEffictive;
    252.     }
    253.  
    254.     private static boolean isNotEmpty(String str) {
    255.         return str != null && !"".equals(str);
    256.     }
    257.  
    258.     private static boolean isEmpty(String str) {
    259.         return !isNotEmpty(str);
    260.     }
    261.  
    262.     /**
    263.      * 【中文姓名】只显示第一个汉字，其他隐藏为2个星号，比如：李**
    264.      *
    265.      * @param fullName
    266.      * @return
    267.      */
    268.     public static String chineseName(String fullName) {
    269.         if (StringUtils.isBlank(fullName)) {
    270.             return "";
    271.         }
    272.         String name = StringUtils.left(fullName, 1);
    273.         return StringUtils.rightPad(name, StringUtils.length(fullName), "*");
    274.     }
    275.  
    276.     /**
    277.      * 【身份证号】显示第一位和最后一位
    278.      *
    279.      * @param id
    280.      * @return
    281.      */
    282.     public static String idCardNum(String id) {
    283.         if (StringUtils.isBlank(id)) {
    284.             return "";
    285.         }
    286.         return StringUtils.left(id,1).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(id,1), StringUtils.length(id),"*"),"*"));
    287.     }
    288.  
    289.     /**
    290.      * 【虚拟账号】显示第一位和最后一位
    291.      *
    292.      * @param id
    293.      * @return
    294.      */
    295.     public static String account(String id) {
    296.         if (StringUtils.isBlank(id)) {
    297.             return "";
    298.         }
    299.         return StringUtils.left(id,1).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(id,1), StringUtils.length(id),"*"),"*"));
    300.     }
    301.  
    302.  
    303.     /**
    304.      * 【固定电话 后四位，其他隐藏，比如1234
    305.      *
    306.      * @param num
    307.      * @return
    308.      */
    309.     public static String fixedPhone(String num) {
    310.         if (StringUtils.isBlank(num)) {
    311.             return "";
    312.         }
    313.         return StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*");
    314.     }
    315.  
    316.     /**
    317.      * 【手机号码】前三位，后四位，其他隐藏，比如135****6810
    318.      *
    319.      * @param num
    320.      * @return
    321.      */
    322.     public static String mobilePhone(String num) {
    323.         if (StringUtils.isBlank(num)) {
    324.             return "";
    325.         }
    326.         return StringUtils.left(num, 3).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*"), "***"));
    327.     }
    328.  
    329.     /**
    330.      * 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
    331.      *
    332.      * @param address
    333.      * @param sensitiveSize 敏感信息长度
    334.      * @return
    335.      */
    336.     public static String address(String address, int sensitiveSize) {
    337.         if (StringUtils.isBlank(address)) {
    338.             return "";
    339.         }
    340.         int length = StringUtils.length(address);
    341.         return StringUtils.rightPad(StringUtils.left(address, length - sensitiveSize), length, "*");
    342.     }
    343.  
    344.     /**
    345.      * 【电子邮箱 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com>
    346.      *
    347.      * @param email
    348.      * @return
    349.      */
    350.     public static String email(String email) {
    351.         if (StringUtils.isBlank(email)) {
    352.             return "";
    353.         }
    354.         int index = StringUtils.indexOf(email, "@");
    355.         if (index <= 1)
    356.             return email;
    357.         else
    358.             return StringUtils.rightPad(StringUtils.left(email, 1), index, "*").concat(StringUtils.mid(email, index, StringUtils.length(email)));
    359.     }
    360.  
    361.     /**
    362.      * 【银行卡号】前4位，后3位，其他用星号隐藏每位1个星号，比如：6217 **** **** **** 567>
    363.      *
    364.      * @param cardNum
    365.      * @return
    366.      */
    367.     public static String bankCard(String cardNum) {
    368.         if (StringUtils.isBlank(cardNum)) {
    369.             return "";
    370.         }
    371.         return StringUtils.left(cardNum, 4).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(cardNum, 3), StringUtils.length(cardNum), "*"), "****"));
    372.     }
    373.  
    374.     /**
    375.      * 【密码】密码的全部字符都用*代替，比如：******
    376.      *
    377.      * @param password
    378.      * @return
    379.      */
    380.     public static String password(String password) {
    381.         if (StringUtils.isBlank(password)) {
    382.             return "";
    383.         }
    384.         String pwd = StringUtils.left(password, 0);
    385.         return StringUtils.rightPad(pwd, StringUtils.length(password), "*");
    386.     }
    387.  
    388.     /**
    389.      * 遍历List脱敏数据
    390.      * @param content
    391.      * @return
    392.      */
    393.     public static <T> List getList(List<T> content){
    394.         if (content == null || content.size() <= 0) {
    395.             return content;
    396.         }
    397.         List list = new ArrayList<T>();
    398.         for (T t : content) {
    399.             list.add(getObj(t));
    400.         }
    401.         return list;
    402.     }
    403. }
    404.

    创建脱敏工具类

    1. package com.artboy.project.common.utils;
    2.  
    3. import com.artboy.project.common.annotation.Desensitized;
    4. import com.google.gson.Gson;
    5. import org.apache.commons.lang3.StringUtils;
    6.  
    7. import java.lang.reflect.Array;
    8. import java.lang.reflect.Field;
    9. import java.lang.reflect.InvocationTargetException;
    10. import java.lang.reflect.Method;
    11. import java.util.*;
    12.  
    13. /**
    14.  * @author xh
    15.  * @Date 2022/7/26
    16.  */
    17. public class DesensitizedUtils {
    18.     /**
    19.      * 获取脱敏json串(递归引用会导致java.lang.StackOverflowError)
    20.      *
    21.      * @param javaBean
    22.      * @return
    23.      */
    24.     public static String getJson(Object javaBean) {
    25.         String json = null;
    26.         if (null != javaBean) {
    27.             try {
    28.                 if (javaBean.getClass().isInterface()) return json;
    29.                 /* 克隆出一个实体进行字段修改，避免修改原实体 */
    30.                 //Object clone =DesensitizedObjectUtils.deepCloneObject(javaBean);
    31.                 //Object clone =DesensitizedObjectUtils.deepCloneByFastJson(javaBean);
    32.                 Object clone = DesensitizedObjectUtils.deepClone(javaBean);
    33.  
    34.                 /* 定义一个计数器，用于避免重复循环自定义对象类型的字段 */
    35.                 Set<Integer> referenceCounter = new HashSet<Integer>();
    36.  
    37.                 /* 对克隆实体进行脱敏操作 */
    38.                 DesensitizedUtils.replace(DesensitizedObjectUtils.getAllFields(clone), clone, referenceCounter);
    39.  
    40.                 /* 利用fastjson对脱敏后的克隆对象进行序列化 */
    41. //                json = JSON.toJSONString(clone, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullListAsEmpty);
    42.                 json = new Gson().toJson(clone);
    43.  
    44.                 /* 清空计数器 */
    45.                 referenceCounter.clear();
    46.                 referenceCounter = null;
    47.             } catch (Throwable e) {
    48.                 e.printStackTrace();
    49.             }
    50.         }
    51.         return json;
    52.     }
    53.  
    54.     public static <T> T getObj(T javaBean) {
    55.         T clone = null;
    56.         if (null != javaBean) {
    57.             try {
    58.                 if (javaBean.getClass().isInterface()) return null;
    59.                 /* 克隆出一个实体进行字段修改，避免修改原实体 */
    60.                 //Object clone =DesensitizedObjectUtils.deepCloneObject(javaBean);
    61.                 //Object clone =DesensitizedObjectUtils.deepCloneByFastJson(javaBean);
    62.                 clone = (T) DesensitizedObjectUtils.deepClone(javaBean);
    63.  
    64.                 /* 定义一个计数器，用于避免重复循环自定义对象类型的字段 */
    65.                 Set<Integer> referenceCounter = new HashSet<Integer>();
    66.  
    67.                 /* 对克隆实体进行脱敏操作 */
    68.                 DesensitizedUtils.replace(DesensitizedObjectUtils.getAllFields(clone), clone, referenceCounter);
    69.  
    70.                 /* 清空计数器 */
    71.                 referenceCounter.clear();
    72.                 referenceCounter = null;
    73.             } catch (Throwable e) {
    74.                 e.printStackTrace();
    75.             }
    76.         }
    77.         return clone;
    78.     }
    79.  
    80.     /**
    81.      * 对需要脱敏的字段进行转化
    82.      *
    83.      * @param fields
    84.      * @param javaBean
    85.      * @param referenceCounter
    86.      * @throws IllegalArgumentException
    87.      * @throws IllegalAccessException
    88.      */
    89.     private static void replace(Field[] fields, Object javaBean, Set<Integer> referenceCounter) throws IllegalArgumentException, IllegalAccessException {
    90.         if (null != fields && fields.length > 0) {
    91.             for (Field field : fields) {
    92.                 field.setAccessible(true);
    93.                 if (null != field && null != javaBean) {
    94.                     Object value = field.get(javaBean);
    95.                     if (null != value) {
    96.                         Class<?> type = value.getClass();
    97.                         //处理子属性，包括集合中的
    98.                         if (type.isArray()) {//对数组类型的字段进行递归过滤
    99.                             int len = Array.getLength(value);
    100.                             for (int i = 0; i < len; i++) {
    101.                                 Object arrayObject = Array.get(value, i);
    102.                                 if (isNotGeneralType(arrayObject.getClass(), arrayObject, referenceCounter)) {
    103.                                     replace(DesensitizedObjectUtils.getAllFields(arrayObject), arrayObject, referenceCounter);
    104.                                 }
    105.                             }
    106.                         } else if (value instanceof Collection<?>) {//对集合类型的字段进行递归过滤
    107.                             Collection<?> c = (Collection<?>) value;
    108.                             Iterator<?> it = c.iterator();
    109.                             while (it.hasNext()) {// TODO: 待优化
    110.                                 Object collectionObj = it.next();
    111.                                 if (isNotGeneralType(collectionObj.getClass(), collectionObj, referenceCounter)) {
    112.                                     replace(DesensitizedObjectUtils.getAllFields(collectionObj), collectionObj, referenceCounter);
    113.                                 }
    114.                             }
    115.                         } else if (value instanceof Map<?, ?>) {//对Map类型的字段进行递归过滤
    116.                             Map<?, ?> m = (Map<?, ?>) value;
    117.                             Set<?> set = m.entrySet();
    118.                             for (Object o : set) {
    119.                                 Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
    120.                                 Object mapVal = entry.getValue();
    121.                                 if (isNotGeneralType(mapVal.getClass(), mapVal, referenceCounter)) {
    122.                                     replace(DesensitizedObjectUtils.getAllFields(mapVal), mapVal, referenceCounter);
    123.                                 }
    124.                             }
    125.                         } else if (value instanceof Enum<?>) {
    126.                             continue;
    127.                         }
    128.  
    129.                         /*除基础类型、jdk类型的字段之外，对其他类型的字段进行递归过滤*/
    130.                         else {
    131.                             if (!type.isPrimitive()
    132.                                     && type.getPackage() != null
    133.                                     && !StringUtils.startsWith(type.getPackage().getName(), "javax.")
    134.                                     && !StringUtils.startsWith(type.getPackage().getName(), "java.")
    135.                                     && !StringUtils.startsWith(field.getType().getName(), "javax.")
    136.                                     && !StringUtils.startsWith(field.getName(), "java.")
    137.                                     && referenceCounter.add(value.hashCode())) {
    138.                                 replace(DesensitizedObjectUtils.getAllFields(value), value, referenceCounter);
    139.                             }
    140.                         }
    141.                     }
    142.  
    143.                     //脱敏操作
    144.                     setNewValueForField(javaBean, field, value);
    145.  
    146.                 }
    147.             }
    148.         }
    149.     }
    150.  
    151.     /**
    152.      * 排除基础类型、jdk类型、枚举类型的字段
    153.      *
    154.      * @param clazz
    155.      * @param value
    156.      * @param referenceCounter
    157.      * @return
    158.      */
    159.     private static boolean isNotGeneralType(Class<?> clazz, Object value, Set<Integer> referenceCounter) {
    160.         return !clazz.isPrimitive()
    161.                 && clazz.getPackage() != null
    162.                 && !clazz.isEnum()
    163.                 && !StringUtils.startsWith(clazz.getPackage().getName(), "javax.")
    164.                 && !StringUtils.startsWith(clazz.getPackage().getName(), "java.")
    165.                 && !StringUtils.startsWith(clazz.getName(), "javax.")
    166.                 && !StringUtils.startsWith(clazz.getName(), "java.")
    167.                 && referenceCounter.add(value.hashCode());
    168.     }
    169.  
    170.     /**
    171.      * 脱敏操作（按照规则转化需要脱敏的字段并设置新值）
    172.      * 目前只支持String类型的字段，如需要其他类型如BigDecimal、Date等类型，可以添加
    173.      *
    174.      * @param javaBean
    175.      * @param field
    176.      * @param value
    177.      * @throws IllegalAccessException
    178.      */
    179.     public static void setNewValueForField(Object javaBean, Field field, Object value) throws IllegalAccessException {
    180.         //处理自身的属性
    181.         Desensitized annotation = field.getAnnotation(Desensitized.class);
    182.         if (field.getType().equals(String.class) && null != annotation && executeIsEffictiveMethod(javaBean, annotation)) {
    183.             String valueStr = (String) value;
    184.             if (StringUtils.isNotBlank(valueStr)) {
    185.                 switch (annotation.type()) {
    186.                     case CHINESE_NAME: {
    187.                         field.set(javaBean, DesensitizedUtils.chineseName(valueStr));
    188.                         break;
    189.                     }
    190.                     case ID_CARD: {
    191.                         field.set(javaBean, DesensitizedUtils.idCardNum(valueStr));
    192.                         break;
    193.                     }
    194.                     case FIXED_PHONE: {
    195.                         field.set(javaBean, DesensitizedUtils.fixedPhone(valueStr));
    196.                         break;
    197.                     }
    198.                     case MOBILE_PHONE: {
    199.                         field.set(javaBean, DesensitizedUtils.mobilePhone(valueStr));
    200.                         break;
    201.                     }
    202.                     case ADDRESS: {
    203.                         field.set(javaBean, DesensitizedUtils.address(valueStr, 7));
    204.                         break;
    205.                     }
    206.                     case EMAIL: {
    207.                         field.set(javaBean, DesensitizedUtils.email(valueStr));
    208.                         break;
    209.                     }
    210.                     case BANK_CARD: {
    211.                         field.set(javaBean, DesensitizedUtils.bankCard(valueStr));
    212.                         break;
    213.                     }
    214.                     case PASSWORD: {
    215.                         field.set(javaBean, DesensitizedUtils.password(valueStr));
    216.                         break;
    217.                     }case ACCOUNT:{
    218.                         field.set(javaBean, DesensitizedUtils.account(valueStr));
    219.                         break;
    220.                     }
    221.                 }
    222.             }
    223.         }
    224.     }
    225.  
    226.     /**
    227.      * 执行某个对象中指定的方法
    228.      *
    229.      * @param javaBean     对象
    230.      * @param desensitized
    231.      * @return
    232.      */
    233.     private static boolean executeIsEffictiveMethod(Object javaBean, Desensitized desensitized) {
    234.         boolean isAnnotationEffictive = true;//注解默认生效
    235.         if (desensitized != null) {
    236.             String isEffictiveMethod = desensitized.isEffictiveMethod();
    237.             if (isNotEmpty(isEffictiveMethod)) {
    238.                 try {
    239.                     Method method = javaBean.getClass().getMethod(isEffictiveMethod);
    240.                     method.setAccessible(true);
    241.                     isAnnotationEffictive = (Boolean) method.invoke(javaBean);
    242.                 } catch (NoSuchMethodException e) {
    243.                     e.printStackTrace();
    244.                 } catch (IllegalAccessException e) {
    245.                     e.printStackTrace();
    246.                 } catch (InvocationTargetException e) {
    247.                     e.printStackTrace();
    248.                 }
    249.             }
    250.         }
    251.         return isAnnotationEffictive;
    252.     }
    253.  
    254.     private static boolean isNotEmpty(String str) {
    255.         return str != null && !"".equals(str);
    256.     }
    257.  
    258.     private static boolean isEmpty(String str) {
    259.         return !isNotEmpty(str);
    260.     }
    261.  
    262.     /**
    263.      * 【中文姓名】只显示第一个汉字，其他隐藏为2个星号，比如：李**
    264.      *
    265.      * @param fullName
    266.      * @return
    267.      */
    268.     public static String chineseName(String fullName) {
    269.         if (StringUtils.isBlank(fullName)) {
    270.             return "";
    271.         }
    272.         String name = StringUtils.left(fullName, 1);
    273.         return StringUtils.rightPad(name, StringUtils.length(fullName), "*");
    274.     }
    275.  
    276.     /**
    277.      * 【身份证号】显示第一位和最后一位
    278.      *
    279.      * @param id
    280.      * @return
    281.      */
    282.     public static String idCardNum(String id) {
    283.         if (StringUtils.isBlank(id)) {
    284.             return "";
    285.         }
    286.         return StringUtils.left(id,1).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(id,1), StringUtils.length(id),"*"),"*"));
    287.     }
    288.  
    289.     /**
    290.      * 【虚拟账号】显示第一位和最后一位
    291.      *
    292.      * @param id
    293.      * @return
    294.      */
    295.     public static String account(String id) {
    296.         if (StringUtils.isBlank(id)) {
    297.             return "";
    298.         }
    299.         return StringUtils.left(id,1).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(id,1), StringUtils.length(id),"*"),"*"));
    300.     }
    301.  
    302.  
    303.     /**
    304.      * 【固定电话 后四位，其他隐藏，比如1234
    305.      *
    306.      * @param num
    307.      * @return
    308.      */
    309.     public static String fixedPhone(String num) {
    310.         if (StringUtils.isBlank(num)) {
    311.             return "";
    312.         }
    313.         return StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*");
    314.     }
    315.  
    316.     /**
    317.      * 【手机号码】前三位，后四位，其他隐藏，比如135****6810
    318.      *
    319.      * @param num
    320.      * @return
    321.      */
    322.     public static String mobilePhone(String num) {
    323.         if (StringUtils.isBlank(num)) {
    324.             return "";
    325.         }
    326.         return StringUtils.left(num, 3).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*"), "***"));
    327.     }
    328.  
    329.     /**
    330.      * 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
    331.      *
    332.      * @param address
    333.      * @param sensitiveSize 敏感信息长度
    334.      * @return
    335.      */
    336.     public static String address(String address, int sensitiveSize) {
    337.         if (StringUtils.isBlank(address)) {
    338.             return "";
    339.         }
    340.         int length = StringUtils.length(address);
    341.         return StringUtils.rightPad(StringUtils.left(address, length - sensitiveSize), length, "*");
    342.     }
    343.  
    344.     /**
    345.      * 【电子邮箱 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com>
    346.      *
    347.      * @param email
    348.      * @return
    349.      */
    350.     public static String email(String email) {
    351.         if (StringUtils.isBlank(email)) {
    352.             return "";
    353.         }
    354.         int index = StringUtils.indexOf(email, "@");
    355.         if (index <= 1)
    356.             return email;
    357.         else
    358.             return StringUtils.rightPad(StringUtils.left(email, 1), index, "*").concat(StringUtils.mid(email, index, StringUtils.length(email)));
    359.     }
    360.  
    361.     /**
    362.      * 【银行卡号】前4位，后3位，其他用星号隐藏每位1个星号，比如：6217 **** **** **** 567>
    363.      *
    364.      * @param cardNum
    365.      * @return
    366.      */
    367.     public static String bankCard(String cardNum) {
    368.         if (StringUtils.isBlank(cardNum)) {
    369.             return "";
    370.         }
    371.         return StringUtils.left(cardNum, 4).concat(StringUtils.removeStart(StringUtils.leftPad(StringUtils.right(cardNum, 3), StringUtils.length(cardNum), "*"), "****"));
    372.     }
    373.  
    374.     /**
    375.      * 【密码】密码的全部字符都用*代替，比如：******
    376.      *
    377.      * @param password
    378.      * @return
    379.      */
    380.     public static String password(String password) {
    381.         if (StringUtils.isBlank(password)) {
    382.             return "";
    383.         }
    384.         String pwd = StringUtils.left(password, 0);
    385.         return StringUtils.rightPad(pwd, StringUtils.length(password), "*");
    386.     }
    387.  
    388.     /**
    389.      * 遍历List脱敏数据
    390.      * @param content
    391.      * @return
    392.      */
    393.     public static <T> List getList(List<T> content){
    394.         if (content == null || content.size() <= 0) {
    395.             return content;
    396.         }
    397.         List list = new ArrayList<T>();
    398.         for (T t : content) {
    399.             list.add(getObj(t));
    400.         }
    401.         return list;
    402.     }
    403. }
    404.

    测试

    这里我们以UserEntity为例：（一定要序列化）

    1. package com.artboy.project.model.entity;
    2.  
    3. import com.artboy.project.common.annotation.Desensitized;
    4. import com.artboy.project.common.enums.SensitiveTypeEnum;
    5. import com.baomidou.mybatisplus.annotation.IdType;
    6. import com.baomidou.mybatisplus.annotation.TableField;
    7. import com.baomidou.mybatisplus.annotation.TableId;
    8. import com.baomidou.mybatisplus.annotation.TableLogic;
    9. import com.baomidou.mybatisplus.annotation.TableName;
    10. import java.io.Serializable;
    11. import java.util.Date;
    12. import lombok.Data;
    13.  
    14. /**
    15.  * 用户
    16.  *
    17.  * @TableName user
    18.  */
    19. @TableName(value = "user")
    20. @Data
    21. public class UserEntity implements Serializable {
    22.  
    23.     /**
    24.      * id
    25.      */
    26.     @TableId(type = IdType.AUTO)
    27.     private Integer id;
    28.  
    29.     /**
    30.      * 用户昵称
    31.      */
    32.     private String username;
    33.  
    34.     /**
    35.      * 账号
    36.      */
    37.     private String userAccount;
    38.  
    39.     /**
    40.      * 用户头像
    41.      */
    42.     private String avatarUrl;
    43.  
    44.     /**
    45.      * 性别
    46.      */
    47.     private Integer gender;
    48.  
    49.     /**
    50.      * 密码
    51.      */
    52.     @Desensitized(type = SensitiveTypeEnum.PASSWORD)
    53.     private String userPassword;
    54.  
    55.     /**
    56.      * 电话
    57.      */
    58.     @Desensitized(type = SensitiveTypeEnum.MOBILE_PHONE)
    59.     private String phone;
    60.  
    61.     /**
    62.      * 邮箱
    63.      */
    64.     @Desensitized(type = SensitiveTypeEnum.EMAIL)
    65.     private String email;
    66.  
    67.     /**
    68.      * 状态 0 - 正常
    69.      */
    70.     private Integer userStatus;
    71.  
    72.     /**
    73.      * 创建时间，数据库已设置自动更新
    74.      */
    75.     private Date createTime;
    76.  
    77.     /**
    78.      * 更新时间，数据库已设置自动更新
    79.      */
    80.     private Date updateTime;
    81.  
    82.     /**
    83.      * 是否删除
    84.      */
    85.     @TableLogic
    86.     private Integer isDelete;
    87.  
    88.     /**
    89.      * 用户角色 0 - 普通用户 1 - 管理员
    90.      */
    91.     private Integer userRole;
    92.  
    93.     @TableField(exist = false)
    94.     private static final long serialVersionUID = 1L;
    95. }

    测试方法：

    1. QueryWrapper<UserEntity> queryWrapper = new QueryWrapper<>();
    2. UserEntity user = userMapper.selectOne(queryWrapper);
    3. UserEntity safetyUser = DesensitizedUtils.getObj(user);

    Springboot切面+注解实现数据脱敏

    处理步骤

    新建脱敏的枚举类

    1. package com.fwy.common.config.dataRule;
    2.  
    3. import lombok.Getter;
    4.  
    5. /**
    6.  * @description:隐私数据类型枚举
    7.  * @author: xiaYZ
    8.  * @createDate: 2022/6/21
    9.  */
    11. @Getter
    12. public enum PrivacyTypeEnum {
    13.  
    14.     /** 自定义（此项需设置脱敏的范围）*/
    15.     CUSTOMER,
    16.  
    17.     /** 姓名 */
    18.     NAME,
    19.  
    20.     /** 身份证号 */
    21.     ID_CARD,
    22.  
    23.     /** 手机号 */
    24.     PHONE,
    25.  
    26.     /** 邮箱 */
    27.     EMAIL,
    28. }

    新建脱敏操作的工具类

    1. package com.fwy.common.config.dataRule;
    2.  
    3. /**
    4.  * @description:
    5.  * @author: xiaYZ
    6.  * @createDate: 2022/6/21
    7.  */
    8. public class PrivacyUtil {
    9.  
    10.     /**
    11.      * 隐藏手机号中间四位
    12.      */
    13.     public static String hidePhone(String phone) {
    14.         return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    15.     }
    16.  
    17.     /**
    18.      * 隐藏邮箱
    19.      */
    20.     public static String hideEmail(String email) {
    21.         return email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
    22.     }
    23.  
    24.     /**
    25.      * 隐藏身份证
    26.      */
    27.     public static String hideIDCard(String idCard) {
    28.         return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1*****$2");
    29.     }
    30.  
    31.     /**
    32.      * 【中文姓名】只显示第一个汉字，其他隐藏为星号，比如：任**
    33.      */
    34.     public static String hideChineseName(String chineseName) {
    35.         if (chineseName == null) {
    36.             return null;
    37.         }
    38.         return desValue(chineseName, 1, 0, "*");
    39.     }
    40.  
    41. //    /**
    42. //     * 【身份证号】显示前4位, 后2位
    43. //     */
    44. //    public static String hideIdCard(String idCard) {
    45. //        return desValue(idCard, 4, 2, "*");
    46. //    }
    47.  
    48. //    /**
    49. //     * 【手机号码】前三位，后四位，其他隐藏。
    50. //     */
    51. //    public static String hidePhone(String phone) {
    52. //        return desValue(phone, 3, 4, "*");
    53. //    }
    54.  
    55.     /**
    56.      * 对字符串进行脱敏操作
    57.      * @param origin          原始字符串
    58.      * @param prefixNoMaskLen 左侧需要保留几位明文字段
    59.      * @param suffixNoMaskLen 右侧需要保留几位明文字段
    60.      * @param maskStr         用于遮罩的字符串, 如'*'
    61.      * @return 脱敏后结果
    62.      */
    63.     public static String desValue(String origin, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
    64.         if (origin == null) {
    65.             return null;
    66.         }
    67.         StringBuilder sb = new StringBuilder();
    68.         for (int i = 0, n = origin.length(); i < n; i++) {
    69.             if (i < prefixNoMaskLen) {
    70.                 sb.append(origin.charAt(i));
    71.                 continue;
    72.             }
    73.             if (i > (n - suffixNoMaskLen - 1)) {
    74.                 sb.append(origin.charAt(i));
    75.                 continue;
    76.             }
    77.             sb.append(maskStr);
    78.         }
    79.         return sb.toString();
    80.     }
    81.  
    82. }
    83.

    申明注解类

    1. package com.fwy.common.config.dataRule;
    2.  
    3.  
    4. import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
    5. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
    6.  
    7. import java.lang.annotation.ElementType;
    8. import java.lang.annotation.Retention;
    9. import java.lang.annotation.RetentionPolicy;
    10. import java.lang.annotation.Target;
    11.  
    12.  
    13. /**
    14.  * @description: 自定义数据脱敏注解
    15.  * @author: xiaYZ
    16.  * @createDate: 2022/6/21
    17.  */
    19. @Target(ElementType.FIELD) // 作用在字段上
    20. @Retention(RetentionPolicy.RUNTIME) // class文件中保留，运行时也保留，能通过反射读取到
    21. @JacksonAnnotationsInside // 表示自定义自己的注解PrivacyEncrypt
    22. @JsonSerialize(using = PrivacySerializer.class) // 该注解使用序列化的方式
    23. public @interface PrivacyEncrypt {
    24.  
    25.     /**
    26.      * 脱敏数据类型（没给默认值，所以使用时必须指定type）
    27.      */
    28.     PrivacyTypeEnum type();
    29.  
    30.     /**
    31.      * 前置不需要打码的长度
    32.      */
    33.     int prefixNoMaskLen() default 1;
    34.  
    35.     /**
    36.      * 后置不需要打码的长度
    37.      */
    38.     int suffixNoMaskLen() default 1;
    39.  
    40.     /**
    41.      * 用什么打码
    42.      */
    43.     String symbol() default "*";
    44. }
    45.

    注解的AOP操作

    1. package com.fwy.common.config.dataRule;
    2.  
    3. import com.fasterxml.jackson.core.JsonGenerator;
    4. import com.fasterxml.jackson.databind.BeanProperty;
    5. import com.fasterxml.jackson.databind.JsonMappingException;
    6. import com.fasterxml.jackson.databind.JsonSerializer;
    7. import com.fasterxml.jackson.databind.SerializerProvider;
    8. import com.fasterxml.jackson.databind.ser.ContextualSerializer;
    9. import lombok.AllArgsConstructor;
    10. import lombok.NoArgsConstructor;
    11. import org.apache.commons.lang3.StringUtils;
    12.  
    13. import java.io.IOException;
    14. import java.util.Objects;
    15.  
    16. /**
    17.  * @description:
    18.  * @author: xiaYZ
    19.  * @createDate: 2022/6/21
    20.  */
    21.  
    22.  
    23. @NoArgsConstructor
    24. @AllArgsConstructor
    25. public class PrivacySerializer extends JsonSerializer implements ContextualSerializer {
    26.  
    27.     // 脱敏类型
    28.     private PrivacyTypeEnum privacyTypeEnum;
    29.     // 前几位不脱敏
    30.     private Integer prefixNoMaskLen;
    31.     // 最后几位不脱敏
    32.     private Integer suffixNoMaskLen;
    33.     // 用什么打码
    34.     private String symbol;
    35.  
    36.     @Override
    37.     public void serialize(final String origin, final JsonGenerator jsonGenerator,
    38.                           final SerializerProvider serializerProvider) throws IOException {
    39.         if (StringUtils.isNotBlank(origin) && null != privacyTypeEnum) {
    40.             switch (privacyTypeEnum) {
    41.                 case CUSTOMER:
    42.                     jsonGenerator.writeString(PrivacyUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, symbol));
    43.                     break;
    44.                 case NAME:
    45.                     jsonGenerator.writeString(PrivacyUtil.hideChineseName(origin));
    46.                     break;
    47.                 case ID_CARD:
    48.                     jsonGenerator.writeString(PrivacyUtil.hideIDCard(origin));
    49.                     break;
    50.                 case PHONE:
    51.                     jsonGenerator.writeString(PrivacyUtil.hidePhone(origin));
    52.                     break;
    53.                 case EMAIL:
    54.                     jsonGenerator.writeString(PrivacyUtil.hideEmail(origin));
    55.                     break;
    56.                 default:
    57.                     throw new IllegalArgumentException("unknown privacy type enum " + privacyTypeEnum);
    58.             }
    59.         }
    60.     }
    61.  
    62.     @Override
    63.     public JsonSerializer createContextual(final SerializerProvider serializerProvider,
    64.                                               final BeanProperty beanProperty) throws JsonMappingException {
    65.         if (beanProperty != null) {
    66.             if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
    67.                 PrivacyEncrypt privacyEncrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
    68.                 if (privacyEncrypt == null) {
    69.                     privacyEncrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
    70.                 }
    71.                 if (privacyEncrypt != null) {
    72.                     return new PrivacySerializer(privacyEncrypt.type(), privacyEncrypt.prefixNoMaskLen(),
    73.                             privacyEncrypt.suffixNoMaskLen(), privacyEncrypt.symbol());
    74.                 }
    75.             }
    76.             return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    77.         }
    78.         return serializerProvider.findNullValueSerializer(null);
    79.     }
    80. }
    81.

    实际使用

    在这里插入图片描述

    基于jackson，通过自定义注解的方式实现数据脱敏

    添加依赖

    spring-web、spring-boot-starter-web已经集成了jackson相关包，不用添加

    1. <!--jackson依赖-->
    2. <dependency>
    3.     <groupId>com.fasterxml.jackson.core</groupId>
    4.     <artifactId>jackson-core</artifactId>
    5. </dependency>
    6. <dependency>
    7.     <groupId>com.fasterxml.jackson.core</groupId>
    8.     <artifactId>jackson-annotations</artifactId>
    9. </dependency>
    10. <dependency>
    11.     <groupId>com.fasterxml.jackson.core</groupId>
    12.     <artifactId>jackson-databind</artifactId>
    13. </dependency>

    脱敏注解
    DesensitizationJsonSerializer.class: 脱敏序列化类

    1. @Retention(RetentionPolicy.RUNTIME)
    2. @JacksonAnnotationsInside
    3. @JsonSerialize(using = DesensitizationJsonSerializer.class)
    4. public @interface Desensitization {
    5.  
    6.     Classextends AbstractDesensitization> value();
    7.  
    8. }

    脱敏序列化

    1. /**
    2.  * 脱敏序列化
    3.  */
    4. public class DesensitizationJsonSerializer extends JsonSerializer<String> implements ContextualSerializer {
    5.  
    6.     private AbstractDesensitization desensitization;
    7.  
    8.     public DesensitizationJsonSerializer() {
    9.     }
    10.  
    11.     public DesensitizationJsonSerializer(AbstractDesensitization desensitization) {
    12.         this.desensitization = desensitization;
    13.     }
    14.  
    15.     @Override
    16.     public void serialize(String s, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
    17.         jsonGenerator.writeString(desensitization.serialize(s));;
    18.     }
    19.  
    20.  
    21.     @Override
    22.     public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
    23.         JsonSerializer<?> jsonSerializer = null;
    24.         if(null == beanProperty) jsonSerializer = serializerProvider.findNullValueSerializer(beanProperty);
    25.  
    26.         if(!Objects.equals(beanProperty.getType().getRawClass(), String.class))
    27.             jsonSerializer = serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    28.  
    29.         if(Objects.equals(beanProperty.getType().getRawClass(), String.class)){
    30.             jsonSerializer = setDesensitization(jsonSerializer, beanProperty);
    31.         }
    32.         return jsonSerializer;
    33.     }
    34.  
    35.     /**
    36.      * 设置脱敏
    37.      * @param beanProperty
    38.      * @return
    39.      */
    40.     private JsonSerializer<?> setDesensitization(JsonSerializer<?> jsonSerializer, BeanProperty beanProperty) {
    41.         Desensitization desensitization = beanProperty.getAnnotation(Desensitization.class);
    42.  
    43.         if (desensitization == null) desensitization = beanProperty.getContextAnnotation(Desensitization.class);
    44.  
    45.         if (desensitization != null) {
    46.             //设置脱敏实例
    47.             try {
    48.                 jsonSerializer = new DesensitizationJsonSerializer(desensitization.value().newInstance());
    49.             } catch (InstantiationException e) {
    50.                 e.printStackTrace();
    51.             } catch (IllegalAccessException e) {
    52.                 e.printStackTrace();
    53.             }
    54.         }
    55.         return jsonSerializer;
    56.     }
    57. }

    脱敏类
    脱敏父类
    子类通过继承AbstractDesensitization实现扩展

    1. public abstract class AbstractDesensitization {
    2.  
    3.     /**
    4.      * 脱敏
    5.      * @param value
    6.      * @return
    7.      */
    8.     public abstract String serialize(String value);
    9.  
    10. }

    中文姓名脱敏

    1. public class ChineseNameDesensitization extends AbstractDesensitization {
    2.  
    3.     @Override
    4.     public String serialize(String value) {
    5.         String serializeValue = "";
    6.         if(value.length() < 3){
    7.             serializeValue = value.replaceAll(".*(?=[\\u4e00-\\u9fa5])","*");
    8.         }else{
    9.             serializeValue = value.replaceAll("(?<=[\\u4e00-\\u9fa5]).*(?=[\\u4e00-\\u9fa5])","*");
    10.         }
    11.         return serializeValue;
    12.     }
    13.  
    14. }

    手机号脱敏

    1. public class MobilePhoneDesensitization extends AbstractDesensitization {
    2.  
    3.     @Override
    4.     public String serialize(String value) {
    5.         return value.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");
    6.     }
    7.  
    8. }

    身份证脱敏

    1. public class IdCardDesensitization extends AbstractDesensitization {
    2.  
    3.     @Override
    4.     public String serialize(String value) {
    5.         return value.replaceAll("(?<=\\w{3})\\w(?=\\w{4})","*");
    6.     }
    7.  
    8. }

    测试
    添加脱敏注解

    1. public class User {
    2.  
    3.     @Desensitization(ChineseNameDesensitization.class)
    4.     private String name;
    5.  
    6.     private Integer age;
    7.  
    8.     @Desensitization(IdCardDesensitization.class)
    9.     private String idCard;
    10.  
    11.     @Desensitization(MobilePhoneDesensitization.class)
    12.     private String mobilePhone;
    13.  
    14.     //...get and set
    15. }

    新建UserController，查询用户信息

    1. @RestController
    2. public class UserController {
    3.  
    4.     @GetMapping("/users")
    5.     private List<User> users() throws Exception {
    6.         List<User> girls = new ArrayList<>();
    7.         User user = new User();
    8.         user.setName("西施");
    9.         user.setAge(18);
    10.         user.setIdCard("123456789123456202");
    11.         user.setMobilePhone("12345678901");
    12.         User user2 = new User();
    13.         user2.setName("杨贵妃");
    14.         user2.setAge(18);
    15.         user2.setIdCard("123456789123456202");
    16.         user2.setMobilePhone("12345678901");
    17.         User user3 = new User();
    18.         user3.setName("古代四大美女之一 * 貂蝉");
    19.         user3.setAge(18);
    20.         user3.setIdCard("123456789123456202");
    21.         user3.setMobilePhone("12345678901");
    22.         User user4 = new User();
    23.         user4.setName("古代四大美女之一 * 王昭君");
    24.         user4.setAge(18);
    25.         user4.setIdCard("123456789123456202");
    26.         user4.setMobilePhone("12345678901");
    27.         User user5 = new User();
    28.         user5.setName(null);
    29.         user5.setAge(18);
    30.         user5.setIdCard(null);
    31.         user5.setMobilePhone(null);
    32.         girls.add(user);
    33.         girls.add(user2);
    34.         girls.add(user3);
    35.         girls.add(user4);
    36.         girls.add(user5);
    37.         return girls;
    38.     }
    39. }

  • 相关阅读:
    【数仓基础（一）】基础概念：数据仓库【用于决策的数据集合】的概念、建立数据仓库的原因与好处
    Go语言结构体指针
    BI零售数据分析方案，看了就想拥有
    5 分钟带你小程序入门 [实战总结分享]
    2023-09-27 Cmake 编译 OpenCV+Contrib 源码通用设置
    Leetcode 1834. Single-Threaded CPU (堆好题)
    C语言学生成绩管理系统
    1034 Head of a Gang
    深入研究下Spring Boot Actuator 在kubernetes中探针的应用
    12年开发大佬，熬夜4个月整理的SpringBoot实战派，绝对涨薪秘籍
  • 原文地址：https://blog.csdn.net/weixin_53998054/article/details/126741551