SpringBoot实现返回值数据脱敏

已于 2023-07-11 16:41:34 修改
阅读量1.5k 收藏 15
点赞数 3
文章标签： spring boot 脱敏处理
于 2023-07-11 16:34:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yusewuhen/article/details/131662827
版权

介绍

  • SpringBoot实现返回数据脱敏

  • 有时，敏感数据返回时，需要进行隐藏处理，但是如果一个字段一个字段的进行硬编码处理的话，不仅增加了工作量，而且后期需求变动的时候，更加是地狱般的工作量变更。

  • 下面，通过身份证，姓名，密码，手机号等等示例去演示脱敏的流程，当然你也可以在此基础上添加自己的实现方式

原理

  • 项目使用的是SpringBoot，所以需要在序列化的时候，进行脱敏处理，springboot内置的序列化工具为jackson
  • 通过实现com.fasterxml.jackson.databind.JsonSerializer进行自定义序列化
  • 通过重写com.fasterxml.jackson.databind.ser.ContextualSerializer.createContextual获取自定义注解的信息

 实现

自定义注解类

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

创建脱敏字段类型枚举

public enum SensitizedType {
    /**
     * 用户id
     */
    USER_ID,
    /**
     * 中文名
     */
    CHINESE_NAME,
    /**
     * 身份证号
     */
    ID_CARD,
    /**
     * 座机号
     */
    FIXED_PHONE,
    /**
     * 手机号
     */
    MOBILE_PHONE,
    /**
     * 地址
     */
    ADDRESS,
    /**
     * 电子邮件
     */
    EMAIL,
    /**
     * 密码
     */
    PASSWORD,
    /**
     * 中国大陆车牌，包含普通车辆、新能源车辆
     */
    CAR_LICENSE,
    /**
     * 银行卡
     */
    BANK_CARD,
    /**
     * IPv4地址
     */
    IPV4,
    /**
     * IPv6地址
     */
    IPV6,
    /**
     * 定义了一个first_mask的规则，只显示第一个字符。
     */
    FIRST_MASK
}

脱敏工具类

import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.StrUtil;

/**
 * @Auther: wu
 * @Date: 2023/7/11
 * @Description: com.wu.demo.common.my_sensitive
 */
public class SensitizedUtil {

    public static String desensitized(CharSequence str, SensitizedType desensitizedType) {
        if (StrUtil.isBlank(str)) {
            return StrUtil.EMPTY;
        }
        String newStr = String.valueOf(str);
        switch (desensitizedType) {
            case USER_ID:
                newStr = String.valueOf(userId());
                break;
            case CHINESE_NAME:
                newStr = chineseName(String.valueOf(str));
                break;
            case ID_CARD:
                newStr = idCardNum(String.valueOf(str), 3, 4);
                break;
            case FIXED_PHONE:
                newStr = fixedPhone(String.valueOf(str));
                break;
            case MOBILE_PHONE:
                newStr = mobilePhone(String.valueOf(str));
                break;
            case ADDRESS:
                newStr = address(String.valueOf(str), 8);
                break;
            case EMAIL:
                newStr = email(String.valueOf(str));
                break;
            case PASSWORD:
                newStr = password(String.valueOf(str));
                break;
            case CAR_LICENSE:
                newStr = carLicense(String.valueOf(str));
                break;
            case BANK_CARD:
                newStr = bankCard(String.valueOf(str));
                break;
            case IPV4:
                newStr = ipv4(String.valueOf(str));
                break;
            case IPV6:
                newStr = ipv6(String.valueOf(str));
                break;
            case FIRST_MASK:
                newStr = firstMask(String.valueOf(str));
                break;
            default:
        }
        return newStr;
    }

    /**
     * 【用户id】不对外提供userId
     *
     * @return 脱敏后的主键
     */
    public static Long userId() {
        return 0L;
    }

    /**
     * 定义了一个first_mask的规则，只显示第一个字符。<br>
     * 脱敏前：123456789；脱敏后：1********。
     *
     * @param str 字符串
     * @return 脱敏后的字符串
     */
    public static String firstMask(String str) {
        if (StrUtil.isBlank(str)) {
            return StrUtil.EMPTY;
        }
        return StrUtil.hide(str, 1, str.length());
    }

    /**
     * 【中文姓名】只显示第一个汉字，其他隐藏为2个星号，比如：李**
     *
     * @param fullName 姓名
     * @return 脱敏后的姓名
     */
    public static String chineseName(String fullName) {
        return firstMask(fullName);
    }

    /**
     * 【身份证号】前1位 和后2位
     *
     * @param idCardNum 身份证
     * @param front     保留：前面的front位数；从1开始
     * @param end       保留：后面的end位数；从1开始
     * @return 脱敏后的身份证
     */
    public static String idCardNum(String idCardNum, int front, int end) {
        //身份证不能为空
        if (StrUtil.isBlank(idCardNum)) {
            return StrUtil.EMPTY;
        }
        //需要截取的长度不能大于身份证号长度
        if ((front + end) > idCardNum.length()) {
            return StrUtil.EMPTY;
        }
        //需要截取的不能小于0
        if (front < 0 || end < 0) {
            return StrUtil.EMPTY;
        }
        return StrUtil.hide(idCardNum, front, idCardNum.length() - end);
    }

    /**
     * 【固定电话 前四位，后两位
     *
     * @param num 固定电话
     * @return 脱敏后的固定电话；
     */
    public static String fixedPhone(String num) {
        if (StrUtil.isBlank(num)) {
            return StrUtil.EMPTY;
        }
        return StrUtil.hide(num, 4, num.length() - 2);
    }

    /**
     * 【手机号码】前三位，后4位，其他隐藏，比如135****2210
     *
     * @param num 移动电话；
     * @return 脱敏后的移动电话；
     */
    public static String mobilePhone(String num) {
        if (StrUtil.isBlank(num)) {
            return StrUtil.EMPTY;
        }
        return StrUtil.hide(num, 3, num.length() - 4);
    }

    /**
     * 【地址】只显示到地区，不显示详细地址，比如：北京市海淀区****
     *
     * @param address       家庭住址
     * @param sensitiveSize 敏感信息长度
     * @return 脱敏后的家庭地址
     */
    public static String address(String address, int sensitiveSize) {
        if (StrUtil.isBlank(address)) {
            return StrUtil.EMPTY;
        }
        int length = address.length();
        return StrUtil.hide(address, length - sensitiveSize, length);
    }

    /**
     * 【电子邮箱】邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示，比如：d**@126.com
     *
     * @param email 邮箱
     * @return 脱敏后的邮箱
     */
    public static String email(String email) {
        if (StrUtil.isBlank(email)) {
            return StrUtil.EMPTY;
        }
        int index = StrUtil.indexOf(email, '@');
        if (index <= 1) {
            return email;
        }
        return StrUtil.hide(email, 1, index);
    }

    /**
     * 【密码】密码的全部字符都用*代替，比如：******
     *
     * @param password 密码
     * @return 脱敏后的密码
     */
    public static String password(String password) {
        if (StrUtil.isBlank(password)) {
            return StrUtil.EMPTY;
        }
        return StrUtil.repeat('*', password.length());
    }

    /**
     * 【中国车牌】车牌中间用*代替
     * eg1：null       -》 ""
     * eg1：""         -》 ""
     * eg3：苏D40000   -》 苏D4***0
     * eg4：陕A12345D  -》 陕A1****D
     * eg5：京A123     -》 京A123     如果是错误的车牌，不处理
     *
     * @param carLicense 完整的车牌号
     * @return 脱敏后的车牌
     */
    public static String carLicense(String carLicense) {
        if (StrUtil.isBlank(carLicense)) {
            return StrUtil.EMPTY;
        }
        // 普通车牌
        if (carLicense.length() == 7) {
            carLicense = StrUtil.hide(carLicense, 3, 6);
        } else if (carLicense.length() == 8) {
            // 新能源车牌
            carLicense = StrUtil.hide(carLicense, 3, 7);
        }
        return carLicense;
    }

    /**
     * 银行卡号脱敏
     * eg: 1101 **** **** **** 3256
     *
     * @param bankCardNo 银行卡号
     * @return 脱敏之后的银行卡号
     * @since 5.6.3
     */
    public static String bankCard(String bankCardNo) {
        if (StrUtil.isBlank(bankCardNo)) {
            return bankCardNo;
        }
        bankCardNo = StrUtil.trim(bankCardNo);
        if (bankCardNo.length() < 9) {
            return bankCardNo;
        }

        final int length = bankCardNo.length();
        final int midLength = length - 8;
        final StringBuilder buf = new StringBuilder();

        buf.append(bankCardNo, 0, 4);
        for (int i = 0; i < midLength; ++i) {
            if (i % 4 == 0) {
                buf.append(CharUtil.SPACE);
            }
            buf.append('*');
        }
        buf.append(CharUtil.SPACE).append(bankCardNo, length - 4, length);
        return buf.toString();
    }

    /**
     * IPv4脱敏，如：脱敏前：192.0.2.1；脱敏后：192.*.*.*。
     *
     * @param ipv4 IPv4地址
     * @return 脱敏后的地址
     */
    public static String ipv4(String ipv4) {
        return StrUtil.subBefore(ipv4, '.', false) + ".*.*.*";
    }

    /**
     * IPv4脱敏，如：脱敏前：2001:0db8:86a3:08d3:1319:8a2e:0370:7344；脱敏后：2001:*:*:*:*:*:*:*
     *
     * @param ipv6 IPv4地址
     * @return 脱敏后的地址
     */
    public static String ipv6(String ipv6) {
        return StrUtil.subBefore(ipv6, ':', false) + ":*:*:*:*:*:*:*";
    }
}

上述枚举类和脱敏工具类，我使用了hutool中的代码，如果hutool满足你的需求，可以直接把上述自定义注解类和自定义序列化类使用到的SensitizedType类直接替换为hutool中的cn.hutool.core.util.DesensitizedUtil.DesensitizedType的枚举类，

添加自定义序列化实现类

public class SensitiveInfoSerialize extends JsonSerializer<String> implements ContextualSerializer {

    private SensitizedType sensitizedType;

    /**
     * 步骤一
     * 方法来源于ContextualSerializer，获取属性上的注解属性,同时返回一个合适的序列化器
     */
    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        // 获取自定义注解
        Sensitive annotation = beanProperty.getAnnotation(Sensitive.class);
        // 注解不为空，且标注的字段为String
        if(Objects.nonNull(annotation) && Objects.equals(String.class, beanProperty.getType().getRawClass())){
            this.sensitizedType = annotation.value();
            //自定义情况，返回本序列化器，将顺利进入到该类中的serialize方法中
            return this;
        }
        // 注解为空，字段不为String，寻找合适的序列化器进行处理
        return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    }

    /**
     * 步骤二
     * 方法来源于JsonSerializer<String>：指定返回类型为String类型，serialize()将修改后的数据返回
     */
    @Override
    public void serialize(String str, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        if(Objects.isNull(sensitizedType)){
            // 定义策略为空，返回原字符串
            jsonGenerator.writeString(str);
        }else {
            // 定义策略不为空，返回策略处理过的字符串
            jsonGenerator.writeString(SensitizedUtil.desensitized(str,sensitizedType));
        }
    }
    
}

测试验证

在需要的脱敏的实体类字段上加上相应的注解

@Data
public class SensitiveBody {
    private String name;
    @Sensitive(SensitizedType.MOBILE_PHONE)
    private String mobile;
    @Sensitive(SensitizedType.ID_CARD)
    private String idCard;
}
    @ApiOperation(value = "脱敏测试处理")
    @GetMapping("sensitiveTest")
    public AjaxResult sensitiveTest(){
        SensitiveBody body = new SensitiveBody();
        body.setMobile("13041064026");
        body.setIdCard("411126189912355689");
        body.setName("Tom");

        return AjaxResult.success(body);
    }

月色无痕
关注
Spring Boot(六十一)：实现接口返回数据脱敏实现
u013938578的博客
03-15 488
当返回对象比较复杂，需要递归去反射，性能一下子就会降低，于是换种思路，我想到平时使用的 @JsonFormat，跟我现在的场景很类似，通过自定义注解跟字段解析器，对字段进行自定义解析，tql。（1）要做成可配置多策略的脱敏操作，要不然一个个接口进行脱敏操作，重复的工作量太多，很显然违背了“多写一行算我输”的程序员规范。思来想去，定义数据脱敏注解和数据脱敏逻辑的接口， 在返回类上，对需要进行脱敏的属性加上，并指定对应的脱敏策略操作。3.4 覆盖ObjectMapper。3.6 编写测试接口。
【微服务】springboot 实现动态修改接口返回值
congge
09-28 8093
springboot 实现动态修改接口返回值
spring MVC 对 ResponseBody返回json数据进行脱敏处理
05-01
NULL 博文链接：https://coocaobo.iteye.com/blog/2410629
项目敏感词脱敏如何实现
weixin_39195030的博客
08-13 74
因为我的项目是基于 Spring Boot 开发的，因此可以利用 Spring Boot 自带的 Jackson 自定义序列化实现，在 JSON 进行序列化渲染给前端时，进行脱敏。脱敏工具类支持用户 ID、中文姓名、身份证号、座机号、手机号、电子邮件、银行卡号等脱敏数据类型，基本覆盖了常见的敏感信息。如果使用的序列化是 Fastjson 而不是默认的 Jackson，你可以创建一个自定义的。这里以最常用的替换为例进行介绍，这也是我的项目用到的方法。脱敏工具类的脱敏规则是隐藏掉信息中的一部分关键信息用。
Spring Boot中的数据脱敏处理
技术研究中心
06-27 1188
我们首先定义一个注解，用于标记需要脱敏的字段。Retention;Target;同时，我们定义一个枚举来表示不同的脱敏类型。本文介绍了在Spring Boot中如何进行数据脱敏处理。通过自定义注解和Jackson配置，我们可以轻松实现对敏感数据的脱敏，保护用户隐私。在实际应用中，我们可以根据具体需求灵活调整脱敏策略，确保数据安全。
springboot项目中实现数据脱敏
weixin_44727769的博客
06-08 2703
创建自定义脱敏枚举类：这里定义一个敏感字段的枚举，并设定各个字段的脱敏策略。/*** 用户名* 身份证* 手机号* 地址} }创建序列化类：SensitiveSerializer：} }定义SensitiveData注解定义返回结果实体类创建包含敏感数据字段的实体类，并在需要脱敏的字段上添加 @SensitiveData 注解。创建Conrtoller测试返回结果u . setUsername("张老三");
【SpringBoot】数据脱敏
阿Q的小窝
04-30 3889
数据脱敏，也称为数据的去隐私化或数据变形，是一种技术手段，用于对某些敏感信息通过特定的脱敏规则进行数据的变形，从而实现敏感隐私数据的可靠保护。这样可以在开发、测试和其他非生产环境以及外包环境中安全地使用脱敏后的真实数据集。数据脱敏的主要应用场景包括涉及客户安全数据或商业性敏感数据的情况，例如身份证号、手机号、卡号、客户号等个人信息都需要进行数据脱敏。
SpringBoot实战：轻松实现接口数据脱敏
weixin_73588491的博客
07-09 5645
接口数据脱敏是指在Web应用程序的API接口返回数据时，对包含敏感信息的字段进行处理，使其部分或全部信息被隐藏或替换，以防止敏感信息的泄露。这个过程通常不会改变数据的原始格式，而是通过特定的算法或规则，将敏感部分替换为特定字符（如星号*）或者保留部分信息。接下来，我们创建一个自定义注解/*** 用于标记字段需要进行脱敏处理的注解*//*** 脱敏类型*//*** 脱敏起始位置*//*** 脱敏结束位置*/然后，定义枚举类/*** 脱敏类型枚举类/*** 默认脱敏。
springboot spring aop 拦截器注解方式实现脱敏
02-13
在本案例中，我们将探讨如何使用注解来实现拦截器，用于数据脱敏，这是保护敏感信息的一种常见方法。数据脱敏是指在展示或传输数据时，将敏感信息替换或隐藏，以确保隐私。 首先，让我们从`pom.xml`文件开始。在...
springboot 脱敏自定义注解
03-25
总的来说，通过自定义注解和Spring AOP，我们可以灵活地在Spring Boot应用中实现数据脱敏，提高应用的安全性。这不仅使代码保持整洁，也使得脱敏规则易于管理和维护。在实际开发中，还需要注意处理各种异常情况，...
SpringBoot实现接口：统一返回值、全局异常处理、Swagger接口文档
最新发布
pan_junbiao的博客
10-15 918
在 Spring Boot 应用中实现统一返回值和全局异常处理可以带来多方面的好处，这些好处不仅提升了代码的可读性和可维护性，还增强了应用的健壮性和用户体验。通过定义统一的返回值格式，可以确保整个应用中的API响应结构保持一致。统一的异常处理机制使得错误信息的返回方式也保持一致，便于前端开发者理解和处理。
Spring Boot数据脱敏
m0_57077522的博客
02-15 382
Spring Boot数据脱敏
SpringBoot如何优雅地实现返回数据脱敏
qq_40782372的博客
05-18 889
数据脱敏是一种常见的数据安全保护技术，可以在保护数据隐私的同时，保持数据的有效性和可用性。在 Spring Boot 中，我们可以使用注解的方式实现数据脱敏，使代码更加简洁、易于维护和扩展。
springboot数据脱敏
wangtianyou343的博客
04-13 160
springboot数据脱敏
使用Spring Boot实现数据脱敏
省赚客开发者博客
07-15 548
数据脱敏是一种有效保护敏感信息的技术，通过对数据进行遮掩或变形，使其在不影响使用的前提下失去敏感性。本文将介绍如何在Spring Boot项目中实现数据脱敏，确保用户信息的安全性。数据脱敏技术能够有效保护用户的敏感信息，提升系统的安全性和用户信任度。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！首先，我们需要创建一个Spring Boot项目，并添加必要的依赖。我们创建一个简单的RESTful接口，来演示数据脱敏的效果。我们创建一个数据脱敏工具类，提供常见的脱敏方法。
Springboot实现数据脱敏
CMM__的博客
02-14 905
springboot实现数据脱敏最简单的方式
springboot实现数据脱敏
weixin_73375551的博客
02-16 415
springboot整合secure
【三十三】springboot+序列化实现返回值脱敏和返回值字符串时间格式化问题
weixin_56995925的博客
06-08 1585
很久没有写小作文了，赶着学子们参加考试的时间，继续记录点小东西，1、返回对象的字符串数据脱敏；2、返回对象针对字符串格式的时间的格式化。
springboot统一返回值
10-17
在Spring Boot中，可以通过自定义一个统一的返回值对象来实现统一返回值。具体实现方式如下： 1. 定义一个统一的返回值对象，例如： ```java public class Result<T> { private int code; private String message; private T data; // 省略 getter 和 setter 方法 } ``` 2. 在控制器中，将方法的返回值类型改为 `Result` 类型，并在方法中构造一个 `Result` 对象，例如： ```java @RestController public class UserController { @GetMapping("/user/{id}") public Result<User> getUser(@PathVariable Long id) { User user = userService.getUserById(id); return new Result<>(200, "success", user); } } ``` 3. 在全局异常处理器中，捕获异常并构造一个 `Result` 对象返回，例如： ```java @ControllerAdvice public class GlobalExceptionHandler { @ExceptionHandler(Exception.class) @ResponseBody public Result<Object> handleException(Exception e) { return new Result<>(500, e.getMessage(), null); } } ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值