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

编程入门行业动态更新时间:2024-10-09 12:26:13

自定义@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，属性名作为valuemap.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;
}