mybatis、mybatis-plus自定义插件，实现自定义策略数据脱敏功能

最新推荐文章于 2024-09-12 17:09:24 发布
最新推荐文章于 2024-09-12 17:09:24 发布
阅读量568 收藏 3
点赞数 10
文章标签： mybatis 脱敏 拦截器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy1209357299/article/details/141298759
版权

背景

mybatis中四大组件的作用，下面开发的插件拦截器会使用
四大组件Executor、StatementHandler、ParameterHandler、ResultSetHandler
在这里插入图片描述

需求

1、根据脱敏规则进行查询数据，显示的时候进行展示脱敏
2、根据脱敏规则进行查询数据，将脱敏后的数据批量更新回数据库，进行脱敏存储

数据

在这里插入图片描述

/*
 Navicat Premium Data Transfer

 Source Server         : localhost
 Source Server Type    : MySQL
 Source Server Version : 80026 (8.0.26)
 Source Host           : localhost:3306
 Source Schema         : mp

 Target Server Type    : MySQL
 Target Server Version : 80026 (8.0.26)
 File Encoding         : 65001

 Date: 18/08/2024 13:44:24
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `username` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
  `password` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
  `phone` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '注册手机号',
  `info` json NOT NULL COMMENT '详细信息',
  `status` int NULL DEFAULT 1 COMMENT '使用状态（1正常 2冻结）',
  `balance` int NULL DEFAULT NULL COMMENT '账户余额',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`username` ASC) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '用户表' ROW_FORMAT = COMPACT;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'Jack', 'D5F3C4C80A651CFE876DA231061FA871', '13900112224', '{\"age\": 20, \"intro\": \"佛系青年\", \"gender\": \"male\"}', 1, 1600, '2023-05-19 20:50:21', '2024-08-18 13:43:05');
INSERT INTO `user` VALUES (2, 'Rose', 'D5F3C4C80A651CFE876DA231061FA871', '13900112223', '{\"age\": 19, \"intro\": \"青涩少女\", \"gender\": \"female\"}', 1, 600, '2023-05-19 21:00:23', '2024-08-18 13:43:09');
INSERT INTO `user` VALUES (3, 'Hope', 'D5F3C4C80A651CFE876DA231061FA871', '13900112222', '{\"age\": 25, \"intro\": \"上进青年\", \"gender\": \"male\"}', 1, 100000, '2023-06-19 22:37:44', '2024-08-18 13:43:12');
INSERT INTO `user` VALUES (4, 'Toomas', 'D5F3C4C80A651CFE876DA231061FA871', '17701265258', '{\"age\": 29, \"intro\": \"伏地魔\", \"gender\": \"male\"}', 1, 800, '2023-06-19 23:44:45', '2024-08-18 13:43:27');

SET FOREIGN_KEY_CHECKS = 1;

具体实现

1、定义脱敏规则

mybatis:
  interceptors:
#    是否开启拦截
    enabled: true
desensitization:
#  是否进行脱敏
  enabled: true
  rule:
#    脱敏模式
    - schema: MP
#      是否全模式脱敏
      allSchema: true
#      单模式脱敏规则
      schemaRule:
#        模式下需要脱敏的表
        - tableName: USER
#          模式下需要脱敏的表的主键字段
          keyColumn: id
#          具体表的脱敏规则
          tableRule:
#            具体列的脱敏规则
            - column: username
              columnRule:
#                隐藏脱敏，*代替
                ruleType: hide
                startIndex: 1
                endIndex: 2
            - column: password
              columnRule:
#                密码aes加密脱敏
                ruleType: aes
#      全模式脱敏规则
      allTableRule:
        - column: username
          columnRule:
            ruleType: hide
            startIndex: 1
            endIndex: 2
        - column: password
          columnRule:
#             密码aes加密脱敏
              ruleType: aes

2、配置类

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/16 13:35
 * @Description ${DESCRIPTION}
 */
@Data
@Component
@ConfigurationProperties(prefix = "desensitization")
public class DesensitizationConfig {

    private String enabled = "false";

    private List<DesensitizationBaseRule> rule;
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/16 13:37
 * @Description 脱敏规则
 */
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class DesensitizationBaseRule implements Serializable {
    private static final long serialVersionUID = 1L;

    private String schema = "schema";

    private String allSchema = "false";

    private List<DesensitizationSchemaRule> schemaRule = new ArrayList<>();

    private List<DesensitizationTableRule> allTableRule = new ArrayList<>();
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/16 13:41
 * @Description ${DESCRIPTION}
 */
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class DesensitizationSchemaRule implements Serializable {
    private static final long serialVersionUID = 1L;

    private String tableName = "table";

    private String keyColumn = "id";

    private List<DesensitizationTableRule> tableRule;

}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/16 13:46
 * @Description ${DESCRIPTION}
 */
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class DesensitizationTableRule implements Serializable {

    private static final long serialVersionUID = 1L;

    private String column = "name";

    private DesensitizationMaskRule columnRule;
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/16 13:50
 * @Description ${DESCRIPTION}
 */
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class DesensitizationMaskRule implements Serializable {

    private static final long serialVersionUID = 1L;

    private String ruleType = "hide";

    private int startIndex = 1;

    private int endIndex = 2;
}

3、拦截器

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/13 9:54
 * @Description ${DESCRIPTION}
 */
@Intercepts({
        @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
@Slf4j
public class SqlQueryInterceptor implements Interceptor {

    private static final Pattern TABLE_NAME_PATTERN = Pattern.compile("(FROM|UPDATE)\\s+([\\w\\._]+)");

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler)invocation.getTarget();

        // 获取连接对象
        Connection connection = (Connection) invocation.getArgs()[0];
        // 获取数据库名称
        String databaseName = connection.getCatalog();
        log.info("----------当前数据库名：{}", databaseName);

        Object parameterObject = statementHandler.getParameterHandler().getParameterObject();
        JSONObject paramObject = JSONObject.parseObject(JSON.toJSONString(parameterObject));

        BoundSql boundSql = statementHandler.getBoundSql();
        //统一转大写
        String tableNameSql = boundSql.getSql().toUpperCase();
        //获取表名
        String tableName = "";
        Matcher matcher = TABLE_NAME_PATTERN.matcher(tableNameSql);
        while (matcher.find()){
            tableName = matcher.group(2);
            log.info("----------当前sql语句：{}，表名：{}", tableNameSql, tableName);
        }

        if(StringUtils.hasLength(databaseName) && StringUtils.hasLength(tableName)){
            ContextUtil.setSchemaName(databaseName);
            ContextUtil.setTableName(tableName);
        }

        String originalSql = boundSql.getSql();
        String modifySql = modifySql(originalSql, paramObject);
        Field field = BoundSql.class.getDeclaredField("sql");
        field.setAccessible(true);
        field.set(statementHandler.getBoundSql(), modifySql);

        log.info("----------修改后的sql：{}", statementHandler.getBoundSql().getSql());

        return invocation.proceed();
    }

    private String modifySql(String originalSql, JSONObject paramObject){
        String tableName = "";
        String fieldName = "";
        String fieldCode = "";
        if(ObjectUtil.isNotEmpty(paramObject)){
            tableName = paramObject.getString("tablename");
            fieldName = paramObject.getString("fieldname");
            fieldCode = paramObject.getString("fieldcode");
        }
        if(StringUtils.hasLength(tableName)){
            log.info("tableName:{}", tableName);
        }
        if(StringUtils.hasLength(fieldName)){
            log.info("fieldName:{}", fieldName);
        }
        if(StringUtils.hasLength(fieldCode)){
            log.info("fieldCode:{}", fieldCode);
        }
        log.info("modify sql：{}", originalSql);
        return originalSql;
    }
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/13 14:15
 * @Description ${DESCRIPTION}
 */
@Intercepts({
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
@Slf4j
public class ResultSetInterceptor implements Interceptor {

    private static final String TABLE_NAME = ".";

    private static final String PATTERN_TABLE_NAME = "\\.";
    @Resource
    private DesensitizationConfig desensitizationConfig;

    @Resource
    private BaseDesensitizationPolicy baseDesensitizationPolicy;

    @Override
    public Object plugin(Object target) {
        if (target instanceof ResultSetHandler) {
            return Plugin.wrap(target, this);
        }
        return target;
    }

    @Override
    public void setProperties(Properties properties) {

    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object resultObject = invocation.proceed();
        if (Objects.isNull(resultObject)) {
            return null;
        }
        String schemaName = ContextUtil.getSchemaName();
        String tableName = ContextUtil.getTableName();
        if (tableName.contains(TABLE_NAME)) {
            String[] schemaAndTable = tableName.split(PATTERN_TABLE_NAME);
            schemaName = schemaAndTable[0];
            tableName = schemaAndTable[1];
        }

        log.info("----------拦截的数据库：{}，表：{}", schemaName, tableName);
        log.info("----------当前的脱敏规则：{}", desensitizationConfig.toString());
        //脱敏处理
        if (Boolean.FALSE.toString().equals(desensitizationConfig.getEnabled())) {
            //不进行脱敏
            return resultObject;
        }

        //最终变量
        final String schema = schemaName;
        final String table = tableName;
        List<DesensitizationBaseRule> rule = desensitizationConfig.getRule();
        //获取当前schema的规则
        DesensitizationBaseRule desensitizationBaseRule = rule.stream().filter(d -> schema.equalsIgnoreCase(d.getSchema())).findFirst().orElse(null);

        //定义脱敏规则
        List<DesensitizationTableRule> columnRule = new ArrayList<>();
        //是否全表脱敏规则
        if (Boolean.TRUE.toString().equals(desensitizationBaseRule.getAllSchema())) {
            columnRule = desensitizationBaseRule.getAllTableRule();
        } else {
            List<DesensitizationSchemaRule> schemaRule = desensitizationBaseRule.getSchemaRule();
            DesensitizationSchemaRule desensitizationSchemaRule = schemaRule.stream().filter(s -> table.equalsIgnoreCase(s.getTableName())).findFirst().orElse(null);
            columnRule = Objects.isNull(desensitizationSchemaRule.getTableRule()) ? null : desensitizationSchemaRule.getTableRule();
        }

        //分页结果
        if (resultObject instanceof IPage) {
            IPage page = (IPage) resultObject;
            if (page != null && CollUtil.isNotEmpty(page.getRecords())) {
                for (Object res : page.getRecords()) {
                    doDealData(res, columnRule);
                }
            }

            return resultObject;
        }

        //list结果
        if (resultObject instanceof ArrayList) {
            ArrayList list = (ArrayList) resultObject;
            if (CollUtil.isNotEmpty(list)) {
                for (Object res : list) {
                    doDealData(res, columnRule);
                }
            }

            return resultObject;
        }

        //单个接口
        doDealData(resultObject, columnRule);

        return resultObject;
    }

    private Object doDealData(Object result, List<DesensitizationTableRule> columnRule) throws Exception {
        //result to map
        Map<Object, Object> map = (HashMap<Object, Object>) result;
        String jsonString = JSON.toJSONString(map);
        log.info("当前的json数据：{}, 脱敏规则：{}", jsonString, columnRule.toString());

        //遍历规则
        columnRule.forEach(c -> {
            Object value = map.get(c.getColumn());
            BaseDesensitizationService service = baseDesensitizationPolicy.getService(c.getColumnRule().getRuleType());
            String hideValue = service.desensitizationStr(value.toString(), c.getColumnRule());
            log.info("当前的字段：{}, 脱敏规则：{}，脱敏后的数据：{}", c.getColumn(), c.getColumnRule().toString(), hideValue);
            map.put(c.getColumn(), hideValue);
        });

        return map;
    }
}

4、注册拦截器

 @Bean
    @Order(1)
    public SqlQueryInterceptor sqlQueryInterceptor(){
        return new SqlQueryInterceptor();
    }

    @Bean
    @Order(2)
    public ResultSetInterceptor resultSetInterceptor(){
        return new ResultSetInterceptor();
    }

5、工具类

/**
 * @Description
 * @Author code
 * @Create 2024-08-18 11:02
 */
@Slf4j
public class AESUtil {
    /**
     * 定义 aes 加密的key
     * 密钥  必须是16位, 自定义,
     * 如果不是16位, 则会出现InvalidKeyException: Illegal key size
     * 解决方案有两种：
     * 需要安装Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files(可以在Oracle下载).
     *  .设置设置key的长度为16个字母和数字的字符窜（128 Bit/8=16字符）就不报错了。
     */
    //秘钥设置16位
    private static final String SECRET_KEY = "abcdeg123456!#$%";

    public static String getSecretKey(){
        return SECRET_KEY;
    }

    //加密方式
    private static final String AES_TYPE = "AES";
    //秘钥最大长度16位
    private static final int BYTE_LENGTH = 16;

    /**
     * 加密AES
     *
     * @param value 字符串
     * @param key   秘钥
     * @return String
     */
    private static String encryptAES(String key, String value) {
        try {
            byte[] keyBytes = Arrays.copyOf(key.getBytes(StandardCharsets.US_ASCII), BYTE_LENGTH);
            SecretKey keyStr = new SecretKeySpec(keyBytes, AES_TYPE);
            Cipher cipher = Cipher.getInstance(AES_TYPE);
            cipher.init(Cipher.ENCRYPT_MODE, keyStr);
            byte[] cleartext = value.getBytes(StandardCharsets.UTF_8);
            byte[] ciphertextBytes = cipher.doFinal(cleartext);
            return new String(Hex.encodeHex(ciphertextBytes)).toUpperCase();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 解密AES
     *
     * @param encrypted 字符串
     * @param key       秘钥
     * @return String
     */
    private static String decryptAES(String key, String encrypted) {
        try {
            byte[] keyBytes = Arrays.copyOf(key.getBytes(StandardCharsets.US_ASCII), BYTE_LENGTH);
            SecretKey keyStr = new SecretKeySpec(keyBytes, AES_TYPE);
            Cipher cipher = Cipher.getInstance(AES_TYPE);
            cipher.init(Cipher.DECRYPT_MODE, keyStr);
            byte[] content = Hex.decodeHex(encrypted.toCharArray());
            byte[] ciphertextBytes = cipher.doFinal(content);
            return new String(ciphertextBytes);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 加密
     *
     * @param value 字符串
     * @param pwd   秘钥
     * @return String
     */
    public static String encryptValue(String value, String pwd) {
        return StrUtil.isEmpty(value) ? null : encryptAES(pwd, value.trim());
    }

    /**
     * 解密
     *
     * @param value 字符串
     * @param pwd   秘钥
     * @return String
     */
    public static String decryptValue(String value, String pwd) {
        if (StrUtil.isNotEmpty(value)) {
            String value2 = decryptAES(pwd, value.toLowerCase());
            value = StrUtil.isEmpty(value2) ? value : value2;
        }
        return value;
    }

    /**
     * main方法
     *
     * #mysql 进行AES加密
     * SELECT HEX(AES_ENCRYPT("原始字符串","密钥"));
     *
     * #mysql 进行AES解密
     * SELECT AES_DECRYPT(UNHEX("加密后字符串"), "密钥");
     *
     * @param args 参数
     */
    public static void main(String[] args) {
        //加密测试
        System.out.println(encryptValue("张三", ""));
        //解密测试
        System.out.println(decryptValue(encryptValue("张三", ""), ""));

        //加密测试
        System.out.println(encryptValue("李四", SECRET_KEY));
        //解密测试
        System.out.println(decryptValue(encryptValue("李四", SECRET_KEY), SECRET_KEY));
    }
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/8/13 10:05
 * @Description ${DESCRIPTION}
 */
public class ContextUtil {
    private static final ThreadLocal<String> THREAD_LOCAL_SCHEMA_NAME = new ThreadLocal<>();

    private static final ThreadLocal<String> THREAD_LOCAL_TABLE_NAME = new ThreadLocal<>();

    public static void setTableName(String tableName){
        THREAD_LOCAL_TABLE_NAME.set(tableName);
    }

    public static String getTableName(){
        return THREAD_LOCAL_TABLE_NAME.get();
    }

    public static void removerTableName(){
        THREAD_LOCAL_TABLE_NAME.remove();
    }

    public static void setSchemaName(String schemaName){
        THREAD_LOCAL_SCHEMA_NAME.set(schemaName);
    }

    public static String getSchemaName(){
        return THREAD_LOCAL_SCHEMA_NAME.get();
    }

    public static void removerSchemaName(){
        THREAD_LOCAL_SCHEMA_NAME.remove();
    }
}

/**
 * @author code
 * @version 1.0
 * @Date 2024/6/17 16:26
 * @Description ${DESCRIPTION}
 */
@Component
@Slf4j
public class JdbcSqlUtil {

    private static final String TABLE_NAME = ".";

    private static final String PATTERN_TABLE_NAME = "\\.";

    @Resource
    private DataSource dataSource;

    @Resource
    private DesensitizationConfig desensitizationConfig;

    public Map<String, Object> getDataForMap(String sql) {
        long startTime = System.currentTimeMillis();
        log.info("-------------------------executeQuerySqlMap开始时间：{}", startTime);

        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        log.info("executeQuerySqlMap:{}", sql);
        Map<String, Object> maps = jdbcTemplate.queryForMap(sql);

        long endTime = System.currentTimeMillis();
        log.info("-------------------------executeQuerySqlMap结束时间：{}，消耗时间：{}", endTime, endTime - startTime);

        return maps;
    }

    /**
     * 通用sql查询，支持一般函数、join、分页
     * 执行sql语句
     *
     * @param commonSql
     * @return
     */
    public List<Map<String, Object>> getCommonDataList(String commonSql) {
        long startTime = System.currentTimeMillis();
        log.info("-------------------------executeQuerySql开始时间：{}", startTime);

        String sql = sqlFormat(commonSql);

        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        log.info("common-------query-------executeQuerySql:{}", sql);
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);

        long endTime = System.currentTimeMillis();
        log.info("common-------query-------executeQuerySql结束时间：{}，消耗时间：{}", endTime, endTime - startTime);

        return maps;
    }

    public Object butchUpdateData(List<Map<String, Object>> data) {

        if (CollectionUtils.isEmpty(data)) {
            return "无更新数据";
        }

        //判断规则是否开启
        //脱敏处理
        if (Boolean.FALSE.toString().equals(desensitizationConfig.getEnabled())) {
            //不进行脱敏
            return "不进行脱敏";
        }

        String schemaName = ContextUtil.getSchemaName();
        String tableName = ContextUtil.getTableName();
        if (tableName.contains(TABLE_NAME)) {
            String[] schemaAndTable = tableName.split(PATTERN_TABLE_NAME);
            schemaName = schemaAndTable[0];
            tableName = schemaAndTable[1];
        }

        //处理模式名和表名
        ContextUtil.removerSchemaName();
        ContextUtil.removerTableName();
        log.info("----------拦截的数据库：{}，表：{}", schemaName, tableName);
        log.info("----------处理后的数据库：{}，表：{}", ContextUtil.getSchemaName(), ContextUtil.getTableName());

        //查找主键字段
        final String schema = schemaName;
        final String table = tableName;
        List<DesensitizationBaseRule> rule = desensitizationConfig.getRule();
        //获取当前schema的规则
        DesensitizationBaseRule desensitizationBaseRule = rule.stream().filter(d -> schema.equalsIgnoreCase(d.getSchema())).findFirst().orElse(null);

        //定义脱敏规则
        List<DesensitizationTableRule> columnRule = new ArrayList<>();
        //是否全表脱敏规则
        if (Boolean.TRUE.toString().equals(desensitizationBaseRule.getAllSchema())) {
            return "全模式脱敏，无法批量更新";
        }

        List<DesensitizationSchemaRule> schemaRule = desensitizationBaseRule.getSchemaRule();
        DesensitizationSchemaRule desensitizationSchemaRule = schemaRule.stream().filter(s -> table.equalsIgnoreCase(s.getTableName())).findFirst().orElse(null);
        String keyColumn = desensitizationSchemaRule.getKeyColumn();

        List<DesensitizationTableRule> tableRule = desensitizationSchemaRule.getTableRule();

        //构造sql
        StringBuilder columns = new StringBuilder();
        tableRule.forEach(d -> {
            columns.append(d.getColumn()).append("=?,");
        });
        //去掉最后一个逗号
        String column = columns.toString().substring(0, columns.length() - 1);

        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        DataSource dataSource = jdbcTemplate.getDataSource();

        String updateSql = " update " + schema + "." + table + " set " + column + " where " + keyColumn + " = ?";

        BatchSqlUpdate bsu = new BatchSqlUpdate(dataSource, updateSql);
        bsu.setBatchSize(1000);
        //参数类型匹配
        int[] types = new int[tableRule.size() + 1];

        for (int i = 0; i <tableRule.size() + 1; i++) {
            types[i] = Types.VARCHAR;
        }

        bsu.setTypes(types);

        data.forEach(m -> {
            Object[] objects = new Object[tableRule.size() + 1];
            for (int i = 0; i < tableRule.size(); i++) {
                String key = tableRule.get(i).getColumn();
                objects[i] = m.get(key);
            }
            int keyIndex = tableRule.size();
            objects[keyIndex] = m.get(keyColumn);
            bsu.update(objects);
        });
        bsu.flush();

        return "OK";
    }

    //格式化sql
    private String sqlFormat(String sql) {
        String type = null;
        try {
            Connection connection = dataSource.getConnection();
            type = connection.getMetaData().getDatabaseProductName().toLowerCase();
            connection.close();
        } catch (SQLException e) {
            log.error("db type error");
        }

        String res = SQLUtils.format(sql, type);

        log.info("format sql : {}", res);
        return res;
    }
}

6、结果展示

原始数据
在这里插入图片描述
启用脱敏规则后查询
在这里插入图片描述

在这里插入图片描述
脱敏后更新数据库数据
需要调用jdbc的批量更新方法，jdbcSqlUtil.butchUpdateData()

需要设置指定模式、表和主键等
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

yy1209357299
关注
你还不会搞数据脱敏？MyBatis 插件 + 注解轻松实现数据脱敏，Soeasy
m0_69804655的博客
02-25 395
问题在项目中需要对用户敏感数据进行脱敏处理，例如身份号、手机号等信息进行加密再入库。解决思路就是：一种最简单直接的方式，在所有涉及数据敏感的查询到对插入时进行密码加解密方法二：有方法一到出现对所有重大问题的影响，需要考虑到问题的出现，并且需要考虑可能出现的组员时添加数据的方法。Mybatis 插件原理Mybatis 的是通过拦截器实现的，Mabatis 支持对当事人进行拦截​编辑切换为居中添加图片注释，不超过 140 字（可选）实现设置对参数中带有敏感参数字段的数据时进行加密对返回的结果进行解密处理根据不同
基于MyBatis写一个数据脱敏插件
czc的博客
02-04 460
本文在SpringBoot环境下，利用MyBatis的Interceptor接口实现一个数据脱敏的插件。MyBatis的插件接口提供了强大的功能，我们可以利用这个接口来拦截不同的组件，可以实现如结果集数据脱敏、sql语句日志打印、自定义参数等效果。
java数据脱敏
cndndj的博客
05-11 766
1.添加注解DataMaskingClass和注解DataMaskingField分别作用在类和字段上面 /** * 需要脱敏的类注解 * */ @Documented @Inherited @Target({ ElementType.TYPE }) @Retention(RetentionPolicy.RUNTIME) public @interface DataMaskingClass { } /** * 脱敏字段 */ @Documented @Inherited @Target({El
mybatis-encrypt-plugin:mybatis数据脱敏和字段加解密插件
05-14
敏感数据加解密以及数据脱敏mybatis插件 介绍 本工具是基于mybatis的插件机制编写的一套敏感数据加解密以及数据脱敏工具。 在使用时通过注解指定一个字段是需要加密的字段，该插件会在存储时自动加密存储。 而查询时会自动解密出明文在程序内部使用。 在使用时也可以通过注解指定一个字段是需要脱敏的字段，该插件会在入库时将字段脱敏存储。 内置了一些常用数据的脱敏处理方式。 设计目标 对应用和使用者透明，业务逻辑无感知，通过配置集成，改动代码量小。 加密算法可扩展。 实现原理 1，拦截mybatis的StatementHandler 对读写请求进行脱敏和字段的加密。 2，拦截mybatis的ResultSetHandler，对读请求的响应进行加密字段的解密赋值。 使用方式 0,导入依赖 <!-- mybatis数据脱敏插件 --> <dependency> <g
mybatis、mybatis-plus插件开发，实现数据脱敏功能
小哇
07-02 1435
具体实现步骤。
mybatis-plus的数据脱敏使用
dream的博客
01-04 6354
最近看 mybatis-Plus 官方发布的神器：mybatis-mate,功能十分强大，我简单给大家说下 1.mybatis-mate能做什么？ mybatis-mate 为mybatis-plus企业级模块，支持分库分表，数据审计、数据敏感词过滤（AC 算法），字段加密，字典回写（数据绑定），数据权限，表结构自动生成 SQL 维护等 2.具体使用 Spring Boot 引入自动依赖注解包 ： <dependency> <groupId>com...
【Mybatis】MybatisPlus轻松实现数据动态可配置热脱敏
DreamSun的博客
08-28 1760
网站开发功能是否全面是衡量的一个重要指标，往往我们还需要针对用户进行功能的拼接或者切割，这部分我愿称之为用户画像。在用户画像下我们还需要考虑的是如何做到精准控制。基于 Spring 我们可以轻松实现传统的 三元 管理用于精准控制用户的菜单、按钮、及资源。再仔细思考想，难道控制住资源就是精准控制了吗？我决定将精准下方我想细化到数据层面。本文主要是思路的剖析，并没有将每个案例都完成的代码呈现出来，因为在项目中也不可能同时使用上述所有的场景。我仅讲核心代码提供，部分辅助型的如有需要可以下方留言给你提供思路。
mybatis-plus的插件
weixin_54401017的博客
07-20 889
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。default-enum-type-handler这个也很重要，这里不配的话，如果是自己写xml文件，在sql中也会写。后端接收前端传来的String类型参数需要用枚举来接收的话，就需要定义一个自定义转换器。1.首先在实体类中用@TableField注解file来设置什么时候自动填充。1.数据库中的表需要一个对应的deleted字段。...
mybatis-plus-3.0.zip
03-16
MyBatis-Plus 是 MyBatis 的一个扩展插件，主要目标是简化常见的 CRUD（创建、读取、更新、删除）操作，它提供了一系列便捷的 CRUD 方法，使得开发者无需编写大量重复的 SQL 代码，提高了开发效率。这个 "mybatis-...
Mybatis+注解轻松实现脱敏
01-05
【Mybatis+注解轻松实现脱敏】是一个针对Java开发工程师的实用技术，旨在帮助他们在处理敏感数据时，如身份证号、手机号等信息，进行数据脱敏和加密。这一技术结合了MyBatis插件和注解的方式，使得数据脱敏过程变得...
基于mybatis 来实现对敏感数据在进出DB时候进行脱敏处理， 让各位码友们无需自己各种手动实现
06-03
通过上述方式，我们可以借助 MyBatis 的拦截器和插件机制，轻松地实现在数据库操作时对敏感数据的自动脱敏，从而提高数据安全性。同时，这也是一个良好的实践，可以减少手动处理的繁琐工作，让开发者更专注于业务...
集成mybatis-plus，使用mybatis拦截器方式做数据库字段脱敏处理
最新发布
qq_44022870的博客
09-12 1356
数据库字段加解密处理，字段脱敏处理
Mybatis-Plus06-插件
sweet987250的博客
07-05 409
Mybatis-Plus06-插件
mybatis之自定义插件
shangshanzixu的博客
01-14 461
要写一个mybatis的插件，我们大概分为以下三步 1.书写插件类，实现interceptor接口 2.书写插件的方法标签(为四大对象的哪个方法执行拦截操作) 3.在mybatis全局配置中配置我们书写的插件 案例 假设现在我们需要通过ID属性从数据库查询员工信息，我们通过自定义插件，使得每次查询的ID参数都被我们改为查询1号员工，实现偷梁换柱。 插件类 @Intercepts({ @Signature(type = StatementHandler.class,
数据库脱敏：Mybatis-plus改造二
lvjingang的博客
05-17 581
上次我们重写了QueryWrapper，解决了无法得到QueryWrapper中字段名称的问题，但是问题并没有这么简单，咱们再次接下来的兼容性改造。
自定义Mybatis-plus插件(限制最大查询数量)
2301_76725413的博客
08-14 3346
​ 一次查询如果结果返回太多（1万或更多），往往会导致系统性能下降，有时更会内存不足，影响系统稳定性，故需要做限制。1.经分析最后决定，应限制一次查询返回的最大结果数量不应该超出1万，对于一次返回结果大于限制的时候应该抛出异常，而不应该截取(limit 10000)最大结果(结果需求不匹配)。2.利用mybatis拦截器技术，统一拦截sql,并真对大结果的查询先做一次count查询。 1.2 重写willDoQuery方法 1.3 代码解析 1.3.1 利用CCJSqlParserUtil解析
Mybatis-Plus 进阶开发-自定义乐观锁插件
日拱一卒无有尽，功不唐捐终入海
05-30 1177
有的时候我们需要对mybatis-plus的乐观锁插件进行自定义修改。那么其实mybatis 是已经有个默认的实现，我们只需要将其继承并扩展即可。当要更新一条记录的时候，希望这条记录没有被别人更新取出记录时，获取当前 version更新时，带上这个 version执行更新时， set version = newVersion where version = oldVersion如果 version 不对，就更新失败 但是我们也可以根据自己的业务需求实现自定义的乐观锁插件。
MyBatis Plus (七) --------- 插件扩展
在森林里麋了鹿
08-31 411
MyBatis Plus 中的插件拓展
MybatisPlus----- 插件功能
m0_59281987的博客
05-10 2137
其中缺少的仅仅是分页条件，而分页条件不仅仅用户分页查询需要，以后其它业务也都有分页查询的需求。这里用到了分页参数，Page，即可以支持分页参数，也可以支持排序参数。MybatisPlus提供了很多的插件功能，进一步拓展其功能。在查询出分页结果后，数据的非空校验，数据的vo转换都是模板代码，编写起来很麻烦。所以，我们必须配置分页插件。：分页查询条件的实体，包含分页、排序参数、过滤条件。：分页结果实体，包含总条数、总页数、当前页数据。如果排序字段为空，默认按照更新时间排序。排序字段不为空，则按照排序字段排序。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值