AI 助理
备案控制台
开发者社区 数据库 文章 正文

Mybatis-Plus 拦截SQL语句实现加解密存储

2024-02-20 96
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
密钥管理服务KMS，1000个密钥，100个凭据，1个月
简介： Mybatis-Plus 拦截SQL语句实现加解密存储

定义加解密工具类

package com.tz.mybatisplus.common.util;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.Scanner;
/**
 * @author @醉鱼
 * @link https://github.com/TianPuJun
 * @ClassName AesUtils
 * @Description
 * @Date 19:58 2022/3/30
 **/
public class AesUtils {
    public static String AESEncode(String encodeRules, String content) {
        try {
            // 1.构造密钥生成器，指定为AES算法,不区分大小写
            KeyGenerator keygen = KeyGenerator.getInstance("AES");
            // 2.根据ecnodeRules规则初始化密钥生成器
            // 生成一个128位的随机源,根据传入的字节数组
            //keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(encodeRules.getBytes());
            keygen.init(128, secureRandom);
            // 3.产生原始对称密钥
            SecretKey original_key = keygen.generateKey();
            // 4.获得原始对称密钥的字节数组
            byte[] raw = original_key.getEncoded();
            // 5.根据字节数组生成AES密钥
            SecretKey key = new SecretKeySpec(raw, "AES");
            // 6.根据指定算法AES自成密码器
            Cipher cipher = Cipher.getInstance("AES");
            // 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
            cipher.init(Cipher.ENCRYPT_MODE, key);
            // 8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
            byte[] byte_encode = content.getBytes("utf-8");
            // 9.根据密码器的初始化方式--加密：将数据加密
            byte[] byte_AES = cipher.doFinal(byte_encode);
            // 10.将加密后的数据转换为字符串
            // 这里用Base64Encoder中会找不到包
            // 解决办法：
            // 在项目的Build path中先移除JRE System Library，再添加库JRE System Library，重新编译后就一切正常了。
            String AES_encode = new String(Base64.getEncoder().encodeToString(byte_AES));
            // 11.将字符串返回
            return AES_encode;
        } catch (NoSuchAlgorithmException e) {
        } catch (NoSuchPaddingException e) {
        } catch (InvalidKeyException e) {
        } catch (IllegalBlockSizeException e) {
        } catch (BadPaddingException e) {
        } catch (UnsupportedEncodingException e) {
        }
        // 如果有错就返加nulll
        return null;
    }
    /*
     * 解密 解密过程： 1.同加密1-4步 2.将加密后的字符串反纺成byte[]数组 3.将加密内容解密
     */
    public static String AESDecode(String encodeRules, String content) {
        try {
            // 1.构造密钥生成器，指定为AES算法,不区分大小写
            KeyGenerator keygen = KeyGenerator.getInstance("AES");
            // 2.根据ecnodeRules规则初始化密钥生成器
            // 生成一个128位的随机源,根据传入的字节数组
            //keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(encodeRules.getBytes());
            keygen.init(128, secureRandom);
            // 3.产生原始对称密钥
            SecretKey original_key = keygen.generateKey();
            // 4.获得原始对称密钥的字节数组
            byte[] raw = original_key.getEncoded();
            // 5.根据字节数组生成AES密钥
            SecretKey key = new SecretKeySpec(raw, "AES");
            // 6.根据指定算法AES自成密码器
            Cipher cipher = Cipher.getInstance("AES");
            // 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
            cipher.init(Cipher.DECRYPT_MODE, key);
            // 8.将加密并编码后的内容解码成字节数组
            byte[] byte_content = Base64.getDecoder().decode(content);
            /*
             * 解密
             */
            byte[] byte_decode = cipher.doFinal(byte_content);
            String AES_decode = new String(byte_decode, "utf-8");
            return AES_decode;
        } catch (NoSuchAlgorithmException e) {
        } catch (NoSuchPaddingException e) {
        } catch (InvalidKeyException e) {
        } catch (IOException e) {
        } catch (IllegalBlockSizeException e) {
        } catch (BadPaddingException e) {
        }
        // 如果有错就返加nulll
        return null;
    }
    public static void main(String[] args) {
        AesUtils se = new AesUtils();
        Scanner scanner = new Scanner(System.in);
        /*
         * 加密
         */
        System.out.println("使用AES对称加密，请输入加密的规则");
        String encodeRules = scanner.next();
        System.out.println("请输入要加密的内容:");
        String content = scanner.next();
        System.out.println("根据输入的规则" + encodeRules + "加密后的密文是:" + se.AESEncode(encodeRules, content));
        /*
         * 解密
         */
        System.out.println("使用AES对称解密，请输入加密的规则：(须与加密相同)");
        encodeRules = scanner.next();
        System.out.println("请输入要解密的内容（密文）:");
        content = scanner.next();
        System.out.println("根据输入的规则" + encodeRules + "解密后的明文是:" + se.AESDecode(encodeRules, content));
    }
}

监听保存方法，实现数据加密存储

package com.tz.mybatisplus.interceptor;
import com.tz.mybatisplus.common.encrypt.EncryptField;
import com.tz.mybatisplus.common.util.AesUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.springframework.stereotype.Component;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
/**
 * @author @醉鱼
 * @link https://github.com/TianPuJun
 * @ClassName EncryptFieldInterceptor
 * @Description mapper 拦截器，处理sql语句,加密字段存储
 * @Date 09:56 2022/3/30
 **/
@Intercepts({
        // type 指定代理对象，method 指定代理方法，args 指定type代理类中method方法的参数
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
})
@Slf4j
@Component
public class EncryptFieldInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameter = null;
        if (invocation.getArgs().length > 1) {
            parameter = invocation.getArgs()[1];
        }
        String sqlId = mappedStatement.getId();
        log.info("==> intercept  SQL_ID: [{}]", sqlId);
        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        Configuration configuration = mappedStatement.getConfiguration();
        Object returnVal = null;
        String sql = genSql(configuration, boundSql);
        log.info("==> intercept  SQL: [{}]", sql);
        returnVal = invocation.proceed();
        return returnVal;
    }
    private String genSql(Configuration configuration, BoundSql boundSql) {
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        if (parameterMappings.size() > 0 && null != parameterObject) {
            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
            if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                sql = sql.replaceFirst("\\?", getParameterVal(parameterObject));
            } else {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    if (metaObject.hasGetter(propertyName)) {
                        Object value = metaObject.getValue(propertyName);
                        if (EncryptField.FULL_NAME.equalsIgnoreCase(propertyName) || EncryptField.PASSWORD.equalsIgnoreCase(propertyName)) {
                            log.info("==> genSql before [{}]: [{}]", propertyName, value);
                            value = AesUtils.AESEncode(EncryptField.AES_KEY, value.toString());
                            log.info("==> genSql after [{}]: [{}]", propertyName, value);
                            metaObject.setValue(propertyName, value);
                        }
                        sql = sql.replaceFirst("\\?", getParameterVal(value));
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        Object value = boundSql.getAdditionalParameter(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterVal(value));
                    }
                }
            }
        }
        return sql;
    }
    private String getParameterVal(Object obj) {
        String val;
        if (obj instanceof String) {
            val = "'" + obj.toString() + "'";
        } else if (obj instanceof Date) {
            DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
            val = "'" + dateFormat.format(obj) + "'";
        } else {
            if (null != obj) {
                val = obj.toString();
            } else {
                val = "";
            }
        }
        return val;
    }
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties) {
    }
}

监听查询方法，实现数据解密查看

package com.tz.mybatisplus.interceptor;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.tz.mybatisplus.common.encrypt.EncryptField;
import com.tz.mybatisplus.common.util.AesUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandlerRegistry;
import org.springframework.stereotype.Component;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
/**
 * @author @醉鱼
 * @link https://github.com/TianPuJun
 * @ClassName DecryptFieldInterceptor
 * @Description mapper 拦截器，处理sql语句，解密数据
 * @Date 09:56 2022/3/30
 **/
@Intercepts({
        // type 指定代理对象，method 指定代理方法，args 指定type代理类中method方法的参数
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
})
@Slf4j
@Component
public class DecryptFieldInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        String sqlId = mappedStatement.getId();
        log.info("==> intercept  SQL_ID: [{}]", sqlId);
        Object proceed = invocation.proceed();
        if (sqlId.contains("selectCount")) {
            log.warn("==> SQL 语句类型是[selectCount] 直接返回结果");
            return proceed;
        }
        Object parameter = null;
        if (invocation.getArgs().length > 1) {
            parameter = invocation.getArgs()[1];
        }
        BoundSql boundSql = mappedStatement.getBoundSql(parameter);
        Configuration configuration = mappedStatement.getConfiguration();
        String sql = genSql(configuration, boundSql);
        if (sql.contains("count") || sql.contains("COUNT") || sql.contains("Count")) {
            log.warn("==> SQL 语句包含[count|COUNT|Count] 直接返回结果");
            return proceed;
        }
        String result = JSONObject.toJSONString(proceed);
        log.info("==> SQL 查询结果 [{}]", result);
        JSONArray array = JSONArray.parseArray(result);
        log.info("==> SQL 查询结果转换json [{}]", array);
        JSONArray retArray = new JSONArray();
        for (Object o : array) {
            JSONObject jsonObject = JSONObject.parseObject(o.toString());
            jsonObject.put(EncryptField.PASSWORD, AesUtils.AESDecode(EncryptField.AES_KEY, jsonObject.getString(EncryptField.PASSWORD)));
            // 这种的最好还是统一
            if (jsonObject.containsKey(EncryptField.FULL_NAME)) {
                jsonObject.put(EncryptField.FULL_NAME, AesUtils.AESDecode(EncryptField.AES_KEY, jsonObject.getString(EncryptField.FULL_NAME)));
            } else {
                jsonObject.put("full_name", AesUtils.AESDecode(EncryptField.AES_KEY, jsonObject.getString("full_name")));
            }
            retArray.add(jsonObject);
        }
        return retArray;
    }
    private String genSql(Configuration configuration, BoundSql boundSql) {
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        String sql = boundSql.getSql().replaceAll("[\\s]+", " ");
        if (parameterMappings.size() > 0 && null != parameterObject) {
            TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
            if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                sql = sql.replaceFirst("\\?", getParameterVal(parameterObject));
            } else {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                for (ParameterMapping parameterMapping : parameterMappings) {
                    String propertyName = parameterMapping.getProperty();
                    if (metaObject.hasGetter(propertyName)) {
                        Object value = metaObject.getValue(propertyName);
                        if (EncryptField.FULL_NAME.equalsIgnoreCase(propertyName) || EncryptField.PASSWORD.equalsIgnoreCase(propertyName)) {
                            log.info("==> genSql before [{}]: [{}]", propertyName, value);
                            value = AesUtils.AESEncode(EncryptField.AES_KEY, value.toString());
                            log.info("==> genSql after [{}]: [{}]", propertyName, value);
                            metaObject.setValue(propertyName, value);
                        }
                        sql = sql.replaceFirst("\\?", getParameterVal(value));
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        Object value = boundSql.getAdditionalParameter(propertyName);
                        sql = sql.replaceFirst("\\?", getParameterVal(value));
                    }
                }
            }
        }
        return sql;
    }
    private String getParameterVal(Object obj) {
        String val;
        if (obj instanceof String) {
            val = "'" + obj.toString() + "'";
        } else if (obj instanceof Date) {
            DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.CHINA);
            val = "'" + dateFormat.format(obj) + "'";
        } else {
            if (null != obj) {
                val = obj.toString();
            } else {
                val = "";
            }
        }
        return val;
    }
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties) {
    }
}

源代码地址

文章标签：
密钥管理服务
存储
SQL
数据安全/隐私保护
关键词：
MyBatis sql
mybatis-plus SQL
SQL拦截
SQL存储
SQL mybatis-plus
醉鱼Java
目录
相关文章
热爱技术的小郑
|
5月前
|
SQL Java 测试技术
3、Mybatis-Plus 自定义sql语句
这篇文章介绍了如何在Mybatis-Plus框架中使用自定义SQL语句进行数据库操作。内容包括文档结构、编写mapper文件、mapper.xml文件的解释说明、在mapper接口中定义方法、在mapper.xml文件中实现接口方法的SQL语句，以及如何在单元测试中测试自定义的SQL语句，并展示了测试结果。
热爱技术的小郑
326 3
3、Mybatis-Plus 自定义sql语句
蓝易云
|
21天前
|
SQL XML Java
mybatis实现动态sql
MyBatis的动态SQL功能为开发人员提供了强大的工具来应对复杂的查询需求。通过使用 `<if>`、`<choose>`、`<foreach>`等标签，可以根据不同的条件动态生成SQL语句，从而提高代码的灵活性和可维护性。本文详细介绍了动态SQL的基本用法和实际应用示例，希望对您在实际项目中使用MyBatis有所帮助。
蓝易云
49 11
蓝染-惣右介
|
2月前
|
SQL 缓存 Java
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
本文详细介绍了MyBatis的各种常见用法MyBatis多级缓存、逆向工程、分页插件 包括获取参数值和结果的各种情况、自定义映射resultMap、动态SQL
蓝染-惣右介
147 1
【详细实用のMyBatis教程】获取参数值和结果的各种情况、自定义映射、动态SQL、多级缓存、逆向工程、分页插件
游客ny3yjjsyp7iro
|
2月前
|
SQL Java 数据库连接
canal-starter 监听解析 storeValue 不一样，同样的sql 一个在mybatis执行 一个在数据库操作，导致解析不出正确对象
canal-starter 监听解析 storeValue 不一样，同样的sql 一个在mybatis执行 一个在数据库操作，导致解析不出正确对象
游客ny3yjjsyp7iro
52 0
java冯坚持
|
3月前
|
SQL Java 数据库连接
mybatis使用四：dao接口参数与mapper 接口中SQL的对应和对应方式的总结，MyBatis的parameterType传入参数类型
这篇文章是关于MyBatis中DAO接口参数与Mapper接口中SQL的对应关系，以及如何使用parameterType传入参数类型的详细总结。
java冯坚持
62 10
杀死一只知更鸟debug
|
4月前
|
SQL XML Java
mybatis复习03，动态SQL，if，choose，where,set,trim标签及foreach标签的用法
文章介绍了MyBatis中动态SQL的用法，包括if、choose、where、set和trim标签，以及foreach标签的详细使用。通过实际代码示例，展示了如何根据条件动态构建查询、更新和批量插入操作的SQL语句。
杀死一只知更鸟debug
130 2
mybatis复习03，动态SQL，if，choose，where,set,trim标签及foreach标签的用法
热爱技术的小郑
|
5月前
|
SQL Java 数据库连接
Mybatis系列之 Error parsing SQL Mapper Configuration. Could not find resource com/zyz/mybatis/mapper/
文章讲述了在使用Mybatis时遇到的资源文件找不到的问题，并提供了通过修改Maven配置来解决资源文件编译到target目录下的方法。
热爱技术的小郑
223 1
Mybatis系列之 Error parsing SQL Mapper Configuration. Could not find resource com/zyz/mybatis/mapper/
蓝易云
|
4月前
|
SQL XML Java
mybatis ：sqlmapconfig.xml配置 ++++Mapper XML 文件（sql/insert/delete/update/select)（增删改查）用法
当然，这些仅是MyBatis功能的初步介绍。MyBatis还提供了高级特性，如动态SQL、类型处理器、插件等，可以进一步提供对数据库交互的强大支持和灵活性。希望上述内容对您理解MyBatis的基本操作有所帮助。在实际使用中，您可能还需要根据具体的业务要求调整和优化SQL语句和配置。
蓝易云
76 1
热爱技术的小郑
|
5月前
|
SQL Java 数据库连接
Mybatis系列之 动态SQL
文章详细介绍了Mybatis中的动态SQL用法，包括`<if>`、`<choose>`、`<when>`、`<otherwise>`、`<trim>`和`<foreach>`等元素的应用，并通过实际代码示例展示了如何根据不同条件动态生成SQL语句。
热爱技术的小郑
43 1
热爱技术的小郑
|
5月前
|
SQL 关系型数据库 MySQL
解决：Mybatis-plus向数据库插入数据的时候 报You have an error in your SQL syntax
该博客文章讨论了在使用Mybatis-Plus向数据库插入数据时遇到的一个常见问题：SQL语法错误。作者发现错误是由于数据库字段中使用了MySQL的关键字，导致SQL语句执行失败。解决方法是将这些关键字替换为其他字段名称，以避免语法错误。文章通过截图展示了具体的操作步骤。
热爱技术的小郑
224 2

热门文章

最新文章

  • 1
    Flask 框架防止 SQL 注入攻击的方法
  • 2
    Vanna：开源 AI 检索生成框架，自动生成精确的 SQL 查询
  • 3
    SQL自学笔记（3）：SQL里的DCL,DQL都代表什么？
  • 4
    Flink SQL Deduplication 去重以及如何获取最新状态操作
  • 5
    MySQL导入.sql文件后数据库乱码问题
  • 6
    MySQL进阶突击系列(02)一条更新SQL执行过程 | 讲透undoLog、redoLog、binLog日志三宝
  • 7
    MySQL 高级(进阶) SQL 语句
  • 8
    MySQL进阶突击系列(01)一条简单SQL搞懂MySQL架构原理 | 含实用命令参数集
  • 9
    SQL自学笔记（1）：什么是SQL？有什么用？
  • 10
    SQL慢查询优化策略
  • 1
    Mybatis逆向工程的2种方法，一键高效快速生成Pojo、Mapper、XML，摆脱大量重复开发
    91
  • 2
    mybatis的一对多
    50
  • 3
    mybatis动态sql
    50
  • 4
    【JAVA进阶篇教学】第九篇：MyBatis-Plus用法介绍
    299
  • 5
    解决一个mybatisplus left join里有ur报错问题
    83
  • 6
    java mysql druid mybatis-plus里使用多表删除出错的一种处理方式
    114
  • 7
    nbcio-boot升级springboot、mybatis-plus和JSQLParser后的LocalDateTime日期json问题
    104
  • 8
    基于jeecg-boot的nbcio-boot因升级mybatis-plus到3.5.3.1和JSQLParser 到4.6而引起的在线报表配置报错处理
    197
  • 9
    升级mybatis-plus到3.5.3.1和JSQLParser 从4.3升级到4.6版本引起的插入问题解决
    664
  • 10
    MyBatis #与$的区别以及动态SQL
    56

    • 相关课程

    更多
  • SQL完全自学手册
  • SQL Server on Linux入门教程
  • SQL入门与实践
  • 数据库及SQL/MySQL基础
  • SQL进阶及查询
  • MyBatis持久层框架入门

    • 相关电子书

    更多
  • SQL Server 2017
  • GeoMesa on Spark SQL
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)

    • 相关实验场景

    更多
  • PolarDB for AI：在数据库中通过SQL实现AI能力
  • 玩转MaxCompute SQL! 30分钟搞定数据分析挖掘
  • 使用SQL语句实现数据表管理
  • 使用SQL语句实现数据查询操作
  • 使用SQL语句管理索引
  • SQL进阶之约束、索引
    • 下一篇
    DataWorks智能交互式数据开发与分析之旅