实际开发中，敏感数据脱敏几乎是必修课。但多数现成方案都是全局一刀切，只要字段标了注解，所有返回场景都会被脱敏。这样虽然省事，可真遇到“列表页要脱敏、详情页要完整”这类需求时，就很难应付了。
于是就想折腾一套更灵活的实现：既能享受 JsonSerializer 的便利，又能借助 AOP 在需要的时候打开或关上脱敏开关。
起因
最近在写一个 Spring Boot 功能时，需要对用户敏感数据进行脱敏。网上的方案看了一圈，基本都是全局范围的；但我更希望不同场景、不同业务下能分别控制，而不是一刀切。
JsonSerializer 的介绍可以参考这位大佬的文章：
https://juejin.cn/post/6872636051237240846
AOP 的介绍可以参考这位大佬的文章：
https://juejin.cn/post/6844903575441637390
初步尝试
先定义一个敏感信息枚举类：
/**
* 敏感信息枚举类
*
*/
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<String> 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<String> 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<Field> 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 实现类的方法上加上注解即可。
另外，另一种实现方式也可以参考：
https://juejin.cn/post/7242145254057410615
整体来看，这套方案把“要不要脱敏”的控制权从实体类中解耦出来，改由注解在方法维度决定。配合 JsonSerializer 和 AOP，既能灵活适配不同场景，又不用在每个调用点都手动设置开关，实际用起来省心不少。
发表于 昨天 23:12
|
查看: 6|
回复: 0
