自定义@Sensitive对敏感字段进行脱敏处理

1.通过面向切面基于注解方式进行处理

@RequestMapping("/test")
    @Sensitive(name={"userName"},phoneNo={"mobile"},email={"email"})
    public Rsp_1 test(){
       //对返回结果进行脱敏处理
    }

切面类

/**
 * 切面类，对敏感信息进行脱敏处理
 * @Author mufeng
 * @Date 2019-5-23 16:42
 */
@Aspect
@Component
public class SensitiveAspect {
    private static Logger logger=LoggerFactory.getLogger(SensitiveAspect.class);
   public SensitiveAspect(){

   }
   @Pointcut("@annotation(com.mufeng.validator.annotation.Sensitive)")
   public void filter(){

   }

    /**
     * 对@Sensitive标记的方法进行过滤
     * @param pjp
     * @return
     */
   @Around("filter()")
   public Object afterReturn(ProceedingJoinPoint pjp){
       MethodSignature signature = (MethodSignature)pjp.getSignature();
       Method method = signature.getMethod();
       Object result=null;
       try {
            result = pjp.proceed();
            if(method.isAnnotationPresent(Sensitive.class)){
                //对返回结果脱敏处理
                result= SensitiveUtil.sensitiveFilter(method, result);
            }
       } catch (Throwable throwable) {
           logger.error("脱敏异常："+throwable.getMessage());
       }
       return result;
   }
}

/**
 * 脱敏工具类
 * @Author mufeng
 * @Date 2019-5-23 17:46
 */
public class SensitiveUtil {
    private static Logger logger=LoggerFactory.getLogger(SensitiveUtil.class);
    //通过静态map存储，多次访问都是同一资源
    private static Map<String, Map<String, String>> METHOD_MAP = new HashMap();

    public SensitiveUtil() {
    }

    public static Object sensitiveFilter(Method method, Object result) {
        String methodName = method.getDeclaringClass().getName() + "." + method.getName();
        Map<String, String> map = (Map)METHOD_MAP.get(methodName);
        if (map == null) {
            //注册所有被标记的@Sensitive属性
            map = register(method);
        }
        //脱敏处理
        return desensitiveObject(map, result);
    }

    /**
     * 返回结果对象转成JsonObject，进行解析
     * @param filedsMap
     * @param result
     * @return
     */
    private static Object desensitiveObject(Map<String,String> filedsMap, Object result) {
         if(filedsMap.isEmpty()){
             return result;
         }else{
             Class<?> clazz = result.getClass();
             JSONObject jsonObj = (JSONObject)JSONObject.toJSON(result);
             //解析
             analysisJson(jsonObj, filedsMap);
             result = JSONObject.toJavaObject(jsonObj, clazz);
             return result;
         }
    }

    private static void analysisJson(Object jsonObj, Map<String,String> filedsMap) {
        //
        if(jsonObj instanceof JSONArray){
            JSONArray jsonArr = (JSONArray) jsonObj;
            for(int i=0;i<jsonArr.size();i++){
                Object obj = jsonArr.get(i);
                //不是JSONObject或JSONArray不进行解析
                if(!(obj instanceof JSONObject)&&!(obj instanceof JSONArray)){
                    logger.info("JsonArray 不进行解析的第{}属性：{}",i,obj);
                }else{
                    analysisJson(obj,filedsMap);
                }
            }
        }else if(jsonObj instanceof JSONObject){
            JSONObject jsonObject = (JSONObject) jsonObj;
            jsonObject.keySet().forEach(key -> {
                Object obj = jsonObject.get(key);
                //不是JSONObject或JSONArray,为String进行处理
                if(!(obj instanceof JSONObject)&&!(obj instanceof JSONArray)){
                    if(obj instanceof String){
                        processDesensitizeJson(jsonObject, key, filedsMap);
                    }else{
                        logger.info("JSONObject不解析属性：{}",obj);
                    }
                }else{
                    analysisJson(obj,filedsMap);
                }
            });
        }else{
            logger.info("不是JSONObject和JsonArray不进行解析：{}",jsonObj);
        }
    }

    /**
     * 脱敏处理
     * @param jsonObject 返回结果
     * @param key  需脱敏处理字段名
     * @param filedsMap 需脱敏map
     */
    private static void processDesensitizeJson(JSONObject jsonObject, String key, Map<String,String> filedsMap) {
        if(filedsMap.containsKey(key)){

            try {
                logger.info("开始脱敏处理。。。。");
                //获取脱敏对应handle的方法名
                String methodName = filedsMap.get(key);
                //实例化脱敏处理类
                Class<?> clazz = Class.forName("com.mufeng.validator.util.SensitiveHandle");
                //通过反射获取脱敏方法
                Method method = clazz.getMethod(methodName, String.class);
                //脱敏返回新值
                String newValue =(String) method.invoke((Object) null, (String) jsonObject.get(key));
                jsonObject.put(key,newValue);
            } catch (Exception e) {
                logger.error("脱敏异常：{}",e.getMessage());
            }
        }
    }

    private static Map<String, String> register(Method method) {
        Map<String, String> map = new HashMap();
        Sensitive sen = (Sensitive)method.getAnnotation(Sensitive.class);
        if (sen != null) {
            //获取@Sensitive注解所有属性
            Method[] methods = Sensitive.class.getMethods();
            Method[] var4 = methods;
            int var5 = methods.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                Method m = var4[var6];

                try {
                    //获取被标记属性的值
                    String[] keys = (String[])((String[])m.invoke(sen));
                    if (keys == null || keys.length == 0) {
                        break;
                    }

                    String[] var9 = keys;
                    int var10 = keys.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String s = var9[var11];
                        if (StringUtils.isEmpty(s)) {
                            break;
                        }
                        //属性值作为key，属性名作为value
                        map.put(s, m.getName());
                    }
                } catch (Exception var13) {
                    logger.error(var13.getMessage());
                }
            }

            METHOD_MAP.put(method.getDeclaringClass().getName() + "." + method.getName(), map);
        }

        return map;
    }

/**
 * 处理类
 * @Author mufeng
 * @Date 2019-5-24 10:26
 */
public class SensitiveHandle {
    public SensitiveHandle() {
    }

    public static String name(String name) {
        if (StringUtils.isEmpty(name)) {
            return "";
        } else {
            return name.length() == 1 ? name : SensitiveBean.getMaskCharWay(name, 2, name.length());
        }
    }

    public static String idCardNo(String idCardNo) {
        if (StringUtils.isEmpty(idCardNo)) {
            return "";
        } else {
            return idCardNo.length() <= 8 ? idCardNo : SensitiveBean.getMaskCharWay(idCardNo, 5, idCardNo.length() - 4);
        }
    }

    public static String driverLicense(String drivingLicense) {
        if (StringUtils.isEmpty(drivingLicense)) {
            return "";
        } else {
            return drivingLicense.length() <= 8 ? drivingLicense : SensitiveBean.getMaskCharWay(drivingLicense, 5, drivingLicense.length() - 4);
        }
    }

}

/**
 * * 进行覆盖 
 * @Author mufeng
 * @Date 2019-5-24 10:33
 */
public class SensitiveBean {
    private static final String[] cache = new String[]{"*", "**", "***", "****", "*****", "******", "*******", "********", "*********", "**********", "***********", "************", "*************", "**************", "***************", "****************"};
    private static final char coverDefault = '*';
    private String initialCode;
    private int beginIndex;
    private int endIndex;
    private char cover = '*';

    public SensitiveBean() {
    }

    public SensitiveBean(String initialCode, int beginIndex, int endIndex) {
        this.initialCode = initialCode;
        this.beginIndex = beginIndex;
        this.endIndex = endIndex;
    }

    public SensitiveBean(String initialCode, int beginIndex, int endIndex, char cover) {
        this.initialCode = initialCode;
        this.beginIndex = beginIndex;
        this.endIndex = endIndex;
        this.cover = cover;
    }

    public static String getMaskSubWay(String initialCode, int beginIndex, int endIndex) {
        SensitiveBean override = new SensitiveBean(initialCode, beginIndex, endIndex);
        return override.getMaskSubWay();
    }

    public static String getMaskSubWay(String initialCode, int beginIndex, int endIndex, char cover) {
        SensitiveBean override = new SensitiveBean(initialCode, beginIndex, endIndex, cover);
        return override.getMaskSubWay();
    }

    public static String getMaskCharWay(String initialCode, int beginIndex, int endIndex, char cover) {
        SensitiveBean override = new SensitiveBean(initialCode, beginIndex, endIndex, cover);
        return override.getMaskCharWay();
    }

    public static String getMaskCharWay(String initialCode, int beginIndex, int endIndex) {
        SensitiveBean override = new SensitiveBean(initialCode, beginIndex, endIndex);
        return override.getMaskCharWay();
    }

    public String getMaskSubWay() {
        return null != this.initialCode && !"".equals(this.initialCode) && !"null".equals(this.initialCode) ? this.initialCode.substring(0, this.beginIndex - 1) + cover(this.beginIndex, this.endIndex, this.cover) + this.initialCode.substring(this.endIndex, this.initialCode.length()) : "";
    }

    public String getMaskCharWay() {
        if (null != this.initialCode && !"".equals(this.initialCode) && !"null".equals(this.initialCode)) {
            char[] chars = this.initialCode.toCharArray();
            char[] tempBegin = new char[this.beginIndex - 1];
            char[] tempEnd = new char[this.initialCode.length() - this.endIndex];

            int varEnd;
            for(varEnd = 0; varEnd < tempBegin.length; ++varEnd) {
                tempBegin[varEnd] = chars[varEnd];
            }

            for(varEnd = 0; varEnd < tempEnd.length; ++varEnd) {
                tempEnd[varEnd] = chars[this.endIndex + varEnd];
            }

            return new String(tempBegin) + cover(this.beginIndex, this.endIndex, this.cover) + new String(tempEnd);
        } else {
            return "";
        }
    }

    private static String cover(int beginIndex, int endIndex, char cover) {
        if (beginIndex >= 0 && endIndex >= 0) {
            if (beginIndex > endIndex) {
                beginIndex ^= endIndex;
                endIndex ^= beginIndex;
                beginIndex ^= endIndex;
            }

            if (endIndex - beginIndex < cache.length && cover == '*') {
                return cache[endIndex - beginIndex];
            } else {
                StringBuilder sb;
                for(sb = new StringBuilder(endIndex - beginIndex); beginIndex <= endIndex; ++beginIndex) {
                    sb.append(cover);
                }

                return sb.toString();
            }
        } else {
            return "";
        }
    }

    public static String[] getCache() {
        return cache;
    }

    public static char getCoverDefault() {
        return '*';
    }

    public String getInitialCode() {
        return this.initialCode;
    }

    public void setInitialCode(String initialCode) {
        this.initialCode = initialCode;
    }

    public int getBeginIndex() {
        return this.beginIndex;
    }

    public void setBeginIndex(int beginIndex) {
        this.beginIndex = beginIndex;
    }

    public int getEndIndex() {
        return this.endIndex;
    }

    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public char getCover() {
        return this.cover;
    }

    public void setCover(char cover) {
        this.cover = cover;
    }