SpringBoot 自定义注解实现涉密字段脱敏

2023-03-25 10:41 开发作者： java_代码搬运工

1. 创建隐私数据类型枚举：PrivacyTypeEnum

import lombok.Getter;
 
/**
 * 隐私数据类型枚举
 *
 */
@Getter
public enum PrivacyTypeEnum {
 
    /**
     * 自定义（此项需设置脱敏的范围）
     */
    CUSTOMER,
 
    /**
     * 姓名
     */
    NAME,
 
    /**
     * 身份证号
     */
    ID_CARD,
 
    /**
     * 手机号
     */
    PHONE,
 
    /**
     * 邮箱
     */
    EMAIL,
 
    /**
     * 关键字
     */
    KEYWORD
}

2. 创建自定义隐私注解：PrivacyEncrypt

import com.fasterXML.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 
import Java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 自定义数据脱敏注解
 */
@Target(ElementType.FIELD) // 作用在字段上
@Retention(RetentionPolicy.RUNTIME) // class文件中保留，运行时也保留，能通过反射读取到
@JacksonAnnotationsInside // 表示自定义自己的注解PrivacyEncrypt
@JsonSerialize(using = PrivacySerializer.class) // 该注解使用序列化的方式
public @interface PrivacyEncrypt {
 
    /**
     * 脱敏数据类型（没给默认值，所以使用时必须指定type）
     */
    PrivacyTypeEnum type();
 
    /**
     * 前置不需要打码的长度
     */
    int prefixNoMaskLen() default 1;
 
    /**
     * 后置不需要打码的长度
     */
    int suffixNoMaskLen() default 1;
 
    /**
     * 用什么打码
     */
    String symbol() default "*";
}

3. 创建自定义序列化器：PrivacySerializer

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.zk.common.core.domain.enumerate.PrivacyTypeEnum;
import com.zk.common.core.utils.PrivacyUtil;
import java.io.IOException;
import java.util.Objects;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.apache.co开发者_Python学习mmons.lang3.StringUtils;
 
@NoArgsConstructor
@AllArgsConstructor
public class PrivacySerializer extends JsonSerializer<String> implements ContextualSerializer {
 
  // 脱敏类型
  private PrivacyTypeEnum privacyTypeEnum;
  // 前几位不脱敏
  private Integer prefixNoMaskLen;
  // 最后几位不脱敏
  private Integer suffixNoMaskLen;
  // 用什么打码
  private String symbol;
 
  @Override
  public void serialize(final String origin, final JsonGenerator jsonGenerator,
      final SerializerProvider serializerProvider) throws IOException {
    if (StringUtils.isNotBlank(origin) && null != privacyTypeEnum) {
      switch (privacyTypeEnum) {
        case CUSTOMER:
          jsonGenerator.writeString(PrivacyUtil.desValue(origin, prefixNoMaskLen, suffixNoMaskLen, symbol));
          break;
        case NAME:
          jsonGenerator.writeString(PrivacyUtil.hideChineseName(origin));
          break;
        case ID_CARD:
          jsonGenerator.writeString(PrivacyUtil.hideIDCard(origin));
          break;
        case PHONE:
          jsonGenerator.writeString(PrivacyUjstil.hidePhone(origin));
          break;
        case EMAIL:
          jsonGenerator.writeString(PrivacyUtil.hideEmail(origin));
          break;
        default:
          throw new IllegalArgumentException("unknown privacy type enum " + privacyTypeEnum);
      }
    }
  }
 
  @Override
  public JsonSerializer<?> createContextual(final SerializerProvider serializerProvider,
      final BeanProperty beanProperty) throws JsonMappingException {
    if (beanProperty != null) {
      if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
        PrivacyEncrypt privacyEncrypt = beanProperty.getAnnotation(PrivacyEncrypt.class);
        if (privacyEncrypt == null) {
          privacyEncrypt = beanProperty.getContextAnnotation(PrivacyEncrypt.class);
        }
        if (privacyEncrypt javascript!= null) {
          return new PrivacySerializer(privacyEncrypt.type(), privacyEncrypt.prefixNoMaskLen(),
              privacyEncrypt.suffixNoMaskLen(), privacyEncrypt.symbol());
        }
      }
      return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    }
    return serializerProvider.findNullValueSerializer(null);
  }
}

这里是具体的实现过程，因为要脱敏的数据都是 String 类型的，所以继承 JsonSerializer 时的类型填 String

重写的 serialize 方法是实现脱敏的核心，根据类型 type 的不同去设置序列化后的值

重写的 createContextual 方法就是去读取我们自定义的 PrivacyEncrypt 注解，打造一个上下文的环境。

4. 隐私数据隐藏工具类：PrivacyUtil

public class PrivacyUtil {
 
    /**
     * 隐藏手机号中间四位
     */
    public static String hidePhone(String phone) {
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }
 
    /**
     * 隐藏邮箱
     */
    public static String hideEmail(String email) {
        return email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)", "$1****$3$4");
    }
 
    /**
     * 隐藏身份证
     */
    public static String hideIDCard(String idCard) {
        return idCard.replaceAll("(\\d{4})\\d{10}(\\w{4})", "$1*****$2");
    }
 
    /**
     * 【中文姓名】只显示第一个汉字，其他隐藏为星号，比如：任**
     */
    public static String hideChineseName(String chineseName) {
        if (chineseName == null) {
            return null;
        }
        return desValue(chineseName, 1, 0, "*");
    }
 
/**
     * 隐藏关键字
     *
     * @param context
     * @return
     */
    public static String hideKeyWord(String context) {
        // SpringUtil.getBean()方法来源于hutool提供的工具类。网上也有很多spring静态获取bean的方法，没有hutool依赖的，可自行实现。
        //  实际项目中，请替换为自己的Mapper或者Dao。这里是为大家提供动态获取数据库的示例写法。
        SysSecurityFieldMapper sysSecurityFieldMapper = SpringUtil.getBean(SysSecurityFieldMapper.class);
        List<SysSecurityFieldEntity> privacyKeyWord = sysSecurityFieldMapper.selectList(new LambdaQueryWrapper<SysSecurityFieldEntity>()
                .eq(SysSecurityFieldEntity::getStatus, SecurityFieldConstant.STATUS_NORMAL));
        if (CollectionUtils.isEmpty(privacyKeyWord)) {
            return context;
        }
        for (int i = 0; i < privacyKeyWord.size(); i++) {
            if (context.contains(privacyKeyWord.get(i).getKeyWord())) {
                context = context.replaceAll(privacyKeyWord.get(i).getKeyWord(), "***");
            }
        }
 
        return context;
    }
 
//    /**
//     * 【身份证号】显示前4位, 后2位
//     */
//    public static String hideIdCard(String idCard) {
//        return desValue(idCard, 4, 2, "*");
//    }
 
//    /**
//     * 【手机号码】前三位，后四位，其他隐藏。
//     */
//    public static String hidePhone(String phone) {
//        return desValue(phone, 3, 4, "*");
//    }
 
    /**
     * 对字符串进行脱敏操作
     * @param origin          原始字符串
     * @param prefixNoMaskLen 左侧需要保留几位明文字段
     * @param suffgGQmSixNoMaskLen 右侧需要保留几位明文字段
     * @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();
    }
 
    public static void main(Strwww.devze.coming[] args) {
        System.out.println(hideChineseName("张三三"));
    }
}

这个工具类其实可以自己定，根据自己的业务去扩展，提一点：

在自定义注解 PrivacyEncrypt 里，只有 type 的值为 PrivacyTypeEnum.CUSTOMER（自定义）时，才需要指定脱敏范围，即 prefixNoMaskLen 和 suffixNoMaskLen 的值，像邮箱、手机号这种隐藏格式都采用固定的
hideKeyWord() 方法中，SpringUtil.getBean()方法来源于hutool提供的工具类。网上也有很多spring静态获取bean的方法，没有hutool依赖的，可自行实现。实际项目中，请替换为自己的Mapper或者Dao。这里是为大家提供动态获取数据库的示例写法。

5. 注解使用

直接在需要脱敏的字段上加上注解，指定 type 值即可，如下：

@Data
public class People {
 
    private Integer id;
 
    private String name;
 
    private Integer sex;
 
    private Integer age;
 
    @PrivacyEncrypt(type = PrivacyTypeEnum.PHONE) // 隐藏手机号
    private String phone;
 
    @PrivacyEncrypt(type = PrivacyTypeEnum.EMAIL) // 隐藏邮箱
    private String email;
 
    private String sign;
}

到这里，脱敏工作就已经结束了，全局使用这一个注解即可，一劳永逸，测试效果图如下：

SpringBoot 自定义注解实现涉密字段脱敏

到此这篇关于SpringBoot 自定义注解实现涉密字段脱敏的文章就介绍到这了,更多相关SpringBoot 自定义注解内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

继续阅读：SpringBoot自定义注解涉密字段脱敏

SpringBoot 自定义注解实现涉密字段脱敏

目录

1. 创建隐私数据类型枚举：PrivacyTypeEnum

2. 创建自定义隐私注解：PrivacyEncrypt

3. 创建自定义序列化器：PrivacySerializer

4. 隐私数据隐藏工具类：PrivacyUtil

5. 注解使用

更多精彩内容

精彩评论

最新开发

如何实现Python编写的图形界面可以自由拖动

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

解决Feign异步调用丢失上下文问题

python模拟重载初始化函数的方法详解

SQL注入攻击及其在SpringBoot中使用MyBatisPlus的防范策略的方法

开发排行榜

springboot后端存储富文本内容的思路与步骤(含图片内容)

PyCharm运行python测试,报错“没有发现测试”/“空套件”的解决

return base64.b64encode(b).decode(

基于C语言实现钻石棋游戏的示例代码

Sublime Text 3解决中文乱码问题（实测可用）