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

项目是在controller层进行脱敏，查阅google和github有两种较为方便的方法

  1. 一种是基于注解 desensitized基于注解的形式进行脱敏 GitHub
  2. 一种是基于框架本质上还是注解，但是已经封装好了，当然还提供fastjson的方式进行脱敏 sensitive框架进行脱敏 GitHub
    由于项目原因不想引入框架，所以使用基于注解的方式

新建枚举类型，标明是何种脱敏方式

  1. package com.blgroup.vision.common.enums;
  3. /**
  4.  * @program: blgroup-scloud-web
  5.  * @description: 脱敏枚举
  6.  * @author: ingxx
  7.  * @create: 2019-12-17 14:32
  8.  **/
  9. public enum SensitiveTypeEnum {
  10.     /**
  11.      * 中文名
  12.      */
  13.     CHINESE_NAME,
  14.     /**
  15.      * 身份证号
  16.      */
  17.     ID_CARD,
  18.     /**
  19.      * 座机号
  20.      */
  21.     FIXED_PHONE,
  22.     /**
  23.      * 手机号
  24.      */
  25.     MOBILE_PHONE,
  26.     /**
  27.      * 地址
  28.      */
  29.     ADDRESS,
  30.     /**
  31.      * 电子邮件
  32.      */
  33.     EMAIL,
  34.     /**
  35.      * 银行卡
  36.      */
  37.     BANK_CARD,
  38.     /**
  39.      * 虚拟账号
  40.      */
  41.     ACCOUNT,
  42.     /**
  43.      * 密码
  44.      */
  45.     PASSWORD;
  46. }

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

  1. package com.blgroup.vision.common.annotation;
  4. import com.blgroup.vision.common.enums.SensitiveTypeEnum;
  6. import java.lang.annotation.*;
  8. /**
  9.  * @program: blgroup-scloud-web
  10.  * @description: 脱敏注解
  11.  * @author: ingxx
  12.  * @create: 2019-12-17 14:32
  13.  **/
  14. @Target({ElementType.FIELD, ElementType.METHOD})
  15. @Retention(RetentionPolicy.RUNTIME)
  16. @Inherited
  17. @Documented
  18. public @interface Desensitized {
  20.     /*脱敏类型(规则)*/
  21.     SensitiveTypeEnum type();
  23.     /*判断注解是否生效的方法*/
  24.     String isEffictiveMethod() default "";
  26. }

创建Object工具类，用于复制对象和对对象的其他操作,注意使用fastjson实现深拷贝对于复杂的对象会出现栈溢出，本人测试是发生在转换对象时对象会转换成JsonObject对象，在getHash方法中出现递归调用导致栈溢出，具体原因不明

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

创建脱敏工具类

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

因生产项目中不能展示 所以采用Demo的形式

创建测试实体类

  1. package top.ingxx.pojo;
  3. import lombok.Data;
  4. import top.ingxx.annotation.Desensitized;
  5. import top.ingxx.enums.SensitiveTypeEnum;
  7. @Data
  8. public class UserInfo {
  9.     @Desensitized(type = SensitiveTypeEnum.CHINESE_NAME)
  10.     private String realName;
  12.     @Desensitized(type = SensitiveTypeEnum.ID_CARD)
  13.     private String idCardNo;
  15.     @Desensitized(type = SensitiveTypeEnum.MOBILE_PHONE)
  16.     private String mobileNo;
  18.     @Desensitized(type = SensitiveTypeEnum.ADDRESS)
  19.     private String address;
  21.     @Desensitized(type = SensitiveTypeEnum.PASSWORD)
  22.     private String password;
  24.     @Desensitized(type = SensitiveTypeEnum.BANK_CARD)
  25.     private String bankCard;
  26. }

测试实体字段

  1. package top.ingxx.pojo;
  3. import lombok.Data;
  5. /**
  6.  * @program: demo
  7.  * @description: 测试
  8.  * @author: ingxx
  9.  * @create: 2019-12-18 09:16
  10.  **/
  11. @Data
  12. public class Test {
  13.     private UserInfo userInfo;
  14. }

测试主方法

  1. import com.alibaba.fastjson.JSON;
  2. import top.ingxx.pojo.Test;
  3. import top.ingxx.pojo.UserInfo;
  4. import top.ingxx.utils.DesensitizedUtils;
  6. public class Main {
  8.     public static void main(String[] args) {
  9.         UserInfo userInfo = new UserInfo();
  10.         userInfo.setAddress("上海浦东新区未知地址12号");
  11.         userInfo.setIdCardNo("111521444474441411");
  12.         userInfo.setMobileNo("13555551141");
  13.         userInfo.setPassword("123456");
  14.         userInfo.setRealName("张三");
  15.         userInfo.setBankCard("111521444474441411");
  16.         Test test = new Test();
  17.         test.setUserInfo(userInfo);
  18.         System.out.println(JSON.toJSONString(test));
  19.         Test obj = DesensitizedUtils.getObj(test);
  20.         System.out.println(JSON.toJSONString(obj));
  21.     }
  22. }

使用时可以对单个字段脱敏 也可以直接使用 getObj getJson getList等方法

版权声明：本文为ingxx原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/ingxx/p/12059235.html