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*****o@xx.com
*/
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);
}
}
}
}