MyBatis Plus 数据库字段加密处理

已于 2023-02-24 15:10:24 修改
阅读量6.5k 收藏 20
点赞数 6
分类专栏： Java 文章标签： mybatis 数据库 java
于 2023-02-23 11:28:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33204709/article/details/129178188
版权

目录

1.场景介绍

  • 当项目开发到一半，可能突然客户会要求对数据库里面比如手机号、身份证号的字段进行加密；
  • 在保证开发最快、影响范围最小的情况下，我们需要选择一种介于数据库和代码之间的工具来帮我们实现自动加解密；

2.Maven依赖

<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.1</version>
</dependency>

<!-- mybatis的分页插件 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.11</version>
    <!-- pagehelper 包含该依赖存在版本冲突，因此不建议和 mp 一起混用 -->
    <exclusions>
        <exclusion>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
        </exclusion>
    </exclusions>
</dependency>

2.AESUtil.java 加解密工具类

这里我们选用AES对称加密算法，因为它是可逆算法。

AES加密介绍： https://blog.csdn.net/qq_33204709/article/details/126930720

具体实现代码如下：

import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.Base64Utils;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * AES加密工具类
 *
 * @author ACGkaka
 * @since 2021-06-18 19:11:03
 */
public class AESUtil {
    /**
     * 日志相关
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(AESUtil.class);
    /**
     * 编码
     */
    private static final String ENCODING = "UTF-8";
    /**
     * 算法定义
     */
    private static final String AES_ALGORITHM = "AES";
    /**
     * 指定填充方式
     */
    private static final String CIPHER_PADDING = "AES/ECB/PKCS5Padding";
    private static final String CIPHER_CBC_PADDING = "AES/CBC/PKCS5Padding";
    /**
     * 偏移量(CBC中使用，增强加密算法强度)
     */
    private static final String IV_SEED = "1234567812345678";

    /**
     * AES加密
     * @param content 待加密内容
     * @param aesKey  密码
     * @return
     */
    public static String encrypt(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES encrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置加密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
                //选择加密
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
                //根据待加密内容生成字节数组
                byte[] encrypted = cipher.doFinal(content.getBytes(ENCODING));
                //返回base64字符串
                return Base64Utils.encodeToString(encrypted);
            } catch (Exception e) {
                LOGGER.info("AES encrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }

        }else {
            LOGGER.info("AES encrypt: the aesKey is null or error!");
            return null;
        }
    }

    /**
     * 解密
     * 
     * @param content 待解密内容
     * @param aesKey  密码
     * @return
     */
    public static String decrypt(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES decrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置解密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_PADDING);
                //选择解密
                cipher.init(Cipher.DECRYPT_MODE, skeySpec);

                //先进行Base64解码
                byte[] decodeBase64 = Base64Utils.decodeFromString(content);

                //根据待解密内容进行解密
                byte[] decrypted = cipher.doFinal(decodeBase64);
                //将字节数组转成字符串
                return new String(decrypted, ENCODING);
            } catch (Exception e) {
                LOGGER.info("AES decrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }

        }else {
            LOGGER.info("AES decrypt: the aesKey is null or error!");
            return null;
        }
    }

    /**
     * AES_CBC加密
     * 
     * @param content 待加密内容
     * @param aesKey  密码
     * @return
     */
    public static String encryptCBC(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES_CBC encrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置加密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_CBC_PADDING);
                //偏移
                IvParameterSpec iv = new IvParameterSpec(IV_SEED.getBytes(ENCODING));
                //选择加密
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
                //根据待加密内容生成字节数组
                byte[] encrypted = cipher.doFinal(content.getBytes(ENCODING));
                //返回base64字符串
                return Base64Utils.encodeToString(encrypted);
            } catch (Exception e) {
                LOGGER.info("AES_CBC encrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }

        }else {
            LOGGER.info("AES_CBC encrypt: the aesKey is null or error!");
            return null;
        }
    }

    /**
     * AES_CBC解密
     * 
     * @param content 待解密内容
     * @param aesKey  密码
     * @return
     */
    public static String decryptCBC(String content, String aesKey){
        if(StringUtils.isBlank(content)){
            LOGGER.info("AES_CBC decrypt: the content is null!");
            return null;
        }
        //判断秘钥是否为16位
        if(StringUtils.isNotBlank(aesKey) && aesKey.length() == 16){
            try {
                //对密码进行编码
                byte[] bytes = aesKey.getBytes(ENCODING);
                //设置解密算法，生成秘钥
                SecretKeySpec skeySpec = new SecretKeySpec(bytes, AES_ALGORITHM);
                //偏移
                IvParameterSpec iv = new IvParameterSpec(IV_SEED.getBytes(ENCODING));
                // "算法/模式/补码方式"
                Cipher cipher = Cipher.getInstance(CIPHER_CBC_PADDING);
                //选择解密
                cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);

                //先进行Base64解码
                byte[] decodeBase64 = Base64Utils.decodeFromString(content);

                //根据待解密内容进行解密
                byte[] decrypted = cipher.doFinal(decodeBase64);
                //将字节数组转成字符串
                return new String(decrypted, ENCODING);
            } catch (Exception e) {
                LOGGER.info("AES_CBC decrypt exception:" + e.getMessage());
                throw new RuntimeException(e);
            }

        }else {
            LOGGER.info("AES_CBC decrypt: the aesKey is null or error!");
            return null;
        }
    }

    public static void main(String[] args) {
        // AES支持三种长度的密钥：128位、192位、256位。
        // 代码中这种就是128位的加密密钥，16字节 * 8位/字节 = 128位。
        String random = RandomStringUtils.random(16, "abcdefghijklmnopqrstuvwxyz1234567890");
        System.out.println("随机key:" + random);
        System.out.println();

        System.out.println("---------加密---------");
        String aesResult = encrypt("测试AES加密12", random);
        System.out.println("aes加密结果:" + aesResult);
        System.out.println();

        System.out.println("---------解密---------");
        String decrypt = decrypt(aesResult, random);
        System.out.println("aes解密结果:" + decrypt);
        System.out.println();


        System.out.println("--------AES_CBC加密解密---------");
        String cbcResult = encryptCBC("测试AES加密12456", random);
        System.out.println("aes_cbc加密结果:" + cbcResult);
        System.out.println();

        System.out.println("---------解密CBC---------");
        String cbcDecrypt = decryptCBC(cbcResult, random);
        System.out.println("aes解密结果:" + cbcDecrypt);
        System.out.println();
    }
}

3.字段处理类

import com.demo.util.AESUtil;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * <p> @Title MyEncryptTypeHandler
 * <p> @Description 字段加密处理
 *
 * @author ACGkaka
 * @date 2023/2/21 17:20
 */
public class MyEncryptTypeHandler extends BaseTypeHandler<String> {
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, AESUtil.defaultEncrypt(parameter));
    }

    @Override
    public String getNullableResult(ResultSet rs, String column) throws SQLException {
        return AESUtil.defaultDecrypt(rs.getString(column));
    }

    @Override
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return AESUtil.defaultDecrypt(rs.getString(columnIndex));
    }

    @Override
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return AESUtil.defaultDecrypt(cs.getString(columnIndex));
    }
}

4.修改 MyBatis Plus 查询

4.1 修改表对应实体类

设置 @TableName 注解的 autoResultMap 为 true，默认 false。

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;

/**
 * 用户表
 *
 * @author ACGkaka
 * @date 2023/2/21 17:20
 */
@Data
@TableName(value = "t_user_info", autoResultMap = true)
public class UserInfo implements Serializable {}

4.2 修改加密字段对应属性

设置 @TableField 注解的 typeHandler 为 MyEncryptTypeHandler.class。

import com.demo.encrypt.MyEncryptTypeHandler;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;

/**
 * 用户表
 *
 * @author ACGkaka
 * @date 2023/2/21 17:20
 */
@Data
@TableName(value = "t_user_info", autoResultMap = true)
public class UserInfo implements Serializable {
    /**
     * 手机号码
     */
    @TableField(value = "PHONE", typeHandler = MyEncryptTypeHandler.class)
    private String phone;
}

4.3 修改 xml 使用 ResultMap

1）创建 ResultMap 映射，指定 typeHandler；

2）查询语句使用 ResultMap 返回。

<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.demo.model.UserInfo">
    <id column="ID" property="id" />
    <result column="ACCOUNT" property="staffCode" />
    <result column="PHONE" property="phone" typeHandler="com.demo.encrypt.MyEncryptTypeHandler" />
</resultMap>

<!-- 查询全部 -->
<select id="findAll" resultMap="BaseResultMap">
    SELECT * FROM t_user_info
</select>

4.4 修改 xml 中 el 表达式

设置好 4.1 和 4.2 就可以保证

修改前：

<!-- 更新手机号 -->
<update id="updatePhoneById">
    update t_user_info set phone = #{phone} where id = #{id}
</update>

<!-- 根据手机号查询 -->
<select id="findByPhone" resultMap="BaseResultMap">
    SELECT * FROM t_user_info where phone = #{phone}
</select>

修改后：

<!-- 更新手机号 -->
<update id="updatePhoneById">
    update t_user_info set phone = #{phone, typeHandler=com.demo.encrypt.MyEncryptTypeHandler} where id = #{id}
</update>

<!-- 根据手机号查询 -->
<select id="findByPhone" resultMap="BaseResultMap">
    SELECT * FROM t_user_info where phone = #{phone, typeHandler=com.demo.encrypt.MyEncryptTypeHandler}
</select>

5.测试结果

由于测试内容较多，这里先直接展示测试结果，具体测试示例可以看 补充：测试实例

操作实现方式入参测试结果
SELECT原生SQL非加密字段出参解密成功
SELECTQueryWrapper非加密字段出参解密成功
SELECT原生SQL加密字段入参加密成功
SELECTQueryWrapper加密字段入参加密失败
UPDATE原生SQL加密字段入参加密成功
UPDATEUpdateWrapper加密字段入参加密失败
UPDATELambdaUpdateWrapper加密字段入参加密成功
UPDATEupdateById加密字段入参加密成功
INSERTService加密字段入参加密成功

说明：

  • 官方的解答是 QueryWrapper、UpdateWrapper 底层是通过 @Param 来实现的，目前没有做到入参支持 typeHandler，如果做的话会影响性能。
  • LambdaUpdateWrapper 要求 MyBatis-Plus 版本为 3.5.3，PageHelper 也需要升级为 5.1.11，但是升级之后 PageHelper 分页不好使了，待优化。（升级后依赖参考 补充：2.3）

6.MyBatis Plus 缺陷

  • QueryWrapper 不支持入参加密；

  • UpdateWrapper 不支持入参加密；

  • 加密字段不支持模糊查询。

7.历史数据加密处理程序

@Override
public void encryptUser() {
    // 加密 用户信息
    int count = this.count();
    int pageSize = 1000;
    int pageCount = count / pageSize + 1;
    // 必须用唯一且非空字段进行排序，否则 pageHelper 查出来的数据可能会有重复。
    QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>().orderByAsc("id");
    for (int i = 0; i < pageCount; i++) {
        log.info(">>>>>>>>>> 【INFO】加密用户信息，当前页数:{}，总页数:{}", i + 1, pageCount);
        PageHelper.startPage(i + 1, pageSize);
        List<UserInfo> users = this.list(queryWrapper);
        new PageInfo<>(users);
        users.parallelStream().forEach(o -> {
            // 解密重复加密手机号
            while (AESUtil.defaultDecrypt(o.getPhoneNumber()) != null) {
                o.setPhoneNumber(AESUtil.defaultDecrypt(o.getPhoneNumber()));
            }
            // 解密重复加密身份证号
            while (AESUtil.defaultDecrypt(o.getIdCard()) != null) {
                o.setIdCard(AESUtil.defaultDecrypt(o.getIdCard()));
            }
        });
        this.updateBatchById(users);
    }
}

一般手机号AES加密后长度为32，我们可以根据这点通过SQL检查加密情况：

select '未加密数量' state, COUNT(*) from t_user_info where length(phone_number) < 32 
union all
select '重复加密数量' state, COUNT(*)  from t_user_info where length(phone_number) > 32;

补充：测试实例

1 查询测试

1.1 查询信息，SQL实现
@Test
public void getUserInfoTest1() {
    UserInfo userInfo = userInfoService.findByAccount("testAccount");
    System.out.println("userInfo:" + userInfo);
    System.out.println("phone:" + userInfo.getPhone());
}

测试结果：出参解密成功

1.2 查询信息，QueryWrapper实现
@Test
public void getUserInfoTest2() {
    QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
    wrapper.eq("account", "testAccount");
    List<UserInfo> users = userInfoService.list(wrapper);
    System.out.println("userInfo:" + users);
    System.out.println("phone:" + users.get(0).getPhone());
}

测试结果：出参解密成功

1.3 查询信息，根据加密字段查询，SQL实现
@Test
public void getUserInfoTest3() {
    UserInfo user = userInfoService.findByPhone("13888888888");
    System.out.println("userInfo:" + user);
    System.out.println("phone:" + user.getPhone());
}

（注意：入参需要使用el表达式指定 typeHandler）

测试结果：入参加密成功

1.4 查询信息，根据加密字段查询，QueryWrapper实现
@Test
public void getUserInfoTest3() {
    QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
    wrapper.lambda().eq(UserInfo::getPhone, "13888888888");
    List<UserInfo> users = userInfoService.list(wrapper);
    System.out.println("userInfo:" + users);
    System.out.println("phone:" + users.get(0).getPhone());
}

测试结果：入参加密失败，QueryWrapper底层使用 @Param 实现，无法像 SQL 实现一样指定 typeHandler。

2.测试更新

2.1 更新信息，SQL实现
@Test
public void updateUserInfoTest1() {
    userInfoService.updatePhoneByAccount("testAccount", "13888888888");
}

测试结果：入参加密成功

2.2 更新信息，UpdateWrapper实现
@Test
public void updateUserInfoTest2() {
    UpdateWrapper<UserInfo> wrapper = new UpdateWrapper<>();
    wrapper.set("phone", "13888888888");
    wrapper.eq("account", "testAccount");
    userInfoService.update(wrapper);
    getUserInfoTest1();
}

测试结果：入参加密失败，UpdateWrapper底层使用 @Param 实现，无法像 SQL 实现一样指定 typeHandler。

2.3 更新信息，LambdaUpdateWrapper实现
@Test
public void updateUserInfoTest3() {
    LambdaUpdateWrapper<UserInfo> wrapper = Wrappers.<UserInfo>lambdaUpdate()
            .set(UserInfo::getPhone, "13888888888", "typeHandler=com.demo.encrypt.MyEncryptTypeHandler");
    wrapper.eq(UserInfo::getAccount, "testAccount");
    userInfoService.update(wrapper);
    getUserInfoTest1();
}

测试结果：入参加密成功（3.5.3支持，但是升级之后 PageHelper 分页不好使了，待优化）

升级后依赖：

<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.3</version>
</dependency>

<!-- mybatis的分页插件 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.11</version>
    <!-- pagehelper 包含该依赖存在版本冲突，因此不建议和 mp 一起混用 -->
    <exclusions>
        <exclusion>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
        </exclusion>
    </exclusions>
</dependency>
2.4 更新信息，updateById实现
@Test
public void updateUserInfoTest4() {
    UserInfo userInfo = userInfoService.findByAccount("testAccount");
    userInfo.setPhone("13888888888");
    userInfoService.updateById(userInfo);
}

测试结果：入参加密成功

3.测试插入

7.3.1 插入信息，SQL实现
@Test
public void insertUserInfoTest1() {
    UserInfo userInfo = userInfoService.findByAccount("testAccount");
    userInfo.setAccount("testAccount_002");
    userInfo.setPhone("13888888888");
    userInfoService.save(userInfo);
    UserInfo newUserInfo = userInfoService.findByAccount("testAccount_002");
    System.out.println("userInfo:" + newUserInfo);
    System.out.println("phone:" + newUserInfo.getPhone());
}

测试结果：入参加密成功

3.2 插入信息，Service实现
@Test
public void insertUserInfoTest1() {
    UserInfo userInfo = userInfoService.findByAccount("testAccount");
    userInfo.setAccount("testAccount_002");
    userInfo.setPhone("13888888888");
    userInfoService.save(userInfo);
    UserInfo newUserInfo = userInfoService.findByAccount("testAccount_002");
    System.out.println("userInfo:" + newUserInfo);
    System.out.println("phone:" + newUserInfo.getPhone());
}

测试结果：入参加密成功

整理完毕，完结撒花~





参考地址：

1.mybaits plus 字段加密与解密，https://blog.csdn.net/qq_21134059/article/details/121752978

2.mybatis plus 官方问题页面，https://github.com/baomidou/mybatis-plus/issues

3.更新时自定义的TypeHandler不生效，https://github.com/baomidou/mybatis-plus/issues/794

4.lambdaUpdate() 无法更新Json对象字段，https://github.com/baomidou/mybatis-plus/issues/5031

5.LambdaUpdateWrapper不支持自定义BaseTypeHandler，https://github.com/baomidou/mybatis-plus/issues/3317

不愿放下技术的小赵
关注
专栏目录
【SpringBoot】95、SpringBoot中使用MyBatis-Plus实现自动加密存储和查询自动解密
Asurplus
07-11 495
有的业务需要将敏感数据加密存储到 DB，如果我们每个都手动去加密，再设值，再保存 DB，不仅麻烦，还对每个开发者不友好，在 MyBatis-Plus 中我们可以使用 BaseTypeHandler 来解决这个问题
通过mybatis自定义参数类型转换器，进行数据库字段加密脱敏
m0_71777195的博客
09-02 1516
通过自定义Java类型和类型转换器，并在mapper.xml里标注类型，通过mybatis进行加解密。加密算法可自由选择开发维护比较简单方便不存在适配多种数据库的问题创建一个空白类，在mapper.xml文件查询和新增修改时标注说明，表示需要mybatis进行相关类型转换。}复制代码这里使用国密SM4进行加解密，当然算法可自由选择别的如AES等。@MappedTypes注解映射刚才的自定义Java类@Overridetry {}
mybatis-plus数据库字段信息加解密
bailegebai的博客
10-19 4893
在之前的文章中我们实现了springboot整合mybits-plus，并且配置了多数据源。接下来我们来实现一下敏感数据的保存并查询。
SpringBoot3.32+Sharding Sphere5.5+Mybatis-plus：轻松搞定数据加解密，支持字段级！
最新发布
竹林幽深
08-20 161
原创 路条编程2024年08月20日 08:02北京。
MybatisPlus优雅实现加密？
Evan_L的博客
05-17 1422
成也萧何，败也萧何。MybatisPlus优雅实现字段加解密方案让我吃了不少苦头。只因为他并不改造mybatis，只是提供一些特性。然而，这个方案使用的是半吊子的特性，导致有的方法生效，有的方法不生效，可谓是一言难尽。。。
后端记录 - mybait-plus字段入库加密，出库解密方案
大泡泡糖的博客
08-08 423
此时可以使用mybaits-plus再进行更新及插入时会自动加密，返回时自动解密。前端无感知，参数和返回值都是正常的数据，但数据库存储已自动加密。
mybatis-plus实现数据字段加解密
alan3258的专栏
04-13 1900
在需要加解密的实体类头部添加注解@EncryptedTable，同时在需要加解密的字段上添加@EncryptedField注解即可。
MyBatis-Plus 优雅实现数据加密存储
一碗清深的博客
02-22 3826
本文将基于Mybatis-Plus讲述如何在数据的源头存储层保障其安全。我们都知道一些核心私密字段，比如说密码，手机号等在数据库层存储就不能明文存储，必须加密存储保证即使数据库泄露了也不会轻易曝光数据。
mybaits plus 字段加密与解密
qq_21134059的博客
12-07 7270
mybaits plus 字段加密与解密 写在前面 在我们实际开发中有的时候需要保证数据的安全，那么这个时候我们就需要对我们存储的数据加密，数据加密可以用很多方法实现，比如数据库加密，java代码加密和orm框架加密等等。 思考这么多加密方式我们应该选择那种方式？ 1.数据库加密：主流数据库都提供了一系列的加密功能， ...
Mybatis plus 数据加密
csdn570566705的博客
02-24 6485
Mybatis plus 数据加密
mybatis plus数据库加密解密的
09-27
mybatis plus提供了字段加密与解密的功能。根据提供的测试结果，可以看出在不同的操作实现方式下，对于非加密字段的出参解密是成功的，而对于加密字段的入参加密成功的操作有选择性。具体来说，使用原生SQL时，对于...
Sptring Boot整合mybatis(连接数据库测试及md5加密)
11-08
SpringBoot简单项目开发，适应初学者，整合mybatis,页面简单测试，数据Md5加密
mybatis-plus数据库被加密的字段怎么模糊查询
05-27
如果你使用的是 Mybatis-Plus 3.x 版本，可以使用 `QueryWrapper` 的 `lambda` 条件构造器中的 `like` 方法实现模糊查询，例如： ...其中，`"encrypted_field"` 是你要查询的加密字段的数据库列名。
mybatis-plus数据库被加密的字段怎么sql模糊查询
05-27
如果你需要直接在 SQL 中实现模糊查询加密字段，可以使用数据库提供的加密函数，例如 MySQL 中的 `AES_ENCRYPT` 函数和 `AES_DECRYPT` 函数进行加密和解密。 假设你的加密字段名为 `encrypted_field`，加密使用的...
使用mybatis/mybatisPlus拦截器对数据库表字段加密
GuaGea的博客
11-08 804
对数据库表字段存储时进行加密解密
mybatis-plus 数据字段进行加解密入库，且加密字段支持模糊搜索
从零开始的博客
09-09 2504
需求很简单： 就是将数据存储到数据库，并且将敏感数据字段进行加密处理保存（比如：身份证，手机号，银行卡 等等）需求也很变态：加密的数据要模糊搜素！！如果需求不需要模糊搜素，直接加密入库就完事了，直接看这篇文章mybatis-plus进行数据字段加密解密入库，就可以了！工具类import cn/**/*** iktry {Lexeme le;= null) {} /*** 部分分词} }/**/*** ik。
通过mybatis-plus进行数据库字段加解密
ronshi的博客
05-09 949
通过mybatis-plus进行数据库字段加解密
在MyBatis-Plus中实现字段加密与解密
qq_38978882的博客
02-05 1883
在MyBatis-Plus中实现字段加密与解密
Mybatis-plus数据库表字段加解密存储
weixin_45906061的博客
08-05 6450
项目开发过程中，经常遇到敏感信息加密存储，如身份证号、手机号等，常规操作为存、取数据时对字段值进行单独加、解密处理，不利于维护且扩展性差，今天我们通过继承mybatis-plus（mybatis同样适用）提供的BaseTypeHandler类来统一解决此类问题。一、导入依赖（基于springboot），加密算法使用hutool包提供的AES，自行导入其他加密包也可。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不愿放下技术的小赵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值