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

于 2024-08-18 14:06:57 发布
阅读量345 收藏 3
点赞数 9
文章标签： 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】MybatisPlus轻松实现数据动态可配置热脱敏
DreamSun的博客
08-28 1598
网站开发功能是否全面是衡量的一个重要指标，往往我们还需要针对用户进行功能的拼接或者切割，这部分我愿称之为用户画像。在用户画像下我们还需要考虑的是如何做到精准控制。基于 Spring 我们可以轻松实现传统的 三元 管理用于精准控制用户的菜单、按钮、及资源。再仔细思考想，难道控制住资源就是精准控制了吗？我决定将精准下方我想细化到数据层面。本文主要是思路的剖析，并没有将每个案例都完成的代码呈现出来，因为在项目中也不可能同时使用上述所有的场景。我仅讲核心代码提供，部分辅助型的如有需要可以下方留言给你提供思路。
mybatis-encrypt-plugin:mybatis数据脱敏和字段加解密插件
05-14
敏感数据加解密以及数据脱敏mybatis插件 介绍 本工具是基于mybatis的插件机制编写的一套敏感数据加解密以及数据脱敏工具。 在使用时通过注解指定一个字段是需要加密的字段，该插件会在存储时自动加密存储。 而查询时会自动解密出明文在程序内部使用。 在使用时也可以通过注解指定一个字段是需要脱敏的字段，该插件会在入库时将字段脱敏存储。 内置了一些常用数据的脱敏处理方式。 设计目标 对应用和使用者透明，业务逻辑无感知，通过配置集成，改动代码量小。 加密算法可扩展。 实现原理 1，拦截mybatis的StatementHandler 对读写请求进行脱敏和字段的加密。 2，拦截mybatis的ResultSetHandler，对读请求的响应进行加密字段的解密赋值。 使用方式 0,导入依赖 <!-- mybatis数据脱敏插件 --> <dependency> <g
mybatis、mybatis-plus插件开发，实现数据脱敏功能
小哇
07-02 1271
具体实现步骤。
mybatis-plus的数据脱敏使用
dream的博客
01-04 6130
最近看 mybatis-Plus 官方发布的神器：mybatis-mate,功能十分强大，我简单给大家说下 1.mybatis-mate能做什么？ mybatis-mate 为mybatis-plus企业级模块，支持分库分表，数据审计、数据敏感词过滤（AC 算法），字段加密，字典回写（数据绑定），数据权限，表结构自动生成 SQL 维护等 2.具体使用 Spring Boot 引入自动依赖注解包 ： <dependency> <groupId>com...
mybatis之自定义插件
shangshanzixu的博客
01-14 437
要写一个mybatis的插件，我们大概分为以下三步 1.书写插件类，实现interceptor接口 2.书写插件的方法标签(为四大对象的哪个方法执行拦截操作) 3.在mybatis全局配置中配置我们书写的插件 案例 假设现在我们需要通过ID属性从数据库查询员工信息，我们通过自定义插件，使得每次查询的ID参数都被我们改为查询1号员工，实现偷梁换柱。 插件类 @Intercepts({ @Signature(type = StatementHandler.class,
mybatis-plus的插件
weixin_54401017的博客
07-20 849
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和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 来实现对敏感数据在进出DB时候进行脱敏处理， 让各位码友们无需自己各种手动实现
06-03
通过上述方式，我们可以借助 MyBatis 的拦截器和插件机制，轻松地实现在数据库操作时对敏感数据的自动脱敏，从而提高数据安全性。同时，这也是一个良好的实践，可以减少手动处理的繁琐工作，让开发者更专注于业务...
Mybatis+注解轻松实现脱敏
01-05
【Mybatis+注解轻松实现脱敏】是一个针对Java开发工程师的实用技术，旨在帮助他们在处理敏感数据时，如身份证号、手机号等信息，进行数据脱敏和加密。这一技术结合了MyBatis插件和注解的方式，使得数据脱敏过程变得...
你还不会搞数据脱敏？MyBatis 插件 + 注解轻松实现数据脱敏，Soeasy
m0_69804655的博客
02-25 330
问题在项目中需要对用户敏感数据进行脱敏处理，例如身份号、手机号等信息进行加密再入库。解决思路就是：一种最简单直接的方式，在所有涉及数据敏感的查询到对插入时进行密码加解密方法二：有方法一到出现对所有重大问题的影响，需要考虑到问题的出现，并且需要考虑可能出现的组员时添加数据的方法。Mybatis 插件原理Mybatis 的是通过拦截器实现的，Mabatis 支持对当事人进行拦截​编辑切换为居中添加图片注释，不超过 140 字（可选）实现设置对参数中带有敏感参数字段的数据时进行加密对返回的结果进行解密处理根据不同
通过mybatis自定义参数类型转换器，进行数据库字段加密脱敏
m0_71777195的博客
09-02 1518
通过自定义Java类型和类型转换器，并在mapper.xml里标注类型，通过mybatis进行加解密。加密算法可自由选择开发维护比较简单方便不存在适配多种数据库的问题创建一个空白类，在mapper.xml文件查询和新增修改时标注说明，表示需要mybatis进行相关类型转换。}复制代码这里使用国密SM4进行加解密，当然算法可自由选择别的如AES等。@MappedTypes注解映射刚才的自定义Java类@Overridetry {}
自定义Mybatis-plus插件(限制最大查询数量)
2301_76725413的博客
08-14 3059
​ 一次查询如果结果返回太多（1万或更多），往往会导致系统性能下降，有时更会内存不足，影响系统稳定性，故需要做限制。1.经分析最后决定，应限制一次查询返回的最大结果数量不应该超出1万，对于一次返回结果大于限制的时候应该抛出异常，而不应该截取(limit 10000)最大结果(结果需求不匹配)。2.利用mybatis拦截器技术，统一拦截sql,并真对大结果的查询先做一次count查询。 1.2 重写willDoQuery方法 1.3 代码解析 1.3.1 利用CCJSqlParserUtil解析
Mybatis插件+注解实现数据脱敏
hybaym的专栏
02-10 928
在项目中需要对用户敏感数据进行脱敏处理，例如身份证号、手机号等信息进行加密再入库。
MyBatis 插件 + 注解轻松实现数据脱敏
竹林幽深
04-21 757
发表于上海收录于合集#架构138个#Mybatis2个#加解密2个#技术原理10个。
MyBatis 自定义插件
书香水墨
10-24 2828
7、简述Mybatis的插件运行原理，以及如何编写一个插件。 答：Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是InvocationHandler的invoke()方法，当然，只会拦截那些你指定需要拦截的方法。 编写插件：实现Mybatis的Int
mybatis自定义插件
梁老师教你编程序
11-25 550
简单的说，mybatis插件就是对ParameterHandler、ResultSetHandler、StatementHandler、Executor这四个接口上的方法进行拦截，利用JDK动态代理机制，为这些接口的实现类创建代理对象，在执行方法时，先去执行代理对象的方法，从而执行自己编写的拦截逻辑，所以真正要用好mybatis插件，主要还是要熟悉这四个接口的方法以及这些方法上的参数的含义；如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。
如何对关键字段进行脱敏(一）在使用Mybatis-plus执行查询
最新发布
weixin_40914952的博客
07-04 671
为了在读取用户表中的mobile。
代码生成器:mybatis-plus-generator自定义模板生成 dto、vo、convertor
05-01
Mybatis-plus-generator是一个基于Mybatis-Plus框架的代码生成器。除了自动生成实体类、mapper以及对应的xml文件外，还可以使用自定义模板生成dto、vo、convertor。 在使用Mybatis-plus-generator自定义模板生成dto、vo、convertor时，我们需要先创建模板文件，模板文件主要包含模板语法和模板变量。模板语法是一种自定义的语言，用于对变量进行操作和组装，包括if语句、for循环等。而模板变量则是我们预先定义好的变量，在模板中可以直接使用。 在模板文件中，我们可以使用以下模板变量： entity：生成实体类的类对象。 entityName：生成实体类的类名。 fieldList：生成实体类中的所有成员变量列表。 field：生成实体类中的成员变量对象。 fieldName：生成实体类中的成员变量名。 fieldType：生成实体类中的成员变量类型。 columnName：生成实体类中对应的数据库表的列名。 通过使用模板语法和模板变量，我们可以自定义生成我们所需的dto、vo、convertor等文件，从而满足我们的需求。 总之，使用Mybatis-plus-generator自定义模板生成dto、vo、convertor是非常方便和实用的，可以大大提高我们的编程效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值