SpringBoot 实现数据加密脱敏（注解 + 反射 + AOP）

最新推荐文章于 2024-08-15 17:21:41 发布
最新推荐文章于 2024-08-15 17:21:41 发布
阅读量325 收藏
点赞数
文章标签： spring boot 状态模式 后端
原文链接：https://mp.weixin.qq.com/s/YI_1oo7NfzPVzn7IU5wc2A
版权

程序员黑哥 2023-09-01 22:20 发表于湖南

收录于合集

#身份证1个

#计算机网络35个

#Java138个

#程序员91个

#编程78个

场景：响应政府要求，商业软件应保证用户基本信息不被泄露，不能直接展示用户手机号，身份证，地址等敏感信息。

根据上面场景描述，我们可以分析出两个点。

  • 不被泄露说明用户信息应被加密储存；

  • 不能直接展示说明用户信息应脱敏展示；

解决方案

  • 傻瓜式编程：将项目中关于用户信息实体类的字段，比如姓名，手机号，身份证，地址等，在新增进数据库之前，对数据进行加密处理；在列表中展示用户信息时，对数据库中的数据进行解密脱敏，然后返回给前端；

  • 切入式编程：将项目中关于用户信息实体类的字段用注解给标记，新增用户信息实体类（这里我们用UserBO来表示，给UserBO里面的name，phone字段添加@EncryptField），返回用户信息实体类（这里我们用UserDO来表示，给UserDO里面的name，phone字段添加@DecryptField）；然后利用@EncryptField，@DecryptField做为切入点，以切面的形式实现加密，解密脱敏；

傻瓜式编程不是说傻，而是相当于切入式编程，傻瓜式编程需要对用户信息相关的所有接口进行加密，解密脱敏的逻辑处理，这里改动的地方就比较多，风险高，重复操作相同的逻辑，工作量大，后期不好维护；切入式编程只需要对用户信息字段添加注解，对有注解的字段统一进行加密，解密脱敏逻辑处理，操作方便，高聚合，易维护；

方案实现

傻瓜式编程没什么难度，这里我给大家有切入式编程来实现；在实现之前，跟大家预热一下注解，反射，AOP的知识；

注解实战

创建注解

创建一个只能标记在方法上的注解：

package com.weige.javaskillpoint.annotation;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Target(ElementType.METHOD)         //METHOD 说明该注解只能用在方法上@Retention(RetentionPolicy.RUNTIME) //RUNTIME 说明该注解在运行时生效public @interface Encryption {
}

创建一个只能标记在字段上的注解：

package com.weige.javaskillpoint.annotation;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Target(ElementType.FIELD)           //FIELD 说明该注解只能用在字段上@Retention(RetentionPolicy.RUNTIME)  //RUNTIME 说明该注解在运行时生效public @interface EncryptField {
}

创建一个标记在字段上，且有值的注解：

package com.weige.javaskillpoint.annotation;
import com.weige.javaskillpoint.enums.DesensitizationEnum;
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)public @interface DecryptField {  // 注解是可以有值的,这里可以为数组,String,枚举等类型  // DesensitizationEnum desensitizationEnum = field.getAnnotation(DecryptField.class).value(); 这里的field是指当前标记的字段    DesensitizationEnum value(); }
注解使用

创建枚举

package com.weige.javaskillpoint.enums;
public enum DesensitizationEnum {    name,     // 用户信息姓名脱敏    address,  // 用户信息地址脱敏    phone;    // 用户信息手机号脱敏}

创建UserDO类

package com.weige.javaskillpoint.entity;
import com.weige.javaskillpoint.annotation.DecryptField;import com.weige.javaskillpoint.enums.DesensitizationEnum;import com.weige.javaskillpoint.utils.AesUtil;
import java.lang.reflect.Field;
// 用户信息返回实体类public class UserDO {
    @DecryptField(DesensitizationEnum.name)    private String name;
    @DecryptField(DesensitizationEnum.address)    private String address;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public String getAddress() {        return address;    }
    public void setAddress(String address) {        this.address = address;    }
    public UserDO(String name, String address) {        this.name = name;        this.address = address;    }
    public static void main(String[] args) throws IllegalAccessException {        // 生成并初始化对象        UserDO userDO = new UserDO("梦想是什么","湖北省武汉市");        // 反射获取当前对象的所有字段        Field[] fields = userDO.getClass().getDeclaredFields();        // 遍历字段        for (Field field : fields) {            // 判断字段上是否存在@DecryptField注解            boolean hasSecureField = field.isAnnotationPresent(DecryptField.class);            // 存在            if (hasSecureField) {                // 暴力破解 不然操作不了权限为private的字段                field.setAccessible(true);                // 如果当前字段在userDo中不为空 即name,address字段有值                if (field.get(userDO) != null) {                    // 获取字段上注解的value值                    DesensitizationEnum desensitizationEnum = field.getAnnotation(DecryptField.class).value();                    // 控制台输出                    System.out.println(desensitizationEnum);                    // 根据不同的value值 我们可以对字段进行不同逻辑的脱敏 比如姓名脱敏-魏*,手机号脱敏-187****2275                 }            }        }    }}

反射实战

创建UserBO类

package com.weige.javaskillpoint.entity;
import com.weige.javaskillpoint.annotation.EncryptField;
import java.lang.reflect.Field;
// 用户信息新增实体类public class UserBO {    @EncryptField    private String name;
    @EncryptField    private String address;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public String getAddress() {        return address;    }
    public void setAddress(String address) {        this.address = address;    }
    public UserBO(String name, String address) {        this.name = name;        this.address = address;    }
    @Override    public String toString() {        return "UserBO{" +                "name='" + name + '\'' +                ", address='" + address + '\'' +                '}';    }
    public static void main(String[] args) throws IllegalAccessException {        UserBO userBO = new UserBO("周传雄","湖北省武汉市");        Field[] fields = userBO.getClass().getDeclaredFields();        for (Field field : fields) {            boolean annotationPresent = field.isAnnotationPresent(EncryptField.class);            if(annotationPresent){                // 当前字段内容不为空                if(field.get(userBO) != null){                    // 这里对字段内容进行加密                    Object obj = encrypt(field.get(userBO));                    // 字段内容加密过后 通过反射重新赋给该字段                    field.set(userBO, obj);                }            }        }        System.out.println(userBO);    }
    public static Object encrypt(Object obj){        return "加密: " + obj;    }}

AOP实战

切入点：

package com.weige.javaskillpoint.controller;
import com.weige.javaskillpoint.annotation.Encryption;import com.weige.javaskillpoint.entity.UserBO;import lombok.extern.slf4j.Slf4j;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
@RestController@RequestMapping("/encrypt")@Slf4jpublic class EncryptController {
    @PostMapping("/v1")    @Encryption  // 切入点    public UserBO insert(@RequestBody UserBO user) {        log.info("加密后对象：{}", user);        return user;    }}

切面：

package com.weige.javaskillpoint.aop;
import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;
@Slf4j@Aspect@Componentpublic class EncryptAspect {
    //拦截需加密注解 切入点    @Pointcut("@annotation(com.weige.javaskillpoint.annotation.Encryption)")    public void point() {
    }
    @Around("point()") //环绕通知    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {        //加密逻辑处理        encrypt(joinPoint);        return joinPoint.proceed();    }
}

为什么这里要使用AOP：无论是注解，反射，都需要一个启动方法，我上面演示的是通过main函数来启动。使用AOP，项目启动后，只要调用切入点对应的方法，就会根据切入点来形成一个切面，进行统一的逻辑增强；如果大家熟悉SpringMVC，SpringMVC提供了 ResponseBodyAdvice 和 RequestBodyAdvice两个接口，这两个接口可以对请求和响应进行预处理，就可以不需要使用AOP；

加密解密脱敏实战

项目目录：

图片

pom.xml文件：

<dependencies>        <!--Springboot项目自带 -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter</artifactId>        </dependency>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-test</artifactId>            <scope>test</scope>        </dependency>        <!--Springboot Web项目 -->        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-web</artifactId>        </dependency>
        <!--lombok -->        <dependency>            <groupId>org.projectlombok</groupId>            <artifactId>lombok</artifactId>            <version>1.18.22</version>        </dependency>
        <!-- hutool  -->        <dependency>            <groupId>cn.hutool</groupId>            <artifactId>hutool-all</artifactId>            <version>5.7.20</version>        </dependency>
    <!-- 切面 aop  -->        <dependency>            <groupId>org.aspectj</groupId>            <artifactId>aspectjweaver</artifactId>            <version>1.9.7</version>        </dependency>    </dependencies>
实体类

用户信息新增实体类 ：UserBO

package com.weige.javaskillpoint.entity;
import com.weige.javaskillpoint.annotation.EncryptField;
// 实体类public class UserBO {    @EncryptField    private String name;
    @EncryptField    private String address;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public String getAddress() {        return address;    }
    public void setAddress(String address) {        this.address = address;    }
    public UserBO(String name, String address) {        this.name = name;        this.address = address;    }
    @Override    public String toString() {        return "UserBO{" +                "name='" + name + '\'' +                ", address='" + address + '\'' +                '}';    }}

用户信息返回实体类 ：UserDO

package com.weige.javaskillpoint.entity;
import com.weige.javaskillpoint.annotation.DecryptField;import com.weige.javaskillpoint.enums.DesensitizationEnum;
// 实体类public class UserDO {
    @DecryptField(DesensitizationEnum.name)    private String name;
    @DecryptField(DesensitizationEnum.address)    private String address;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public String getAddress() {        return address;    }
    public void setAddress(String address) {        this.address = address;    }
    public UserDO(String name, String address) {        this.name = name;        this.address = address;    }}

脱敏枚举

package com.weige.javaskillpoint.enums;
public enum DesensitizationEnum {    name,    address,    phone;}
注解

解密字段注解（字段）：

package com.weige.javaskillpoint.annotation;
import com.weige.javaskillpoint.enums.DesensitizationEnum;
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)public @interface DecryptField {    DesensitizationEnum value();}

解密方法注解（方法 作切入点）：

package com.weige.javaskillpoint.annotation;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface Decryption {
}

加密字段注解（字段）：

package com.weige.javaskillpoint.annotation;
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)public @interface EncryptField {
}

加密方法注解（方法 作切入点）：

package com.weige.javaskillpoint.annotation;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface Encryption {
}
控制层

解密 Controller：

package com.weige.javaskillpoint.controller;
import com.weige.javaskillpoint.annotation.Decryption;import com.weige.javaskillpoint.entity.UserDO;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
@RestController@RequestMapping("/decrypt")public class DecryptController {
    @GetMapping("/v1")    @Decryption    public UserDO decrypt() {        return new UserDO("7c29e296e92893476db5f9477480ba7f", "b5c7ff86ac36c01dda45d9ffb0bf73194b083937349c3901f571d42acdaa7bae");    }
}

加密 Controller：

package com.weige.javaskillpoint.controller;
import com.weige.javaskillpoint.annotation.Encryption;import com.weige.javaskillpoint.entity.UserBO;import lombok.extern.slf4j.Slf4j;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;
@RestController@RequestMapping("/encrypt")@Slf4jpublic class EncryptController {
    @PostMapping("/v1")    @Encryption    public UserBO insert(@RequestBody UserBO user) {        log.info("加密后对象：{}", user);        return user;    }}
切面

解密脱敏切面：

package com.weige.javaskillpoint.aop;
import com.weige.javaskillpoint.annotation.DecryptField;import com.weige.javaskillpoint.enums.DesensitizationEnum;import com.weige.javaskillpoint.utils.AesUtil;import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;
import java.lang.reflect.Field;import java.util.ArrayList;import java.util.Collection;import java.util.List;import java.util.Objects;
@Slf4j@Aspect@Componentpublic class DecryptAspect {    //拦截需解密注解    @Pointcut("@annotation(com.weige.javaskillpoint.annotation.Decryption)")    public void point() {
    }
    @Around("point()")    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {        //解密        return decrypt(joinPoint);    }
    public Object decrypt(ProceedingJoinPoint joinPoint) {        Object result = null;        try {            Object obj = joinPoint.proceed();            if (obj != null) {                //抛砖引玉 ，可自行扩展其他类型字段的判断                if (obj instanceof String) {                    decryptValue();                } else {                    result = decryptData(obj);                }            }        } catch (Throwable e) {            e.printStackTrace();        }        return result;    }
    private Object decryptData(Object obj) throws IllegalAccessException {
        if (Objects.isNull(obj)) {            return null;        }        if (obj instanceof ArrayList) {            decryptList(obj);        } else {            decryptObj(obj);        }        return obj;    }
    private void decryptObj(Object obj) throws IllegalAccessException {        Field[] fields = obj.getClass().getDeclaredFields();        for (Field field : fields) {            boolean hasSecureField = field.isAnnotationPresent(DecryptField.class);            if (hasSecureField) {                field.setAccessible(true);                if (field.get(obj) != null) {                    String realValue = (String) field.get(obj);                    DesensitizationEnum desensitizationEnum = field.getAnnotation(DecryptField.class).value();                    String value = (String) AesUtil.decrypt(realValue,desensitizationEnum);                    field.set(obj, value);                }            }        }    }
    private void decryptList(Object obj) throws IllegalAccessException {        List<Object> result = new ArrayList<>();        if (obj instanceof ArrayList) {            result.addAll((Collection<?>) obj);        }        for (Object object : result) {            decryptObj(object);        }    }
    private void decryptValue() {        log.info("根据对象进行解密脱敏，单个字段不做处理！");    }


}

加密切面：

package com.weige.javaskillpoint.aop;
import com.weige.javaskillpoint.annotation.EncryptField;import com.weige.javaskillpoint.entity.UserBO;import com.weige.javaskillpoint.utils.AesUtil;import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
@Slf4j@Aspect@Componentpublic class EncryptAspect {
    //拦截需加密注解    @Pointcut("@annotation(com.weige.javaskillpoint.annotation.Encryption)")    public void point() {
    }
    @Around("point()")    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {        //加密        encrypt(joinPoint);        return joinPoint.proceed();    }
    public void encrypt(ProceedingJoinPoint joinPoint) {        Object[] objects;        try {            objects = joinPoint.getArgs();            if (objects.length != 0) {                for (Object object : objects) {                    if (object instanceof UserBO) {                        Field[] fields = object.getClass().getDeclaredFields();                        for (Field field : fields) {                            if (field.isAnnotationPresent(EncryptField.class)) {                                field.setAccessible(true);                                if (field.get(object) != null) {                                    // 进行加密                                    Object o = field.get(object);                                    Object encrypt = AesUtil.encrypt(field.get(object));                                    field.set(object, encrypt);                                }                            }                        }                    }                }            }        } catch (Exception e) {            log.error(e.getMessage());        }    }}
工具类

加密工具类：AesUtil

package com.weige.javaskillpoint.utils;
import cn.hutool.core.util.CharsetUtil;import cn.hutool.crypto.SecureUtil;import cn.hutool.crypto.symmetric.AES;import com.weige.javaskillpoint.enums.DesensitizationEnum;
public class AesUtil {
    // 默认16位 或 128 256位    public static String AES_KEY = "Wk#qerdfdshbd910";
    public static AES aes = SecureUtil.aes(AES_KEY.getBytes());
    public static Object encrypt(Object obj) {        return aes.encryptHex((String) obj);    }
    public static Object decrypt(Object obj, DesensitizationEnum desensitizationEnum) {        // 解密        Object decrypt = decrypt(obj);        // 脱敏        return DesensitizationUtil.desensitization(decrypt, desensitizationEnum);    }
    public static Object decrypt(Object obj) {        return aes.decryptStr((String) obj, CharsetUtil.CHARSET_UTF_8);    }
}

脱敏工具类：DesensitizationUtil

package com.weige.javaskillpoint.utils;
import cn.hutool.core.util.StrUtil;import com.weige.javaskillpoint.enums.DesensitizationEnum;
public class DesensitizationUtil {

    public static Object desensitization(Object obj, DesensitizationEnum desensitizationEnum) {        Object result;        switch (desensitizationEnum) {            case name:                result = strUtilHide(obj, 1);                break;            case address:                result = strUtilHide(obj, 3);                break;            default:                result = "";        }        return result;    }
    /**     * start从0开始     */    public static Object strUtilHide(String obj, int start, int end) {        return StrUtil.hide(obj, start, end);    }
    public static Object strUtilHide(Object obj, int start) {        return strUtilHide(((String) obj), start, ((String) obj).length());    }
}

完结

以上代码不难，大伙复制到本地跑一遍，基本就能理解；愿每一位程序员少走弯路！

竹林幽深
关注
【微服务】springboot 自定义注解+反射+aop实现动态修改请求参数
congge
09-01 9064
springboot 动态修改请求参数常用方案
AOP实现注解式脱敏数据明文查询
回炉重造P的博客
08-22 1079
最近又遇到了脱敏数据查询相关的问题，常规的脱敏数据比如用户身份证将中间位数抹去后加入数据库，那么查询时需要手动调用就比较麻烦，不过可以使用自定义注解，利用AOP解析后在切面将数据加密再作为参数注入运行，实现非入侵的脱敏数据明文查询。简单记录一下。
spring MVC 对 ResponseBody返回json数据进行脱敏处理
05-01
NULL 博文链接：https://coocaobo.iteye.com/blog/2410629
springmvc-数据脱敏
dark
08-06 2885
在项目开发过程中，通常会有一些敏感字段如：电话号码，身份证，email等信息，不想完整暴露给客户端，这里就需要用到数据脱敏. 常见的脱敏手段有: 数据库编写脱敏函数 mybatis编写脱敏拦截器 今天来介绍一种新思路。 基于ResponseBodyAdvice来实现,关于ResponseBodyAdvice在之前的文章SpringMVC-特性annotation中有介绍,这里不再赘述. pub...
springboot使用aop或Jackson进行数据脱敏
最新发布
qq_40323503的博客
08-15 565
启动类加@EnableAspectJAutoProxy自定义注解，在实体类中使用表示被脱敏字段建立aop切面类可能这里gpt会建议你用@Pointcut("execution(public * com.xx.aop..*.get*(..))")这种方式拦截，这种我试了，拦截不住。猜测在mvc返回的时候，已经不被aop拦住了，除非手动调用。并且get方式还要user成为bean，不值当。直接拦截controller包吧。
springboot aop方式实现敏感数据自动加解密
qq_42077317的博客
08-23 876
也就是脱敏，比如像手机号、身份证号等信息。如果我们只是在接口返回后再去做替换处理，则代码会显得非常冗余，那么实际可以通过注解的方式实现数据脱敏。在实际项目开发中，可能会涉及到一些敏感信息，那么我们就需要对这些敏感信息进行加密处理，3.定义一个在字段上，且有值的注解。4.定义一个在字段上，且有值的注解。1.定义一个标记于方法上的注解。2.定义一个数据解密的注解。5.定义用户返回的实体类。6.定义AOP注解实现。8.接着就可以测试了。
基于springboot使用aop指定接口自动解密前端加密参数
m0_57485150的博客
08-18 560
基于springboot使用aop指定接口自动解密前端加密参数
Spring boot结合aop实现请求参数AES加解密
qq_42875353的博客
08-23 865
Aspect@Component@Resource//这里写需要切入的类//获取传入目标方法的参数//获取代理方法的参数//获取参数名if (null!//这里写你需要加密解密的方法参数 目前方法参数是实体类//例如//这里写方法参数对象的属性//加密//此时 方法参数的userId值就变成了加密后的数据 解密也是这个逻辑以上是楼主的业务场景，希望可以帮到大家。
springboot项目通过自定义注解+aop实现对入参加解密
k_x_sh的博客
10-30 843
【代码】springboot项目通过自定义注解+aop实现对入参加解密。
【SpringBoot组件】基于SpringMVC注解 使用AOP对http接口请求响应参数加解密 数据脱敏 @Security @Sensitive
肥宅友的博客
08-01 1482
对SpringWeb项目中SpringMVC注解的接口参数进行脱敏与加解密，仅限于Http请求中字符串类型的参数数据生效，可进行充分扩展，可自进行定义脱敏、加解密等。
springmvc log4j2 logback 注解 jackson 日志脱敏实现源码
12-30
几乎是网上 能找到的 日志脱敏的所有实现 1、基于正则表达式的 日志脱敏实现 ，扩展logback 、log4j 2、springmvc 返回报文脱敏。 3、基于注解方式的脱敏。 大家选择使用。
springboot spring aop 拦截器注解方式实现脱敏
02-13
springboot spring aop 拦截器 注解方式实现脱敏（涉及到：pom.xml -->application.properties --->启动类-->拦截器）
关于数据脱敏的两种解决方案之二基于springmvc json处理时候的数据脱敏
傻根她弟
08-30 2317
接上一篇 关于数据脱敏的两种解决方案之一基于mybatis Interceptor的脱敏 这里只写基于springmvc json处理类 继承alibaba.fastjson import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Arrays; import java.util.List;...
数据脱敏（基于Springboot）
Alon的博客
02-14 515
讲解了数据脱敏的使用以及实现简单数据脱敏具体实例
Spring Boot应用之数据加密以及字段过滤
热门推荐
jeff's blog
10-23 1万+
1、应用背景在使用Spring Boot开发基于restful类型的API时，对于返回的JSON数据我们经常需要对数据进行加密，有的时候我们还必须过滤掉一些对象字段的值来减少网络流量2、解决方案1）加密对返回的数据进行加密，我们必须对spring boot返回json数据前对数据进行拦截和加密处理，为了方便api调用解析还原数据，我们采用双向加密的方式，因为客户端需要解密为明文，加密的使用java本
Java实战：Spring Boot通过JsonSerializer和Aop实现可控制的数据脱敏
oandy0的博客
02-27 1150
本文将详细介绍如何在Spring Boot应用程序中通过JsonSerializer和Aop实现可控制的数据脱敏。我们将探讨数据脱敏的基本概念，以及如何使用Spring Boot的JsonSerializer和Aop来实现数据脱敏功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值