起因
最近在写一个功能，对用户敏感的数据进行脱敏，在网上看一圈基本上都是全局范围的，我觉得应该更加灵活，在不同场景，不同业务下进行脱敏更加合适。
JsonSerializer介绍就参考这位大佬的
aop介绍参考这位大佬的
初步尝试
枚举类
/**
- 敏感信息枚举类
*
**/
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
}
复制代码
注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})//作用于字段上
@JacksonAnnotationsInside // 表示自定义自己的注解PrivacyEncrypt
@JsonSerialize(using = PrivacySerialize.class)// 该注解使用序列化的方式
public @interface PrivacyEncrypt {
/**
* 脱敏数据类型, 非Customer时, 将忽略 refixNoMaskLen 和 suffixNoMaskLen 和 maskStr
*/PrivacyTypeEnum type() default PrivacyTypeEnum.CUSTOMER;
/**
* 前置不需要打码的长度
*/int prefixNoMaskLen() default 0;
/**
* 后置不需要打码的长度
*/int suffixNoMaskLen() default 0;
/**
* 用什么打码
*/String maskStr() default "*";
}
复制代码
序列化类
public class PrivacySerialize extends JsonSerializer implements ContextualSerializer {
public static final Logger logger = LoggerFactory.getLogger(PrivacySerialize.class);
private PrivacyTypeEnum type;
private Integer prefixNoMaskLen;
private Integer suffixNoMaskLen;
private String maskStr;
public PrivacySerialize(PrivacyTypeEnum type, Integer prefixNoMaskLen, Integer suffixNoMaskLen, String maskStr) {
this.type = type;
this.prefixNoMaskLen = prefixNoMaskLen;
this.suffixNoMaskLen = suffixNoMaskLen;
this.maskStr = maskStr;}
public PrivacySerialize() {
}
@Override
public void serialize(String origin,JsonGenerator jsonGenerator,SerializerProvider serializerProvider) throws IOException {
if (StringUtils.isNotBlank(origin) && null != type) {
switch (type) {
case CHINESE_NAME:
jsonGenerator.writeString(DesensitizedUtils.chineseName(origin));
break;
case ID_CARD:
jsonGenerator.writeString(DesensitizedUtils.idCardNum(origin));
break;
case FIXED_PHONE:
jsonGenerator.writeString(DesensitizedUtils.fixedPhone(origin));
break;
case MOBILE_PHONE:
jsonGenerator.writeString(DesensitizedUtils.mobilePhone(origin));
break;
case ADDRESS:
jsonGenerator.writeString(DesensitizedUtils.address(origin));
break;
case EMAIL:
jsonGenerator.writeString(DesensitizedUtils.email(origin));
break;
case BANK_CARD:
jsonGenerator.writeString(DesensitizedUtils.bankCard(origin));
break;
case PASSWORD:
jsonGenerator.writeString(DesensitizedUtils.password(origin));
break;
case KEY:
jsonGenerator.writeString(DesensitizedUtils.key(origin));
break;
case CUSTOMER:
jsonGenerator.writeString(DesensitizedUtils.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, maskStr));
break;
default:
throw new IllegalArgumentException("Unknow sensitive type enum " + type);
}
}else {
jsonGenerator.writeString("");
}
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider serializerProvider,BeanProperty beanProperty) throws JsonMappingException {
if (beanProperty != null) {
if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
PrivacyEncrypt encrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
if (encrypt == null) {
encrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
}
if (encrypt != null) {
return new PrivacySerialize(encrypt.type(), encrypt.prefixNoMaskLen(),
encrypt.suffixNoMaskLen(), encrypt.maskStr());
}
}
return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
}
return serializerProvider.findNullValueSerializer(null);}
}
复制代码
脱敏工具类
/**
- 脱敏工具类
*
**/
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 class DataMaskKey implements Serializable {
//不进行序列化,设置key 来进行过滤的把控，默认不开启
private transient Boolean isPrivacyKey = false;
public Boolean getPrivacyKey() {
return isPrivacyKey;
}
public void setPrivacyKey(Boolean privacyKey) {
isPrivacyKey = privacyKey;
}}
复制代码
更新之后的序列化类
思路就是通过反射获取，该成员的属性，因为不知道会继承多少，所以要进行递归查找需要的字段
public class PrivacySerialize extends JsonSerializer implements ContextualSerializer {
public static final Logger logger = LoggerFactory.getLogger(PrivacySerialize.class);
private PrivacyTypeEnum type;
private Integer prefixNoMaskLen;
private Integer suffixNoMaskLen;
private String maskStr;
public PrivacySerialize(PrivacyTypeEnum type, Integer prefixNoMaskLen, Integer suffixNoMaskLen, String maskStr) {
this.type = type;
this.prefixNoMaskLen = prefixNoMaskLen;
this.suffixNoMaskLen = suffixNoMaskLen;
this.maskStr = maskStr;}
public PrivacySerialize() {
}
@Override
public void serialize(String origin,JsonGenerator jsonGenerator,SerializerProvider serializerProvider) throws IOException {
boolean flag = false;
//反射获取对象
Object currentValue = jsonGenerator.getOutputContext().getCurrentValue();
//反射获取class
Class<?> aClass = jsonGenerator.getOutputContext().getCurrentValue().getClass();
List<Field> fieldList = getFieldList(aClass);
for (Field field : fieldList) {
//开始反射获取
String name = field.getName();
if ("isPrivacyKey".equals(name)){
try {
//进行重新赋值
flag = (boolean) field.get(currentValue);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
//反射进行 进行开关判定
if (flag){
//logger.info("进行脱敏处理");
if (StringUtils.isNotBlank(origin) && null != type) {
switch (type) {
case CHINESE_NAME:
jsonGenerator.writeString(DesensitizedUtils.chineseName(origin));
break;
case ID_CARD:
jsonGenerator.writeString(DesensitizedUtils.idCardNum(origin));
break;
case FIXED_PHONE:
jsonGenerator.writeString(DesensitizedUtils.fixedPhone(origin));
break;
case MOBILE_PHONE:
jsonGenerator.writeString(DesensitizedUtils.mobilePhone(origin));
break;
case ADDRESS:
jsonGenerator.writeString(DesensitizedUtils.address(origin));
break;
case EMAIL:
jsonGenerator.writeString(DesensitizedUtils.email(origin));
break;
case BANK_CARD:
jsonGenerator.writeString(DesensitizedUtils.bankCard(origin));
break;
case PASSWORD:
jsonGenerator.writeString(DesensitizedUtils.password(origin));
break;
case KEY:
jsonGenerator.writeString(DesensitizedUtils.key(origin));
break;
case CUSTOMER:
jsonGenerator.writeString(DesensitizedUtils.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, maskStr));
break;
default:
throw new IllegalArgumentException("Unknow sensitive type enum " + type);
}
}else {
jsonGenerator.writeString("");
}
}else {
//logger.info("不进行脱敏处理");
jsonGenerator.writeString(origin);
}
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider serializerProvider,BeanProperty beanProperty) throws JsonMappingException {
if (beanProperty != null) {
if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
PrivacyEncrypt encrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
if (encrypt == null) {
encrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
}
if (encrypt != null) {
return new PrivacySerialize(encrypt.type(), encrypt.prefixNoMaskLen(),
encrypt.suffixNoMaskLen(), encrypt.maskStr());
}
}
return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
}
return serializerProvider.findNullValueSerializer(null);}
private List getFieldList(Class<?> clazz){
if(null == clazz){
return null;
}
List<Field> fieldList = new ArrayList<>();
//递归查找 需求 的字段
Class<?> aClass = ClassRecursionUtils.getClass(clazz, "isPrivacyKey");
Field[] declaredFields = aClass.getDeclaredFields();
for (Field field : declaredFields) {
if (field != null){
//设置属性的可访问性
field.setAccessible(true);
//过滤静态
if(Modifier.isStatic(field.getModifiers())){
continue;
}
String name = field.getName();
//过滤非布尔类型
Class<?> type = field.getType();
//并且只添加 isPrivacyKey
if (type.isAssignableFrom(Boolean.class) && "isPrivacyKey".equals(name)){
fieldList.add(field);
}
}
}
return fieldList;}
}
复制代码
递归工具类
public class ClassRecursionUtils {
public static Class<?> getClass(Class<?> c, String fieldName) {
if (c !=null && !hasField(c, fieldName)) {
return getClass(c.getSuperclass(), fieldName);
}
return c;
}
public static boolean hasField(Class<?> c, String fieldName){
Field[] fields = c.getDeclaredFields();
for (Field f : fields) {
if (fieldName.equals(f.getName())) {
return true;
}
}
return false;
}}
复制代码
现在只需要在进行实体类 封装数据时，在进行手动set即可
最终方案
在上述情况下可以实现 手动控制是否在某些场景下的脱敏，但是需要对原来的代码进行修改，我觉得不友好，所以采用aop的形式进行控制
项目的返回类型基本上为两种
实体类作为返回
分页返回
aop注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})//作用于方法上
public @interface PrivacyKeyAnnotation {
/**
* 是否启用序列化脱敏 默认开启
*/
boolean isKey() default true;
/**
* 是否为PageInfo<?>(分页对象)
*/
boolean isPageKey() default false;}
复制代码
aop类
@Component
@Aspect
public class PrivacyKeyAspect {
public static final Logger logger = LoggerFactory.getLogger(PrivacyKeyAspect.class);
/**
* @Description: 环绕通知包含此注解的
* @param: ProceedingJoinPoint joinPoint
* @return: Object
*/
@Around(value = "@annotation("aop注解地址xxxxx")")
public Object repeatSub(ProceedingJoinPoint joinPoint) throws Throwable {
return joinPoint.proceed();
}
/**
* @Description: 后置通知
*/
@AfterReturning(value = "@annotation("aop注解地址")",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 = ClassRecursionUtils.getClass(result.getClass(), "isPrivacyKey");
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) {
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);
//获取成员变量
Class<?> keyClass = ClassRecursionUtils.getClass(classObj, "isPrivacyKey");
setFieldMethod(next, flag, keyClass);
}
}
}
}
}
}
/**
* 内容填充
*/
private void setFieldMethod(Object result, boolean flag, Class<?> aClass) throws IllegalAccessException {
Field[] declaredFields = aClass.getDeclaredFields();
for (Field field : declaredFields) {
//设置属性的可访问性
field.setAccessible(true);
//只获取isPrivacyKey
String name = field.getName();
//过滤非布尔类型
Class<?> type = field.getType();
//并且只添加 isPrivacyKey
if (type.isAssignableFrom(Boolean.class) && "isPrivacyKey".equals(name)){
//重新写入
field.set(result,flag);
}
}
}}
复制代码
使用
在service implement类方法上写入
