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

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

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

JsonSerializer介绍就参考这位大佬的
aop介绍参考这位大佬的

初步尝试
枚举类
/**

  • 敏感信息枚举类

*
**/
public enum PrivacyTypeEnum {

/**

* 自定义
*/
AI 代码解读

CUSTOMER,
/**

* 用户名, 张*三, 李*
*/
AI 代码解读

CHINESE_NAME,
/**

* 身份证号, 110110********1234
*/
AI 代码解读

ID_CARD,
/**

* 座机号, ****1234
*/
AI 代码解读

FIXED_PHONE,
/**

* 手机号, 176****1234
*/
AI 代码解读

MOBILE_PHONE,
/**

* 地址, 北京********
*/
AI 代码解读

ADDRESS,
/**

* 电子邮件, s*****o@xx.com
*/
AI 代码解读

EMAIL,
/**

* 银行卡, 622202************1234
*/
AI 代码解读

BANK_CARD,
/**

* 密码, 永远是 ******, 与长度无关
*/
AI 代码解读

PASSWORD,
/**

* 密钥, 永远是 ******, 与长度无关
*/
AI 代码解读

KEY

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

/**

* 脱敏数据类型, 非Customer时, 将忽略 refixNoMaskLen 和 suffixNoMaskLen 和 maskStr
*/
AI 代码解读

PrivacyTypeEnum type() default PrivacyTypeEnum.CUSTOMER;

/**

* 前置不需要打码的长度
*/
AI 代码解读

int prefixNoMaskLen() default 0;

/**

* 后置不需要打码的长度
*/
AI 代码解读

int suffixNoMaskLen() default 0;

/**

* 用什么打码
*/
AI 代码解读

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;
AI 代码解读

}
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("");
  }
AI 代码解读

}

@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);
AI 代码解读

}
}
复制代码
脱敏工具类
/**

  • 脱敏工具类

*
**/
public class DesensitizedUtils {

/**

* 对字符串进行脱敏操作
* @param origin 原始字符串
* @param prefixNoMaskLen 左侧需要保留几位明文字段
* @param suffixNoMaskLen 右侧需要保留几位明文字段
* @param maskStr 用于遮罩的字符串, 如'*'
* @return 脱敏后结果
*/
AI 代码解读

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();
AI 代码解读

}

/**

* 【中文姓名】只显示最后一个汉字,其他隐藏为星号,比如:**梦
* @param fullName 姓名
* @return 结果
*/
AI 代码解读

public static String chineseName(String fullName) {

  if (fullName == null) {
     return null;
  }
  return desValue(fullName, 0, 1, "*");
AI 代码解读

}

/**

* 【身份证号】显示前六位, 四位,其他隐藏。共计18位或者15位,比如:340304*******1234
* @param id 身份证号码
* @return 结果
*/
AI 代码解读

public static String idCardNum(String id) {

  return desValue(id, 6, 4, "*");
AI 代码解读

}

/**

* 【固定电话】后四位,其他隐藏,比如 ****1234
* @param num 固定电话
* @return 结果
*/
AI 代码解读

public static String fixedPhone(String num) {

  return desValue(num, 0, 4, "*");
AI 代码解读

}

/**

* 【手机号码】前三位,后四位,其他隐藏,比如135****6810
* @param num 手机号码
* @return 结果
*/
AI 代码解读

public static String mobilePhone(String num) {

  return desValue(num, 3, 4, "*");
AI 代码解读

}

/**

* 【地址】只显示到地区,不显示详细地址,比如:北京市海淀区****
* @param address 地址
* @return 结果
*/
AI 代码解读

public static String address(String address) {

  return desValue(address, 6, 0, "*");
AI 代码解读

}

/**

* 【电子邮箱 邮箱前缀仅显示第一个字母,前缀其他隐藏,用星号代替,@及后面的地址显示,比如:d**@126.com
* @param email 电子邮箱
* @return 结果
*/
AI 代码解读

public static String email(String email) {

  return email.replaceAll("(\w?)(\w+)(\w)(@\w+\.[a-z]+(\.[a-z]+)?)", "$1****$3$4");
AI 代码解读

}

/**

* 【银行卡号】前六位,后四位,其他用星号隐藏每位1个星号,比如:622260**********1234
* @param cardNum 银行卡号
* @return 结果
*/
AI 代码解读

public static String bankCard(String cardNum) {

  return desValue(cardNum, 6, 4, "*");
AI 代码解读

}

/**

* 【密码】密码的全部字符都用*代替,比如:******
* @param password 密码
* @return 结果
*/
AI 代码解读

public static String password(String password) {

  if (password == null) {
     return null;
  }
  return "******";
AI 代码解读

}

/**

* 【密钥】密钥除了最后三位,全部都用*代替,比如:***xdS 脱敏后长度为6,如果明文长度不足三位,则按实际长度显示,剩余位置补*
* @param key 密钥
* @return 结果
*/
AI 代码解读

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();
  }
AI 代码解读

}

}
复制代码
注解使用

效果

的确实现了数据脱敏,但是有个问题现在的脱敏针对的是 只要对该实体类进行了使用返回的接口,中的数据都会进行脱敏,在有些场景下是不需要的,所以说要进行改进。
第二版改进
我的思路是在该实体类中在继承一个 父类其中定义一个字段,使其作为是否进行脱敏的开关,并且该实体类字段不参与序列化
脱敏控制类
public class DataMaskKey implements Serializable {

//不进行序列化,设置key 来进行过滤的把控,默认不开启
private transient Boolean isPrivacyKey = false;

public Boolean getPrivacyKey() {
    return isPrivacyKey;
}

public void setPrivacyKey(Boolean privacyKey) {
    isPrivacyKey = privacyKey;
}
AI 代码解读

}
复制代码
更新之后的序列化类
思路就是通过反射获取,该成员的属性,因为不知道会继承多少,所以要进行递归查找需要的字段
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;
AI 代码解读

}
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);
  }
AI 代码解读

}

@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);
AI 代码解读

}

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;
AI 代码解读

}

}
复制代码
递归工具类
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;
}
AI 代码解读

}
复制代码
现在只需要在进行实体类 封装数据时,在进行手动set即可
最终方案
在上述情况下可以实现 手动控制是否在某些场景下的脱敏,但是需要对原来的代码进行修改,我觉得不友好,所以采用aop的形式进行控制
项目的返回类型基本上为两种

实体类作为返回
分页返回

aop注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})//作用于方法上
public @interface PrivacyKeyAnnotation {

/**
 * 是否启用序列化脱敏 默认开启
 */
boolean isKey() default true;

/**
 * 是否为PageInfo<?>(分页对象)
 */
boolean isPageKey() default false;
AI 代码解读

}
复制代码
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);
        }
    }
}
AI 代码解读

}
复制代码
使用
在service implement类方法上写入

目录
打赏
0
0
0
0
122
分享
相关文章
Spring Boot中的AOP实现
Spring AOP(面向切面编程)允许开发者在不修改原有业务逻辑的情况下增强功能,基于代理模式拦截和增强方法调用。Spring Boot通过集成Spring AOP和AspectJ简化了AOP的使用,只需添加依赖并定义切面类。关键概念包括切面、通知和切点。切面类使用`@Aspect`和`@Component`注解标注,通知定义切面行为,切点定义应用位置。Spring Boot自动检测并创建代理对象,支持JDK动态代理和CGLIB代理。通过源码分析可深入了解其实现细节,优化应用功能。
105 6
SpringBoot 通过集成 Flink CDC 来实时追踪 MySql 数据变动
通过详细的步骤和示例代码,您可以在 SpringBoot 项目中成功集成 Flink CDC,并实时追踪 MySQL 数据库的变动。
142 43
NEON AOP 表面定向反射率数据是一种高光谱 VSWIR(可见光到短波红外)数据产品,包含 426 个波段
NEON AOP 表面定向反射率数据是高光谱 VSWIR 数据产品,涵盖 426 个波段(380-2510 nm),空间分辨率为 1 米,光谱分辨率为 ~5 纳米。数据由 AVIRIS-NG 传感器收集,包含 QA 波段和大气校正。水蒸气吸收波段设为 -100。数据集适用于环境监测、生态研究等领域。代码示例展示了如何使用 Earth Engine 处理和可视化这些数据。
50 17
Spring Boot 3 集成Spring AOP实现系统日志记录
本文介绍了如何在Spring Boot 3中集成Spring AOP实现系统日志记录功能。通过定义`SysLog`注解和配置相应的AOP切面,可以在方法执行前后自动记录日志信息,包括操作的开始时间、结束时间、请求参数、返回结果、异常信息等,并将这些信息保存到数据库中。此外,还使用了`ThreadLocal`变量来存储每个线程独立的日志数据,确保线程安全。文中还展示了项目实战中的部分代码片段,以及基于Spring Boot 3 + Vue 3构建的快速开发框架的简介与内置功能列表。此框架结合了当前主流技术栈,提供了用户管理、权限控制、接口文档自动生成等多项实用特性。
88 8
什么是AOP?如何与Spring Boot一起使用?
什么是AOP?如何与Spring Boot一起使用?
113 5
SpringBoot使用mysql查询昨天、今天、过去一周、过去半年、过去一年数据
SpringBoot使用mysql查询昨天、今天、过去一周、过去半年、过去一年数据
100 9
SpringBoot+EasyExcel轻松实现300万数据快速导出!
本文介绍了在项目开发中使用Apache POI进行数据导入导出的常见问题及解决方案。首先比较了HSSFWorkbook、XSSFWorkbook和SXSSFWorkbook三种传统POI版本的优缺点,然后根据数据量大小推荐了合适的使用场景。接着重点介绍了如何使用EasyExcel处理超百万数据的导入导出,包括分批查询、分批写入Excel、分批插入数据库等技术细节。通过测试,300万数据的导出用时约2分15秒,导入用时约91秒,展示了高效的数据处理能力。最后总结了公司现有做法的不足,并提出了改进方向。
SpringBoot项目使用AOP及自定义注解保存操作日志
SpringBoot项目使用AOP及自定义注解保存操作日志
80 1
elasticsearch学习五:springboot整合 rest 操作elasticsearch的 实际案例操作,编写搜索的前后端,爬取京东数据到elasticsearch中。
这篇文章是关于如何使用Spring Boot整合Elasticsearch,并通过REST客户端操作Elasticsearch,实现一个简单的搜索前后端,以及如何爬取京东数据到Elasticsearch的案例教程。
322 0
elasticsearch学习五:springboot整合 rest 操作elasticsearch的 实际案例操作,编写搜索的前后端,爬取京东数据到elasticsearch中。
|
5月前
Micronaut AOP与代理机制:实现应用功能增强,无需侵入式编程的秘诀
AOP(面向切面编程)能够帮助我们在不修改现有代码的前提下,为应用程序添加新的功能或行为。Micronaut框架中的AOP模块通过动态代理机制实现了这一目标。AOP将横切关注点(如日志记录、事务管理等)从业务逻辑中分离出来,提高模块化程度。在Micronaut中,带有特定注解的类会在启动时生成代理对象,在运行时拦截方法调用并执行额外逻辑。例如,可以通过创建切面类并在目标类上添加注解来记录方法调用信息,从而在不侵入原有代码的情况下增强应用功能,提高代码的可维护性和可扩展性。
110 1
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等