脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → springboot 加密存储解密显示

springboot实现敏感字段加密存储解密显示功能

 更新时间：2022年02月25日 09:57:01   作者：灰太狼_cxh  
这篇文章主要介绍了springboot实现敏感字段加密存储，解密显示,通过mybatis,自定义注解+AOP切面，Base64加解密方式实现功能，本文通过代码实现给大家介绍的非常详细，需要的朋友可以参考下

springboot实现敏感字段加密存储，解密显示，通过mybatis,自定义注解+AOP切面，Base64加解密方式实现功能。

1.代码实现：

创建springboot项目

添加依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        <!--mysql数据库驱动-->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        <!--mybatis-->
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.6</version>

yml配置

server:
  port: 8081
spring:
  #数据库连接配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456
 
#mybatis的相关配置
mybatis:
  #mapper配置文件
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.cxh.mybatis.entity
  #开启驼峰命名
  configuration:
    map-underscore-to-camel-case: true

自定义注解

//表示要加密的字段
@Target({ElementType.FIELD,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface EncryptField {
 
    String[] value() default "";
}
//表示需解密
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedDecrypt {
 
}
//表示需加密
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedEncrypt {
}

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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.lang.reflect.Field;
import java.util.Objects;
//加密AOP
@Slf4j
@Aspect
@Component
public class EncryptAspect {
  
    //拦截需加密注解
    @Pointcut("@annotation(com.cxh.mybatis.test.NeedEncrypt)")
    public void pointCut() {
    }
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //加密
        encrypt(joinPoint);
        return joinPoint.proceed();
    public void encrypt(ProceedingJoinPoint joinPoint)  {
        Object[] objects=null;
        try {
            objects = joinPoint.getArgs();
            if (objects.length != 0) {
                for (int i = 0; i < objects.length; i++) {
                    //抛砖引玉 ，可自行扩展其他类型字段的判断
                    if (objects[i] instanceof String) {
                        objects[i] = encryptValue(objects[i]);
                    } else {
                        encryptObject(objects[i]);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    /**
     * 加密对象
     * @param obj
     * @throws IllegalAccessException
     */
    private void encryptObject(Object obj) throws IllegalAccessException {
        if (Objects.isNull(obj)) {
            log.info("当前需要加密的object为null");
            return;
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            boolean containEncryptField = field.isAnnotationPresent(EncryptField.class);
            if (containEncryptField) {
                //获取访问权
                field.setAccessible(true);
                if(field.get(obj) != null){
                    String value = Base64Util.getBase64(String.valueOf(field.get(obj)));
                    field.set(obj, value);
     * 加密单个值
     * @param realValue
     * @return
    public String encryptValue(Object realValue) {
            realValue = Base64Util.getBase64(String.valueOf(realValue));
            log.info("加密异常={}",e.getMessage());
        return String.valueOf(realValue);
}
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
//解密AOP
@Slf4j
@Aspect
@Component
public class DecryptAspect {
    //拦截需解密注解
    @Pointcut("@annotation(com.cxh.mybatis.test.NeedDecrypt)")
    public void pointCut() {
    }
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //解密
        Object result = decrypt(joinPoint);
        return result;
    public Object decrypt(ProceedingJoinPoint joinPoint) {
        Object result = null;
        try {
            Object obj = joinPoint.proceed();
            if (obj != null) {
                //抛砖引玉 ，可自行扩展其他类型字段的判断
                if (obj instanceof String) {
                    decryptValue(obj);
                } else {
                    result = decryptData(obj);
                }
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
    private Object decryptData(Object obj) throws IllegalAccessException {
        if (Objects.isNull(obj)) {
            return null;
        if (obj instanceof ArrayList) {
            decryptList(obj);
        } else {
            decryptObj(obj);
        return obj;
    /**
     * 针对单个实体类进行 解密
     * @param obj
     * @throws IllegalAccessException
     */
    private void decryptObj(Object obj) throws IllegalAccessException {
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            boolean hasSecureField = field.isAnnotationPresent(EncryptField.class);
            if (hasSecureField) {
                field.setAccessible(true);
                if(field.get(obj) != null) {
                    String realValue = (String) field.get(obj);
                    String value = Base64Util.getFromBase64(realValue);
                    field.set(obj, value);
     * 针对list<实体来> 进行反射、解密
    private void decryptList(Object obj) throws IllegalAccessException {
        List<Object> result = new ArrayList<>();
            for (Object o : (List<?>) obj) {
                result.add(o);
        for (Object object : result) {
            decryptObj(object);
    public String decryptValue(Object realValue) {
            realValue = Base64Util.getFromBase64(String.valueOf(realValue));
        } catch (Exception e) {
            log.info("解密异常={}", e.getMessage());
        return String.valueOf(realValue);
}

BASE64加解密工具类

import java.io.UnsupportedEncodingException;
 
import org.springframework.stereotype.Component;
import sun.misc.*;
public class Base64Util {
    // 加密
    public static String getBase64(String str) {
        byte[] b = null;
        String s = null;
        try {
            b = str.getBytes("utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        if (b != null) {
            s = new BASE64Encoder().encode(b);
        return s;
    }
    // 解密
    public static String getFromBase64(String s) {
        String result = null;
        if (s != null) {
            BASE64Decoder decoder = new BASE64Decoder();
            try {
                b = decoder.decodeBuffer(s);
                result = new String(b, "utf-8");
            } catch (Exception e) {
                e.printStackTrace();
            }
        return result;
    public static void main(String[] args) {
        String a = "123456";
        String b = getBase64(a);
        System.out.println(b);
        System.out.println(getBase64(a));
        System.out.println(getFromBase64(b));
}

控制层

@RestController
@RequestMapping("/user")
public class UserController {
 
    @Autowired
    private UserService userService;
    @RequestMapping("/findAll")
    public List<User> findAll(){
        return userService.findAll();
    }
    @RequestMapping("/add")
    @NeedEncrypt
    public int add(User user){
        return userService.add(user);
    @RequestMapping("/get")
    @NeedDecrypt
    public List<User> get(User user){
        return userService.get(user);
    @RequestMapping("/getByName")
    public List<User> getByName(String username){
        User user = new User();
       user.setUsername(Base64Util.getBase64(username));
}

service实现类

@Service("userService")
public class UserServiceimpl implements UserService {
 
    @Autowired
    private UserMapper userMapper;
    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }
    public Integer add(User user) {
        return userMapper.add(user);
    public List<User> get(User user) {
        return userMapper.get(user);
}

userMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.cxh.mybatis.mapper.UserMapper">
    <select id="findAll" resultType="User">
        SELECT * FROM tb_user
    </select>
 
    <insert id="add" parameterType="User">
        INSERT INTO tb_user(`id`, `username`, `password`) VALUES (#{id}, #{username}, #{password});
    </insert>
    <select id="get" resultType="User" parameterType="User">
        <where>
            <if test="id != null and id != ''">
             and   id = #{id}
            </if>
            <if test="username != null and username != ''">
                and  username = #{username}
            <if test="password != null and password != ''">
                and   password = #{password}
        </where>
</mapper>

2.实现效果：

运行项目，打开postman，发起插入请求：localhost:8081/user/add

查看数据库，显示数据已加密

 发起查询请求localhost:8081/user/get，显示数据已解密

  发起查询所有请求localhost:8081/user/findAll，由于该方法没有添加解密注解，所以数据还是加密的。

到此这篇关于springboot实现敏感字段加密存储，解密显示的文章就介绍到这了,更多相关springboot敏感字段加密存储解密显示内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • spring ioc的简单实例及bean的作用域属性解析

    spring ioc的简单实例及bean的作用域属性解析

    这篇文章主要介绍了spring ioc的简单实例及bean的作用域属性解析，具有一定借鉴价值,需要的朋友可以参考下
    2017-12-12
  • Java中Semaphore(信号量)的使用方法

    Java中Semaphore(信号量)的使用方法

    这篇文章主要介绍了Java中Semaphore(信号量)的使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-08-08
  • SpringMVC中的DispatcherServlet初始化流程详解

    SpringMVC中的DispatcherServlet初始化流程详解

    这篇文章主要介绍了SpringMVC中的DispatcherServlet初始化流程详解,DispatcherServlet这个前端控制器是一个Servlet,所以生命周期和普通的Servlet是差不多的,在一个Servlet初始化的时候都会调用该Servlet的init()方法,需要的朋友可以参考下
    2023-12-12
  • Spring创建IOC容器的方式解析

    Spring创建IOC容器的方式解析

    这篇文章主要介绍了Spring创建IOC容器的方式解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-10-10
  • springboot 通过代码自动生成pid的方法

    springboot 通过代码自动生成pid的方法

    这篇文章主要介绍了springboot 通过代码自动生成pid的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-07-07
  • 深入理解Spring Boot属性配置文件

    深入理解Spring Boot属性配置文件

    这篇文章主要给大家深入的介绍了关于Spring Boot属性配置文件的相关资料，文中介绍的很详细，相信对大家具有一定的参考借鉴价值，需要的朋友们下面来一起看看吧。
    2017-02-02
  • SpringBoot项目里集成Hibernate的示例

    SpringBoot项目里集成Hibernate的示例

    在Spring Boot项目中，集成Hibernate可以帮助我们更轻松地进行数据库操作，本文将介绍如何在Spring Boot项目中集成Hibernate，并提供相应的示例，感兴趣的朋友跟随小编一起看看吧
    2023-04-04
  • Java中Stream流中map和forEach的区别详解

    Java中Stream流中map和forEach的区别详解

    本文主要介绍了Java中Stream流中map和forEach的区别详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-04-04
  • spring boot项目fat jar瘦身的实现

    spring boot项目fat jar瘦身的实现

    这篇文章主要介绍了spring boot项目fat jar瘦身的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-06-06
  • Mybatis 如何开启控制台打印sql语句

    Mybatis 如何开启控制台打印sql语句

    这篇文章主要介绍了Mybatis 如何开启控制台打印sql语句问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-11-11

最新评论