SpringBoot采用JsonSerializer和Aop实现可控制的数据脱敏

---

1 起因

最近在写一个功能，对用户敏感的数据进行脱敏，在网上看一圈基本上都是全局范围的，我觉得应该更加灵活，在不同场景，不同业务下进行脱敏更加合适。

JsonSerializer介绍就参考这位大佬的

https://juejin.cn/post/6872636051237240846

aop介绍参考这位大佬的

https://juejin.cn/post/6844903575441637390

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

• 项目地址：https://github.com/YunaiV/ruoyi-vue-pro
• 视频教程：https://doc.iocoder.cn/video/

2 初步尝试

枚举类

/**
*敏感信息枚举类
*
**/
publicenumPrivacyTypeEnum{

/**
*自定义
*/
CUSTOMER,
/**
*用户名,张*三,李*
*/
CHINESE_NAME,
/**
*身份证号,110110********1234
*/
ID_CARD,
/**
*座机号,****1234
*/
FIXED_PHONE,
/**
*手机号,176****1234
*/
MOBILE_PHONE,
/**
*地址,北京********
*/
ADDRESS,
/**
*电子邮件,s*****[e-mail]
*/
EMAIL,
/**
*银行卡,622202************1234
*/
BANK_CARD,
/**
*密码,永远是******,与长度无关
*/
PASSWORD,
/**
*密钥,永远是******,与长度无关
*/
KEY

}

注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})//作用于字段上
@JacksonAnnotationsInside//表示自定义自己的注解PrivacyEncrypt
@JsonSerialize(using=PrivacySerialize.class)//该注解使用序列化的方式
public@interfacePrivacyEncrypt{

/**
*脱敏数据类型,非Customer时,将忽略refixNoMaskLen和suffixNoMaskLen和maskStr
*/
PrivacyTypeEnumtype()defaultPrivacyTypeEnum.CUSTOMER;

/**
*前置不需要打码的长度
*/
intprefixNoMaskLen()default0;

/**
*后置不需要打码的长度
*/
intsuffixNoMaskLen()default0;

/**
*用什么打码
*/
StringmaskStr()default"*";

}

序列化类

publicclassPrivacySerializeextendsJsonSerializer<String>implementsContextualSerializer{
publicstaticfinalLoggerlogger=LoggerFactory.getLogger(PrivacySerialize.class);
privatePrivacyTypeEnumtype;

privateIntegerprefixNoMaskLen;

privateIntegersuffixNoMaskLen;

privateStringmaskStr;

publicPrivacySerialize(PrivacyTypeEnumtype,IntegerprefixNoMaskLen,IntegersuffixNoMaskLen,StringmaskStr){
this.type=type;
this.prefixNoMaskLen=prefixNoMaskLen;
this.suffixNoMaskLen=suffixNoMaskLen;
this.maskStr=maskStr;
}
publicPrivacySerialize(){
}

@Override
publicvoidserialize(Stringorigin,JsonGeneratorjsonGenerator,SerializerProviderserializerProvider)throwsIOException{
if(StringUtils.isNotBlank(origin)&&null!=type){
switch(type){
caseCHINESE_NAME:
jsonGenerator.writeString(DesensitizedUtils.chineseName(origin));
break;
caseID_CARD:
jsonGenerator.writeString(DesensitizedUtils.idCardNum(origin));
break;
caseFIXED_PHONE:
jsonGenerator.writeString(DesensitizedUtils.fixedPhone(origin));
break;
caseMOBILE_PHONE:
jsonGenerator.writeString(DesensitizedUtils.mobilePhone(origin));
break;
caseADDRESS:
jsonGenerator.writeString(DesensitizedUtils.address(origin));
break;
caseEMAIL:
jsonGenerator.writeString(DesensitizedUtils.email(origin));
break;
caseBANK_CARD:
jsonGenerator.writeString(DesensitizedUtils.bankCard(origin));
break;
casePASSWORD:
jsonGenerator.writeString(DesensitizedUtils.password(origin));
break;
caseKEY:
jsonGenerator.writeString(DesensitizedUtils.key(origin));
break;
caseCUSTOMER:
jsonGenerator.writeString(DesensitizedUtils.desValue(origin,prefixNoMaskLen,suffixNoMaskLen,maskStr));
break;
default:
thrownewIllegalArgumentException("Unknowsensitivetypeenum"+type);
}
}else{
jsonGenerator.writeString("");
}

}

@Override
publicJsonSerializercreateContextual(SerializerProviderserializerProvider,BeanPropertybeanProperty)throwsJsonMappingException{
if(beanProperty!=null){
if(Objects.equals(beanProperty.getType().getRawClass(),String.class)){
PrivacyEncryptencrypt=beanProperty.getAnnotation(PrivacyEncrypt.class);
if(encrypt==null){
encrypt=beanProperty.getContextAnnotation(PrivacyEncrypt.class);
}
if(encrypt!=null){
returnnewPrivacySerialize(encrypt.type(),encrypt.prefixNoMaskLen(),
encrypt.suffixNoMaskLen(),encrypt.maskStr());
}
}
returnserializerProvider.findValueSerializer(beanProperty.getType(),beanProperty);
}
returnserializerProvider.findNullValueSerializer(null);
}
}

脱敏工具类

/**
*脱敏工具类
*
**/
publicclassDesensitizedUtils{

/**
*对字符串进行脱敏操作
*@paramorigin原始字符串
*@paramprefixNoMaskLen左侧需要保留几位明文字段
*@paramsuffixNoMaskLen右侧需要保留几位明文字段
*@parammaskStr用于遮罩的字符串,如'*'
*@return脱敏后结果
*/
publicstaticStringdesValue(Stringorigin,intprefixNoMaskLen,intsuffixNoMaskLen,StringmaskStr){
if(origin==null){
returnnull;
}

StringBuildersb=newStringBuilder();
for(inti=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);
}
returnsb.toString();
}

/**
*【中文姓名】只显示最后一个汉字，其他隐藏为星号，比如：**梦
*@paramfullName姓名
*@return结果
*/
publicstaticStringchineseName(StringfullName){
if(fullName==null){
returnnull;
}
returndesValue(fullName,0,1,"*");
}

/**
*【身份证号】显示前六位,四位，其他隐藏。共计18位或者15位，比如：340304*******1234
*@paramid身份证号码
*@return结果
*/
publicstaticStringidCardNum(Stringid){
returndesValue(id,6,4,"*");
}

/**
*【固定电话】后四位，其他隐藏，比如****1234
*@paramnum固定电话
*@return结果
*/
publicstaticStringfixedPhone(Stringnum){
returndesValue(num,0,4,"*");
}

/**
*【手机号码】前三位，后四位，其他隐藏，比如135****6810
*@paramnum手机号码
*@return结果
*/
publicstaticStringmobilePhone(Stringnum){
returndesValue(num,3,4,"*");
}

/**
*【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
*@paramaddress地址
*@return结果
*/
publicstaticStringaddress(Stringaddress){
returndesValue(address,6,0,"*");
}

/**
*【电子邮箱邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
*@paramemail电子邮箱
*@return结果
*/
publicstaticStringemail(Stringemail){
returnemail.replaceAll("(w?)(w+)(w)(@w+.[a-z]+(.[a-z]+)?)","$1****$3$4");

}

/**
*【银行卡号】前六位，后四位，其他用星号隐藏每位1个星号，比如：622260**********1234
*@paramcardNum银行卡号
*@return结果
*/
publicstaticStringbankCard(StringcardNum){
returndesValue(cardNum,6,4,"*");
}

/**
*【密码】密码的全部字符都用*代替，比如：******
*@parampassword密码
*@return结果
*/
publicstaticStringpassword(Stringpassword){
if(password==null){
returnnull;
}
return"******";
}

/**
*【密钥】密钥除了最后三位，全部都用*代替，比如：***xdS脱敏后长度为6，如果明文长度不足三位，则按实际长度显示，剩余位置补*
*@paramkey密钥
*@return结果
*/
publicstaticStringkey(Stringkey){
if(key==null){
returnnull;
}
intviewLength=6;
StringBuildertmpKey=newStringBuilder(desValue(key,0,3,"*"));
if(tmpKey.length()>viewLength){
returntmpKey.substring(tmpKey.length()-viewLength);
}
elseif(tmpKey.length()< viewLength) {
         intbuffLength=viewLength-tmpKey.length();
for(inti=0;i< buffLength; i++) {
            tmpKey.insert(0,"*");
}
returntmpKey.toString();
}
else{
returntmpKey.toString();
}
}

}

注解使用

的确实现了数据脱敏，但是有个问题现在的脱敏针对的是 只要对该实体类进行了使用返回的接口，中的数据都会进行脱敏，在有些场景下是不需要的，所以说要进行改进。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

• 项目地址：https://github.com/YunaiV/yudao-cloud
• 视频教程：https://doc.iocoder.cn/video/

3 第二版改进

我的思路是在该实体类中在继承一个 父类其中定义一个字段，使其作为是否进行脱敏的开关，并且该实体类字段不参与序列化 脱敏控制类

publicclassDataMaskKeyimplementsSerializable{
//不进行序列化,设置key来进行过滤的把控，默认不开启
privatetransientBooleanisPrivacyKey=false;

publicBooleangetPrivacyKey(){
returnisPrivacyKey;
}

publicvoidsetPrivacyKey(BooleanprivacyKey){
isPrivacyKey=privacyKey;
}
}

更新之后的序列化类

思路就是通过反射获取，该成员的属性，因为不知道会继承多少，所以要进行递归查找需要的字段

publicclassPrivacySerializeextendsJsonSerializer<String>implementsContextualSerializer{
publicstaticfinalLoggerlogger=LoggerFactory.getLogger(PrivacySerialize.class);
privatePrivacyTypeEnumtype;

privateIntegerprefixNoMaskLen;

privateIntegersuffixNoMaskLen;

privateStringmaskStr;

publicPrivacySerialize(PrivacyTypeEnumtype,IntegerprefixNoMaskLen,IntegersuffixNoMaskLen,StringmaskStr){
this.type=type;
this.prefixNoMaskLen=prefixNoMaskLen;
this.suffixNoMaskLen=suffixNoMaskLen;
this.maskStr=maskStr;
}
publicPrivacySerialize(){
}

@Override
publicvoidserialize(Stringorigin,JsonGeneratorjsonGenerator,SerializerProviderserializerProvider)throwsIOException{
booleanflag=false;
//反射获取对象
ObjectcurrentValue=jsonGenerator.getOutputContext().getCurrentValue();
//反射获取class
ClassaClass=jsonGenerator.getOutputContext().getCurrentValue().getClass();
ListfieldList=getFieldList(aClass);
for(Fieldfield:fieldList){
//开始反射获取
Stringname=field.getName();
if("isPrivacyKey".equals(name)){
try{
//进行重新赋值
flag=(boolean)field.get(currentValue);
}catch(IllegalAccessExceptione){
e.printStackTrace();
}
}
}
//反射进行进行开关判定
if(flag){
//logger.info("进行脱敏处理");
if(StringUtils.isNotBlank(origin)&&null!=type){
switch(type){
caseCHINESE_NAME:
jsonGenerator.writeString(DesensitizedUtils.chineseName(origin));
break;
caseID_CARD:
jsonGenerator.writeString(DesensitizedUtils.idCardNum(origin));
break;
caseFIXED_PHONE:
jsonGenerator.writeString(DesensitizedUtils.fixedPhone(origin));
break;
caseMOBILE_PHONE:
jsonGenerator.writeString(DesensitizedUtils.mobilePhone(origin));
break;
caseADDRESS:
jsonGenerator.writeString(DesensitizedUtils.address(origin));
break;
caseEMAIL:
jsonGenerator.writeString(DesensitizedUtils.email(origin));
break;
caseBANK_CARD:
jsonGenerator.writeString(DesensitizedUtils.bankCard(origin));
break;
casePASSWORD:
jsonGenerator.writeString(DesensitizedUtils.password(origin));
break;
caseKEY:
jsonGenerator.writeString(DesensitizedUtils.key(origin));
break;
caseCUSTOMER:
jsonGenerator.writeString(DesensitizedUtils.desValue(origin,prefixNoMaskLen,suffixNoMaskLen,maskStr));
break;
default:
thrownewIllegalArgumentException("Unknowsensitivetypeenum"+type);
}
}else{
jsonGenerator.writeString("");
}
}else{
//logger.info("不进行脱敏处理");
jsonGenerator.writeString(origin);
}

}

@Override
publicJsonSerializercreateContextual(SerializerProviderserializerProvider,BeanPropertybeanProperty)throwsJsonMappingException{
if(beanProperty!=null){
if(Objects.equals(beanProperty.getType().getRawClass(),String.class)){
PrivacyEncryptencrypt=beanProperty.getAnnotation(PrivacyEncrypt.class);
if(encrypt==null){
encrypt=beanProperty.getContextAnnotation(PrivacyEncrypt.class);
}
if(encrypt!=null){
returnnewPrivacySerialize(encrypt.type(),encrypt.prefixNoMaskLen(),
encrypt.suffixNoMaskLen(),encrypt.maskStr());
}
}
returnserializerProvider.findValueSerializer(beanProperty.getType(),beanProperty);
}
returnserializerProvider.findNullValueSerializer(null);
}

privateListgetFieldList(Classclazz){
if(null==clazz){
returnnull;
}
ListfieldList=newArrayList<>();
//递归查找需求的字段
ClassaClass=ClassRecursionUtils.getClass(clazz,"isPrivacyKey");
Field[]declaredFields=aClass.getDeclaredFields();
for(Fieldfield:declaredFields){
if(field!=null){
//设置属性的可访问性
field.setAccessible(true);
//过滤静态
if(Modifier.isStatic(field.getModifiers())){
continue;
}
Stringname=field.getName();
//过滤非布尔类型
Classtype=field.getType();
//并且只添加isPrivacyKey
if(type.isAssignableFrom(Boolean.class)&&"isPrivacyKey".equals(name)){
fieldList.add(field);
}
}
}
returnfieldList;
}

}

递归工具类

publicclassClassRecursionUtils{
publicstaticClassgetClass(Classc,StringfieldName){
if(c!=null&&!hasField(c,fieldName)){
returngetClass(c.getSuperclass(),fieldName);
}
returnc;
}

publicstaticbooleanhasField(Classc,StringfieldName){
Field[]fields=c.getDeclaredFields();
for(Fieldf:fields){
if(fieldName.equals(f.getName())){
returntrue;
}
}
returnfalse;
}
}

现在只需要在进行实体类 封装数据时，在进行手动set即可

4 最终方案

在上述情况下可以实现 手动控制是否在某些场景下的脱敏，但是需要对原来的代码进行修改，我觉得不友好，所以采用aop的形式进行控制

项目的返回类型基本上为两种

• 实体类作为返回
• 分页返回

aop注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})//作用于方法上
public@interfacePrivacyKeyAnnotation{

/**
*是否启用序列化脱敏默认开启
*/
booleanisKey()defaulttrue;

/**
*是否为PageInfo(分页对象)
*/
booleanisPageKey()defaultfalse;
}

aop类

@Component
@Aspect
publicclassPrivacyKeyAspect{
publicstaticfinalLoggerlogger=LoggerFactory.getLogger(PrivacyKeyAspect.class);

/**
*@Description:环绕通知包含此注解的
*@param:ProceedingJoinPointjoinPoint
*@return:Object
*/
@Around(value="@annotation("aop注解地址xxxxx")")
publicObjectrepeatSub(ProceedingJoinPointjoinPoint)throwsThrowable{
returnjoinPoint.proceed();
}

/**
*@Description:后置通知
*/
@AfterReturning(value="@annotation("aop注解地址")",returning="result")
publicvoidsetPrivacyKeyType(JoinPointjoinPoint,Objectresult)throwsThrowable{
//进行注解值获取
MethodSignaturesignature=(MethodSignature)joinPoint.getSignature();
Methodmethod=signature.getMethod();
//是否开启脱敏
booleanflag=method.getDeclaredAnnotation(PrivacyKeyAnnotation.class).isKey();
//是否对分页进行脱敏
booleanstatus=method.getDeclaredAnnotation(PrivacyKeyAnnotation.class).isPageKey();
if(!status){
//进行返回值反射
ClassaClass=ClassRecursionUtils.getClass(result.getClass(),"isPrivacyKey");
if(null!=aClass){
setFieldMethod(result,flag,aClass);
}
}else{
//反射分页page
//反射list类型
Parameter[]parameters=signature.getMethod().getParameters();
//泛型名称
Stringname=parameters[0].getName();
//泛型class
Classtype=parameters[0].getType();
//包名
StringtypeName=type.getName();
PropertyDescriptor[]ps=Introspector.getBeanInfo(result.getClass(),Object.class).getPropertyDescriptors();
for(PropertyDescriptorprop:ps){
if(prop.getPropertyType().isAssignableFrom(List.class)){//List集合类型
Objectobj=result.getClass().getMethod(prop.getReadMethod().getName()).invoke(result);
if(obj!=null){
ListlistObj=(List)obj;
for(Objectnext:listObj){
ClassclassObj=Class.forName(typeName);
//获取成员变量
ClasskeyClass=ClassRecursionUtils.getClass(classObj,"isPrivacyKey");
setFieldMethod(next,flag,keyClass);
}
}

}
}
}
}

/**
*内容填充
*/
privatevoidsetFieldMethod(Objectresult,booleanflag,ClassaClass)throwsIllegalAccessException{
Field[]declaredFields=aClass.getDeclaredFields();
for(Fieldfield:declaredFields){
//设置属性的可访问性
field.setAccessible(true);
//只获取isPrivacyKey
Stringname=field.getName();
//过滤非布尔类型
Classtype=field.getType();
//并且只添加isPrivacyKey
if(type.isAssignableFrom(Boolean.class)&&"isPrivacyKey".equals(name)){
//重新写入
field.set(result,flag);
}
}
}
}

使用 在service implement类方法上写入

最后，另一种实现方式，可以参考：

https://juejin.cn/post/7242145254057410615