mybatis-plus 拦截器敏感字段加解密

最新推荐文章于 2025-08-01 12:05:13 发布
原创 最新推荐文章于 2025-08-01 12:05:13 发布 · 5k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#mybatis #java

本文介绍了如何使用Mybatis-Plus的拦截器实现数据查询时的敏感信息脱敏和更新、插入操作时的数据加密。通过查询和更新拦截器，结合自定义注解，实现了在DO对象上标记加密字段，并在执行SQL前后进行加密和解密操作，确保数据安全。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

背景

数据库在保存数据时，对于某些敏感数据需要脱敏或者加密处理，如果一个一个的去加显然工作量大而且容易出错，这个时候可以考虑使用拦截器，本文针对的是mybatis-plus作为持久层框架，其他场景未测试。代码如下：

 

一、查询拦截器

package com.sfpay.merchant.service.interceptor;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.sfpay.merchant.service.service.CryptService;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.binding.MapperMethod;
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.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.ArrayList;
import java.util.Map;
import java.util.Objects;

/**
 * @describe: 查询拦截器
 * 查询条件加密使用方式：使用 @Param("decrypt")注解的自定义类型
 * 返回结果解密使用方式： ①在自定义的DO上加上注解 CryptAnnotation  ②在需要加解密的字段属性上加上CryptAnnotation
 * @author: ***
 * @date: 2021/3/30 17:51
 */
@Slf4j
@Intercepts({
        @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})
})
public class QueryInterceptor implements Interceptor {
    /**
     * 查询参数名称，ParamMap的key值
     */
    private static final String DECRYPT = "decrypt";

    @Autowired
    private CryptService cryptService;

    @Autowired
    private UpdateInterceptor updateInterceptor;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //获取查询参数，查询条件是否需要加密
        Object[] args = invocation.getArgs();
        Object parameter = args[1];
        Object result = null;
        //设置执行标识
        boolean flag = true;
        if (parameter instanceof MapperMethod.ParamMap) {
            Map paramMap = (Map) parameter;
            if (paramMap.containsKey(DECRYPT)) {
                Object queryParameter = paramMap.get(DECRYPT);
                if (updateInterceptor.needToCrypt(queryParameter)) {
                    //执行sql，还原加密后的报文
                    MappedStatement mappedStatement = (MappedStatement) args[0];
                    result = updateInterceptor.proceed(invocation, mappedStatement, queryParameter);
                    flag = false;
                }
            }
        }
        //是否需要执行
        if (flag) {
            result = invocation.proceed();
        }
        if (Objects.isNull(result)) {
            return null;
        }
        // 返回列表数据，循环检查
        if (result instanceof ArrayList) {
            ArrayList resultList = (ArrayList) result;
            if (CollectionUtils.isNotEmpty(resultList) && updateInterceptor.needToCrypt(resultList.get(0))) {
                for (Object o : resultList) {
                    cryptService.decrypt(o);
                }
            }
        } else if (updateInterceptor.needToCrypt(result)) {
            cryptService.decrypt(result);
        }
        //返回结果
        return result;
    }
}

 

一、插入和更新拦截器

package com.sfpay.merchant.service.interceptor;

import com.baomidou.mybatisplus.annotation.TableId;
import com.sfpay.merchant.common.util.annotation.CryptAnnotation;
import com.sfpay.merchant.service.service.CryptService;
import org.apache.ibatis.binding.MapperMethod;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.defaults.DefaultSqlSession;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

/**
 * @describe: 数据库更新操作拦截器
 * 一、支持的使用场景
 * ①场景一：通过mybatis-plus BaseMapper自动映射的方法
 * ②场景一：通过mapper接口自定义的方法，更新对象为自定义DO
 * 二、使用方法
 * ①在自定义的DO上加上注解 CryptAnnotation
 * ②在需要加解密的字段属性上加上CryptAnnotation
 * ③自定义映射方法在需要加解密的自定义DO参数使用@Param("et")
 * @author: ***
 * @date: 2021/3/31 17:51
 */
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})})
public class UpdateInterceptor implements Interceptor {

    @Autowired
    private CryptService cryptService;
    /**
     * 更新参数名称，ParamMap的key值
     */
    private static final String CRYPT = "et";

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //代理类方法参数，该拦截器拦截的update方法有两个参数args = {MappedStatement.class, Object.class}
        Object[] args = invocation.getArgs();
        //获取方法参数
        MappedStatement mappedStatement = (MappedStatement) args[0];
        Object parameter = args[1];
        if (Objects.isNull(parameter)) {
            //无参数，直接放行
            return invocation.proceed();
        }
        // 如果是多个参数或使用Param注解（Param注解会将参数放置在ParamMap中）
        if (parameter instanceof MapperMethod.ParamMap) {
            Map paramMap = (Map) parameter;
            if (paramMap.containsKey(CRYPT)) {
                Object updateParameter = paramMap.get(CRYPT);
                if (needToCrypt(updateParameter)) {
                    //执行sql，还原加解密后的报文
                    return proceed(invocation, mappedStatement, updateParameter);
                }
            }
        } else if (parameter instanceof DefaultSqlSession.StrictMap) {
            //不知道是啥意思，直接过
            return invocation.proceed();
        } else if (needToCrypt(parameter)) {
            //执行sql，还原加解密后的报文
            return proceed(invocation, mappedStatement, parameter);
        }
        //其他场景直接放行
        return invocation.proceed();
    }

    /**
     * 执行sql，还原加解密后的报文
     *
     * @param invocation
     * @param mappedStatement
     * @param parameter
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     * @throws InvocationTargetException
     */
    Object proceed(Invocation invocation, MappedStatement mappedStatement, Object parameter) throws IllegalAccessException, InstantiationException, InvocationTargetException {
        //先复制一个对象备份数据
        Object newInstance = newInstance(parameter);
        //调用加解密服务
        cryptService.encrypt(parameter);
        //执行操作，得到返回结果
        Object result = invocation.proceed();
        //把加解密后的字段还原
        reductionParameter(mappedStatement, newInstance, parameter);
        //返回结果
        return result;
    }

    /**
     * 先复制一个对象备份数据,便于加解密后还原原报文
     *
     * @param parameter
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private Object newInstance(Object parameter) throws IllegalAccessException, InstantiationException {
        Object newInstance = parameter.getClass().newInstance();
        BeanUtils.copyProperties(parameter, newInstance);
        return newInstance;
    }

    /**
     * 把加解密后的字段还原，同时把mybatis返回的tableId返回给参数对象
     *
     * @param mappedStatement
     * @param newInstance
     * @param parameter
     * @throws IllegalAccessException
     */
    private void reductionParameter(MappedStatement mappedStatement, Object newInstance, Object parameter) throws IllegalAccessException {
        //获取映射语句命令类型
        SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
        if (SqlCommandType.INSERT == sqlCommandType) {
            //从参数属性中找到注解是TableId的字段
            Field[] parameterFields = parameter.getClass().getDeclaredFields();
            Optional<Field> optional = Arrays.stream(parameterFields).filter(field -> field.isAnnotationPresent(TableId.class)).findAny();
            if (optional.isPresent()) {
                Field field = optional.get();
                field.setAccessible(true);
                Object id = field.get(parameter);
                //覆盖参数加解密的值
                BeanUtils.copyProperties(newInstance, parameter);
                field.set(parameter, id);
            } else {
                //覆盖参数加解密的值
                BeanUtils.copyProperties(newInstance, parameter);
            }
        } else {
            //覆盖参数加解密的值
            BeanUtils.copyProperties(newInstance, parameter);
        }
    }

    /**
     * 是否需要加解密：
     * ①是否属于基本类型，void类型和String类型，如果是，不加解密
     * ②DO上是否有注解 ③ 属性是否有注解
     *
     * @param object
     * @return
     */
    public boolean needToCrypt(Object object) {
        if (object == null) {
            return false;
        }
        Class<?> clazz = object.getClass();
        if (clazz.isPrimitive() || object instanceof String) {
            //基本类型和字符串不加解密
            return false;
        }
        //获取DO注解
        boolean annotationPresent = clazz.isAnnotationPresent(CryptAnnotation.class);
        if (!annotationPresent) {
            //无DO注解不加解密
            return false;
        }
        //获取属性注解
        Field[] fields = clazz.getDeclaredFields();
        return Arrays.stream(fields).anyMatch(field -> field.isAnnotationPresent(CryptAnnotation.class));
    }
}

三、注解

import com.sfpay.merchant.common.constant.EncryptDataTypeEnum;

import java.lang.annotation.*;

/**
 * @author ***
 * @Date 2020/12/30 20:13
 * @description 加密注解类
 * @Param
 * @return
 **/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
@Documented
@Inherited
public @interface CryptAnnotation {
    EncryptDataTypeEnum type() default EncryptDataTypeEnum.OTHER;
}

cryptService 为加密服务，怎么实现自己可以根据实际情况来实现。

 

 

mybatis-plus实现数据字段加解密
alan3258的专栏
04-13 3648
在需要加解密的实体类头部添加注解@EncryptedTable，同时在需要加解密的字段上添加@EncryptedField注解即可。
【Mybatis】基于Mybatis拦截器+注解，实现敏感数据自动加解密
颗粒归仓
03-15 3490
我司最近在做等保，要求数据库里面的手机号、微信号、身份证号等等这些在数据库中都不能是明文，所以需要把数据库中的涉及到这些的加密保存，但是查询和保存的接口传参不受影响，之前业务给前端返回是什么样子依然保持不变，这样前端不受影响。
MyBatis-Plus分页拦截器原理深度解析
llwszx的博客
07-06 1027
在企业级应用开发中，分页查询是几乎所有数据交互场景的基础需求。MyBatis-Plus作为MyBatis的增强工具，通过分页拦截器提供了简洁高效的分页解决方案。本文将从原理、实现到优化，全面剖析MyBatis-Plus分页拦截器的工作机制。
mybatis-plus（mysql+springboot）实现字段的加解密
wang_bjfu的博客
03-19 897
项目开发，会对表字段进行进行脱敏操作，如身份证号，手机号等等，通过继承mybatis-plusti提供的BaseTypeHandler类来统一处理这类问题。1.导入依赖（gradle） 加密算法可以使用现成的（如：hutool包提供的AES），也可以自定义，最好是自定义，我这里使用的是自定义的加密算法。4.简单测试（使用dubug，跟着流程看到的效果更好，只要走到NeedEncryptAttributeHandler类，说明以及拦截到）2.增加数据库加解密Handler,指定加解密字段。
Mybatis-plus数据库表字段加解密存储
weixin_45906061的博客
08-05 6718
项目开发过程中，经常遇到敏感信息加密存储，如身份证号、手机号等，常规操作为存、取数据时对字段值进行单独加、解密处理，不利于维护且扩展性差，今天我们通过继承mybatis-plus（mybatis同样适用）提供的BaseTypeHandler类来统一解决此类问题。一、导入依赖（基于springboot），加密算法使用hutool包提供的AES，自行导入其他加密包也可。...
MyBatis拦截器插件：实现敏感数据字段加解密
秃了也弱了
07-22 544
日常开发中，经常有一些敏感数据，直接写入数据库的话，很容易泄露。本文基于mybatis拦截器插件，实现敏感数据的加解密。
MyBatis-plus拦截器
热门推荐
梧桐树的博客
07-29 2万+
在项目中，会出现一些对sql处理的需求，如果sql操作很多，为了简化处理，可以在sql执行的时候加入一个，并对将要执行的sql进行统一的处理。
mybatis-plus 源码（mybatis-plus-3.0.zip）
03-03
11. **插件机制**：MyBatis-Plus允许开发者自定义拦截器，实现全局操作如日志记录、性能分析等功能。 12. **通用Mapper**：提供了一些基本的CRUD方法，如selectById、insert、updateById等，无需手动编写SQL。 13....
SpringBoot集成MyBatis-Plus实现国产数据库适配.docx
05-20
SpringBoot 集成 MyBatis-Plus 实现国产数据库适配 MyBatis-Plus 是一款在 MyBatis 的基础上进行扩展的开源工具包，只做增强不做改变，引入 MyBatis-Plus 不会对您现有的 Mybatis 构架产生任何影响。MyBatis-Plus ...
MyBatis-Plus 学习笔记.pdf
08-30
MyBatis-Plus 学习笔记 MyBatis-Plus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、...
mybatis-plus-3.0
04-13
4. **填充实体类**：在查询结果集映射到实体类时，MyBatis-Plus能自动填充创建时间和更新时间等字段，减少了手动设置这些字段的步骤。 5. **主键自增**：对于具有自增主键的表，MyBatis-Plus可以自动处理插入时的...
mybatis-plus 数据字段进行加解密入库，且加密字段支持模糊搜索
从零开始的博客
09-09 2908
需求很简单： 就是将数据存储到数据库，并且将敏感数据字段进行加密处理保存（比如：身份证，手机号，银行卡 等等）需求也很变态：加密的数据要模糊搜素！！如果需求不需要模糊搜素，直接加密入库就完事了，直接看这篇文章mybatis-plus进行数据字段加密解密入库，就可以了！工具类import cn/**/*** iktry {Lexeme le;= null) {} /*** 部分分词} }/**/*** ik。
Mybatis Plus拦截器
weixin_42502300的博客
07-12 3595
Mybatis Plus使用拦截器控制补充SQL控制权限
Mybatis拦截器Interceptor实现加解密
wind_chasing_boy的博客
06-13 7991
最近项目使用Mybatis拦截器对数据进行加解密，以下记录如何将拦截器集成到项目中以及在使用过程中踩过的一些小坑，与君共勉Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。SqlSessionFactory：SqlSession工厂。
MyBatis Plus 敏感字段加解密与脱敏实战
2023年最新地推相关信息
04-30 977
登录后复制/*** 标记需要加密的字段*/1.2.3.4.5.6.7.8.9.10.11.12.13.登录后复制@Bean// 配置mapper位置// 配置全局TypeHandler// 注册通用加密TypeHandler/*** 自定义MyBatis Plus处理器，用于拦截实体类字段处理*/@Bean/*** 实体字段加密处理器，拦截带有@Encrypt注解的字段*/
MyBatis-Plus 拦截器
qq_33271461的博客
08-31 3290
MyBatis-Plus 拦截器是一个实现了 MyBatis 拦截器接口的组件，可以在 MyBatis 的执行过程中拦截和处理 SQL 语句。它允许开发者在 SQL 执行前后插入自定义的逻辑，例如记录日志、修改 SQL 语句等。MyBatis 的拦截器机制允许开发者在 MyBatis 的执行流程中插入自定义逻辑。Executor：负责执行 SQL 语句的组件。：负责准备 SQL 语句并将其传递给数据库的组件。：负责将参数设置到 SQL 语句中的组件。：负责处理查询结果集的组件。拦截器通过实现。
MyBatis-Plus 优雅实现数据加密存储
一碗清深的博客
02-22 6277
本文将基于Mybatis-Plus讲述如何在数据的源头存储层保障其安全。我们都知道一些核心私密字段，比如说密码，手机号等在数据库层存储就不能明文存储，必须加密存储保证即使数据库泄露了也不会轻易曝光数据。
mybatisPlus自定义拦截器
weixin_43381157的博客
09-08 8901
mybatisPlus
MyBatis-Plus 实战：敏感字段自动加解密支持模糊查询
最新发布
蔡定努
08-01 47
本文基于MyBatis-Plus框架提出了一种全链路敏感字段加密方案。通过自定义TypeHandler实现数据入库自动加密和查询自动解密，结合重写LambdaQueryWrapper处理查询条件加密，并适配多种查询方式。方案核心包括：1）AESUtil工具类提供加解密基础能力；2）EncryptTypeHandler实现字段类型转换；3）实体类通过注解配置加密字段。该方案在保证数据安全的同时，对业务代码侵入性小，支持姓名、手机号等敏感信息的全流程加密处理，满足系统开发的安全需求。
MyBatis-Plus 3.4 拦截器对敏感数据实现加密
03-27
<think>嗯，用户想了解如何使用MyBatis-Plus 3.4的拦截器来实现敏感数据加密。我之前处理过类似的问题，记得MyBatis-Plus的拦截器可以用来在SQL执行前后进行自定义处理。首先，我需要确认用户提到的MyBatis-Plus版本是3.4，这可能涉及到特定的API，比如MetaObjectHandler或者自定义的TypeHandler。 根据引用[1]，里面提到了自定义TypeHandler来实现加密解密逻辑，同时在配置中注册它，并在实体类中使用。这可能是一个关键点。不过用户提到的是拦截器，而TypeHandler通常用于类型转换，可能在数据写入和读取时处理加密解密。而拦截器比如InnerInterceptor可能用于更底层的SQL处理，比如分页或者乐观锁，如引用[5]中的例子。 但用户的问题明确提到“拦截器”，所以可能需要结合两种方法。例如，在插入或更新时，使用拦截器来拦截参数，并对其中的敏感字段进行加密。或者，可能需要在TypeHandler中处理加密，而拦截器用于某些其他操作，比如自动添加加密逻辑。 另外，引用[3]提到了元对象处理器接口，这可能是在插入或更新时自动填充某些字段，比如版本号。或许加密也可以在元对象处理器中处理，但需要确认是否适合。 步骤可能包括：定义加密服务接口，创建自定义TypeHandler，在实体类中指定该TypeHandler，并在MyBatis配置中注册。同时，可能需要在拦截器中处理参数，比如在更新或插入前加密数据，查询后解密数据。或者，使用TypeHandler在数据写入数据库前加密，读取时解密，这样拦截器可能不需要处理具体的加密逻辑，而是TypeHandler自动处理。 需要确保加密逻辑在数据持久化时自动应用。例如，在实体类的字段上使用@TableField(typeHandler = EncryptTypeHandler.class)，这样MyBatis-Plus在读写该字段时会自动调用TypeHandler的setParameter和getResult方法，从而进行加密和解密。 同时，参考引用[5]中的配置类，用户可能需要添加自定义的拦截器，但可能更直接的是使用TypeHandler。不过用户明确提到拦截器，可能需要澄清是否必须使用拦截器，或者TypeHandler是否足够。或者，拦截器用于更复杂的场景，比如全局处理所有敏感字段，而无需在每个字段上标注TypeHandler。 可能需要分步骤来：首先实现加密解密的逻辑，然后通过TypeHandler或拦截器来应用。根据引用[1]的步骤，自定义TypeHandler可能更直接。但用户的问题提到拦截器，所以可能需要结合两者，或者说明拦截器的另一种实现方式。 例如，可以创建一个实现InnerInterceptor接口的拦截器，重写beforePrepare方法，在参数设置前进行加密，在结果处理时进行解密。不过这可能比较复杂，需要处理不同的SQL操作类型，如INSERT、UPDATE、SELECT等。 总结可能的步骤：1. 创建加密工具类；2. 自定义TypeHandler处理字段级别的加密；3. 在实体类中使用该TypeHandler；4. 注册TypeHandler到MyBatis配置。或者，使用拦截器在SQL执行前后处理参数和结果集。 需要查阅MyBatis-Plus的文档，确认拦截器和TypeHandler的最佳实践。根据现有引用，引用[1]使用TypeHandler，而引用[5]使用拦截器处理乐观锁和分页。因此，可能两者都可以，但TypeHandler更适合字段级别的处理，而拦截器更适合全局处理或更复杂的逻辑。 因此，回答应该结合引用[1]中的步骤，使用TypeHandler实现加密解密，并可能提到拦截器的其他用途，或者如何结合拦截器进行更高级的处理。但用户的问题是关于拦截器的实现方式，可能需要调整方法，或者说明TypeHandler是更合适的解决方案，而拦截器可能用于其他方面。 可能的混淆点：TypeHandler和拦截器的不同作用。TypeHandler用于处理单个字段的Java类型到JDBC类型的转换，适合加密解密单个字段。拦截器可以拦截整个SQL语句，处理参数和结果集，适合更广泛的操作，比如全局加密多个字段，或者根据条件动态处理。 因此，正确的实现方式可能是使用TypeHandler处理字段级别的加密，如引用[1]所述，而拦截器可能用于更复杂的场景。但用户的问题明确询问拦截器，所以可能需要解释如何通过拦截器来实现，或者指出TypeHandler是更常见的方法，而拦截器可以辅助其他处理。 最终，可能需要按照引用[1]的方法，使用TypeHandler，并在回答中说明这是MyBatis-Plus推荐的字段级加密方式，同时可能提及拦截器可以用于其他方面的增强，如自动触发加密逻辑，或者在特定操作前后进行处理。</think>### 如何使用 MyBatis-Plus 3.4 拦截器实现敏感数据加密？ #### 实现步骤 1. **定义加密解密工具类** 实现对称加密（如 AES）或非对称加密算法，提供加密和解密方法。例如： ```java public class EncryptUtils { public static String encrypt(String data) { /* 加密逻辑 */ } public static String decrypt(String encryptedData) { /* 解密逻辑 */ } } ``` 2. **创建自定义 TypeHandler** 继承 `BaseTypeHandler`，在数据写入数据库前加密，读取时解密。这是字段级加密的核心逻辑[^1]。 ```java public class EncryptTypeHandler extends BaseTypeHandler<String> { @Override public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) { ps.setString(i, EncryptUtils.encrypt(parameter)); } @Override public String getNullableResult(ResultSet rs, String columnName) { return EncryptUtils.decrypt(rs.getString(columnName)); } // 其他重写方法... } ``` 3. **实体类标注 TypeHandler** 在敏感字段上使用 `@TableField` 注解绑定自定义 TypeHandler： ```java public class User { @TableField(typeHandler = EncryptTypeHandler.class) private String phoneNumber; // 其他字段... } ``` 4. **注册 TypeHandler** 在 MyBatis 配置文件中添加 TypeHandler 的全局注册： ```xml <typeHandlers> <typeHandler handler="com.example.EncryptTypeHandler" javaType="java.lang.String"/> </typeHandlers> ``` 5. **通过拦截器增强控制（可选）** 若需全局拦截 SQL 操作（如记录加密日志），可自定义拦截器实现 `InnerInterceptor`： ```java public class EncryptInterceptor implements InnerInterceptor { @Override public void beforePrepare(StatementHandler sh, Connection conn, Integer transactionTimeout) { // 拦截参数并处理敏感数据（需结合反射或 MetaObject 修改字段值） } } ``` 在配置类中注册拦截器： ```java @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new EncryptInterceptor()); return interceptor; } ``` #### 核心逻辑说明 - **TypeHandler 作用**：直接关联字段的读写操作，自动触发加密/解密[^1]。 - **拦截器适用场景**：补充全局操作（如审计日志），但字段级加密优先使用 TypeHandler[^5]。 #### 注意事项 - 加密字段需避免参与索引查询，否则需实现模糊加密（如哈希处理）。 - 加解密可能影响性能，建议仅对高敏感字段（如手机号、身份证号）使用。 ---
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值