其实这是上一篇《SpringBoot 采用JsonSerializer和Aop 实现可控制的数据脱敏》的后续改进 对只针对脱敏场景来说，上一篇的流程有点繁琐，需要多余继承一个开关类其实很鸡肋
后面思考决定把开关类和序列化器一并拔除，这样后续在使用时只需要关注，脱敏点和脱敏字段即可，不需要再进行多余的类继承，也不需要进行序列器进行多余的参与
对于上一篇内容，删除了开关类，序列化的处理步骤，删除了字段注解的Jackson部分
字段注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})//作用于字段上
public @interface PrivacyEncrypt {
/**
* 脱敏数据类型, 非Customer时, 将忽略 refixNoMaskLen 和 suffixNoMaskLen 和 maskStr
*/
PrivacyTypeEnum type() default PrivacyTypeEnum.CUSTOMER;
/**
* 前置不需要打码的长度
*/
int prefixNoMaskLen() default 0;
/**
* 后置不需要打码的长度
*/
int suffixNoMaskLen() default 0;
/**
* 用什么打码
*/
String maskStr() default "*";
}
aop部分
@Component
@Aspect
public class PrivacyKeyAspect {
public static final Logger logger = LoggerFactory.getLogger(PrivacyKeyAspect.class);
/**
* @Description: 环绕通知包含此注解的
* @param: ProceedingJoinPoint joinPoint
* @return: Object
*/
@Around(value = "@annotation(PrivacyKeyAnnotation注解类路径地址)")
public Object repeatSub(ProceedingJoinPoint joinPoint) throws Throwable {
return joinPoint.proceed();
}
/**
* @Description: 后置通知
*/
@AfterReturning(value = "@annotation(PrivacyKeyAnnotation注解类路径地址)",returning = "result")
public void setPrivacyKeyType(JoinPoint joinPoint, Object result) throws Throwable {
//进行注解 值获取
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
//是否开启脱敏
boolean flag = method.getDeclaredAnnotation(PrivacyKeyAnnotation.class).isKey();
//是否对分页进行脱敏
boolean status = method.getDeclaredAnnotation(PrivacyKeyAnnotation.class).isPageKey();
if (!status) {
//进行返回值反射
//进行单值返回
Class<?> aClass = result.getClass();
if (null != aClass){
//对象属性修改
setFieldMethod(result, flag, aClass);
}
} else {
//反射分页page
//反射list类型
Parameter[] parameters = signature.getMethod().getParameters();
//泛型名称
String name = parameters[0].getName();
//泛型class
Class<?> type = parameters[0].getType();
//包名
String typeName = type.getName();
PropertyDescriptor[] ps = Introspector.getBeanInfo(result.getClass(), Object.class).getPropertyDescriptors();
for (PropertyDescriptor prop : ps) {
//prop.getPropertyType() == List.class
if (prop.getPropertyType().isAssignableFrom(List.class)) { //List 集合类型
Object obj = result.getClass().getMethod(prop.getReadMethod().getName()).invoke(result);
if(obj !=null){
List<?> listObj = (List<?>) obj;
for (Object next : listObj) {
Class<?> classObj = Class.forName(typeName);
//进属性修改
setFieldMethod(next,flag,classObj);
}
}
}
}
}
}
/**
* 内容填充
*/
private void setFieldMethod(Object result, boolean flag, Class<?> aClass) throws IllegalAccessException {
List<Field> fieldList = getFieldList(aClass);
//循环遍历
for (Field field : fieldList) {
field.setAccessible(true); // 设置属性可访问
// 获取指定类型的注解
PrivacyEncrypt myAnnotation = field.getDeclaredAnnotation(PrivacyEncrypt.class);
if (myAnnotation != null) {
//进行数据处理
int intSuf = myAnnotation.suffixNoMaskLen();
int intPre = myAnnotation.prefixNoMaskLen();
String maskStr = myAnnotation.maskStr();
PrivacyTypeEnum type = myAnnotation.type();
Object obj = field.get(result);
//返回脱敏的值
Object str = setPrivacyInfo(type,obj,intSuf,intPre,maskStr);
field.set(result,str);
}
}
}
//判断脱敏内容 返回脱敏值
private Object setPrivacyInfo(PrivacyTypeEnum type, Object obj, int intSuf, int intPre, String maskStr) {
Object newObj = null;
if (obj !=null && null != type) {
switch (type) {
case CHINESE_NAME:
newObj = DesensitizedUtils.chineseName((String) obj);
break;
case ID_CARD:
newObj = DesensitizedUtils.idCardNum((String) obj);
break;
case FIXED_PHONE:
newObj = DesensitizedUtils.fixedPhone((String) obj);
break;
case MOBILE_PHONE:
newObj = DesensitizedUtils.mobilePhone((String) obj);
break;
case ADDRESS:
newObj = DesensitizedUtils.address((String) obj);
break;
case EMAIL:
newObj = DesensitizedUtils.email((String) obj);
break;
case BANK_CARD:
newObj = DesensitizedUtils.bankCard((String) obj);
break;
case PASSWORD:
newObj = DesensitizedUtils.password((String) obj);
break;
case KEY:
newObj = DesensitizedUtils.key((String) obj);
break;
case CUSTOMER://自定义脱敏
newObj = DesensitizedUtils.desValue((String) obj, intPre, intSuf, maskStr);
break;
default:
throw new IllegalArgumentException("Unknow sensitive type enum " + type);
}
return newObj;
}else {
return obj;
}
}
//递归查询对象字段属性
private List<Field> getFieldList(Class<?> clazz){
if(null == clazz){
return null;
}
List<Field> fieldList = new ArrayList<>();
//递归查找
while (clazz!=null){
Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields) {
if (field != null){
//设置属性的可访问性
field.setAccessible(true);
//过滤静态
if(Modifier.isStatic(field.getModifiers())){
continue;
}
//添加字段
fieldList.add(field);
}
}
clazz = clazz.getSuperclass();
}
return fieldList;
}
}
aop脱敏点注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})//作用于方法上
public @interface PrivacyKeyAnnotation {
/**
* 是否启用序列化脱敏 默认开启
*/
boolean isKey() default true;
/**
* 是否为PageInfo<?>(分页对象)
*/
boolean isPageKey() default false;
}
脱敏工具类
/**
* 脱敏工具类
*
**/
public class DesensitizedUtils {
/**
* 对字符串进行脱敏操作
* @param origin 原始字符串
* @param prefixNoMaskLen 左侧需要保留几位明文字段
* @param suffixNoMaskLen 右侧需要保留几位明文字段
* @param maskStr 用于遮罩的字符串, 如'*'
* @return 脱敏后结果
*/
public static String desValue(String origin, int prefixNoMaskLen, int suffixNoMaskLen, String maskStr) {
if (origin == null) {
return null;
}
StringBuilder sb = new StringBuilder();
for (int i = 0, n = origin.length(); i < n; i++) {
if (i < prefixNoMaskLen) {
sb.append(origin.charAt(i));
continue;
}
if (i > (n - suffixNoMaskLen - 1)) {
sb.append(origin.charAt(i));
continue;
}
sb.append(maskStr);
}
return sb.toString();
}
/**
* 【中文姓名】只显示最后一个汉字，其他隐藏为星号，比如：**梦
* @param fullName 姓名
* @return 结果
*/
public static String chineseName(String fullName) {
if (fullName == null) {
return null;
}
return desValue(fullName, 0, 1, "*");
}
/**
* 【身份证号】显示前六位, 四位，其他隐藏。共计18位或者15位，比如：340304*******1234
* @param id 身份证号码
* @return 结果
*/
public static String idCardNum(String id) {
return desValue(id, 6, 4, "*");
}
/**
* 【固定电话】后四位，其他隐藏，比如 ****1234
* @param num 固定电话
* @return 结果
*/
public static String fixedPhone(String num) {
return desValue(num, 0, 4, "*");
}
/**
* 【手机号码】前三位，后四位，其他隐藏，比如135****6810
* @param num 手机号码
* @return 结果
*/
public static String mobilePhone(String num) {
return desValue(num, 3, 4, "*");
}
/**
* 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
* @param address 地址
* @return 结果
*/
public static String address(String address) {
return desValue(address, 6, 0, "*");
}
/**
* 【电子邮箱 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
* @param email 电子邮箱
* @return 结果
*/
public static String email(String email) {
return email.replaceAll("(\w?)(\w+)(\w)(@\w+\.[a-z]+(\.[a-z]+)?)", "$1****$3$4");
}
/**
* 【银行卡号】前六位，后四位，其他用星号隐藏每位1个星号，比如：622260**********1234
* @param cardNum 银行卡号
* @return 结果
*/
public static String bankCard(String cardNum) {
return desValue(cardNum, 6, 4, "*");
}
/**
* 【密码】密码的全部字符都用*代替，比如：******
* @param password 密码
* @return 结果
*/
public static String password(String password) {
if (password == null) {
return null;
}
return "******";
}
/**
* 【密钥】密钥除了最后三位，全部都用*代替，比如：***xdS 脱敏后长度为6，如果明文长度不足三位，则按实际长度显示，剩余位置补*
* @param key 密钥
* @return 结果
*/
public static String key(String key) {
if (key == null) {
return null;
}
int viewLength = 6;
StringBuilder tmpKey = new StringBuilder(desValue(key, 0, 3, "*"));
if (tmpKey.length() > viewLength) {
return tmpKey.substring(tmpKey.length() - viewLength);
}
else if (tmpKey.length() < viewLength) {
int buffLength = viewLength - tmpKey.length();
for (int i = 0; i < buffLength; i++) {
tmpKey.insert(0, "*");
}
return tmpKey.toString();
}
else {
return tmpKey.toString();
}
}
}
脱敏枚举类
/**
* 敏感信息枚举类
*
**/
public enum PrivacyTypeEnum {
/**
* 自定义
*/
CUSTOMER,
/**
* 用户名, 张*三, 李*
*/
CHINESE_NAME,
/**
* 身份证号, 110110********1234
*/
ID_CARD,
/**
* 座机号, ****1234
*/
FIXED_PHONE,
/**
* 手机号, 176****1234
*/
MOBILE_PHONE,
/**
* 地址, 北京********
*/
ADDRESS,
/**
* 电子邮件, s*****o@xx.com
*/
EMAIL,
/**
* 银行卡, 622202************1234
*/
BANK_CARD,
/**
* 密码, 永远是 ******, 与长度无关
*/
PASSWORD,
/**
* 密钥, 永远是 ******, 与长度无关
*/
KEY
}
这里实现的结果和上一篇是一样的，并且速度挺高的（没使用多余的序列化可不呗）
