SpringBoot集成MyBatis实现SQL拦截器的实战指南_Java

一、为什么需要sql拦截器？

先看几个真实场景：

慢查询监控：生产环境突然出现接口超时，需要快速定位执行时间过长的sql
数据脱敏：用户表查询结果中的手机号、身份证号需要自动替换为****
权限控制：多租户系统中，自动给sql添加tenant_id = ?条件，防止数据越权访问
sql审计：记录所有执行的sql语句、执行人、执行时间，满足合规要求

如果没有拦截器，这些需求可能需要修改每一个mapper接口或service方法，工作量巨大。

而mybatis的sql拦截器能在sql执行的各个阶段进行拦截处理，实现"无侵入式"增强。

二、mybatis拦截器基础

2.1 核心接口：interceptor

mybatis的拦截器机制基于jdk动态代理，所有自定义拦截器都要实现interceptor接口：

public interface interceptor {
    // 拦截逻辑的核心方法
    object intercept(invocation invocation) throws throwable;
    
    // 生成代理对象（通常直接用plugin.wrap()）
    object plugin(object target);
    
    // 读取配置参数（如从mybatis-config.xml中获取）
    void setproperties(properties properties);
}

2.2 拦截目标与签名配置

mybatis允许拦截4个核心组件的方法，通过@intercepts和@signature注解指定拦截目标：

举个栗子：拦截statementhandler的prepare方法（sql预编译阶段）：

@intercepts({
    @signature(
        type = statementhandler.class,  // 拦截哪个接口
        method = "prepare",             // 拦截接口的哪个方法
        args = {connection.class, integer.class}  // 方法参数类型（用于确定重载方法）
    )
})
public class mysqlinterceptor implements interceptor {
    // 实现接口方法...
}

注意：args参数必须严格匹配方法的参数类型，否则拦截不到！比如prepare方法有两个重载，这里指定(connection, integer)类型的参数。

三、实战一：慢查询监控拦截器

3.1 需求说明

监控所有sql执行时间，超过阈值（如500ms）则打印警告日志，包含：

sql执行时间
完整sql语句（带参数占位符）
参数值（防止sql注入排查）

3.2 完整实现代码

（1）拦截器类

import lombok.extern.slf4j.slf4j;
import org.apache.ibatis.executor.statement.statementhandler;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.resulthandler;
import java.sql.connection;
import java.sql.statement;
import java.util.properties;

@slf4j
@intercepts({
    // 拦截查询方法
    @signature(
        type = statementhandler.class,
        method = "query",
        args = {statement.class, resulthandler.class}
    ),
    // 拦截更新方法（insert/update/delete）
    @signature(
        type = statementhandler.class,
        method = "update",
        args = {statement.class}
    )
})
public class slowsqlinterceptor implements interceptor {

    // 慢查询阈值（毫秒），可通过配置文件注入
    private long slowthreshold = 500;

    @override
    public object intercept(invocation invocation) throws throwable {
        // 1. 记录开始时间
        long starttime = system.currenttimemillis();
        
        try {
            // 2. 执行原方法（继续sql执行流程）
            return invocation.proceed();
        } finally {
            // 3. 计算执行耗时（无论成功失败都记录）
            long costtime = system.currenttimemillis() - starttime;
            
            // 4. 获取sql语句和参数
            statementhandler statementhandler = (statementhandler) invocation.gettarget();
            string sql = statementhandler.getboundsql().getsql();  // 获取sql语句（带?占位符）
            object parameterobject = statementhandler.getboundsql().getparameterobject();  // 获取参数
            
            // 5. 判断是否慢查询
            if (costtime > slowthreshold) {
                log.warn("[慢查询警告] 执行时间: {}ms, sql: {}, 参数: {}", 
                         costtime, sql, parameterobject);
            } else {
                log.info("[sql监控] 执行时间: {}ms, sql: {}", costtime, sql);
            }
        }
    }

    @override
    public object plugin(object target) {
        // 生成代理对象（mybatis提供的工具方法，避免自己写代理逻辑）
        return plugin.wrap(target, this);
    }

    @override
    public void setproperties(properties properties) {
        // 从配置文件读取阈值（如application.yml中配置）
        string threshold = properties.getproperty("slowthreshold");
        if (threshold != null) {
            slowthreshold = long.parselong(threshold);
        }
    }
}

（2）springboot注册拦截器

package com.example.config;

import com.example.interceptor.sensitiveinterceptor;
import com.example.interceptor.slowsqlinterceptor;
import org.apache.ibatis.session.sqlsessionfactory;
import org.mybatis.spring.sqlsessionfactorybean;
import org.mybatis.spring.annotation.mapperscan;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
import org.springframework.core.io.support.pathmatchingresourcepatternresolver;
import javax.sql.datasource;
import java.util.properties;

@configuration
@mapperscan("com.example.mapper")  // mapper接口所在包
public class mybatisconfig {

    // 注册慢查询拦截器
    @bean
    public slowsqlinterceptor slowsqlinterceptor() {
        slowsqlinterceptor interceptor = new slowsqlinterceptor();
        
        // 设置属性（也可通过application.yml配置）
        properties properties = new properties();
        properties.setproperty("slowthreshold", "500");  // 慢查询阈值500ms
        interceptor.setproperties(properties);
        
        return interceptor;
    }

    @bean
    public sensitiveinterceptor sensitiveinterceptor() {
        return new sensitiveinterceptor();
    }

    // 将拦截器添加到sqlsessionfactory
    @bean
    public sqlsessionfactory sqlsessionfactory(datasource datasource, slowsqlinterceptor slowsqlinterceptor) throws exception {
        sqlsessionfactorybean sessionfactory = new sqlsessionfactorybean();
        sessionfactory.setdatasource(datasource);
        
        // 设置mapper.xml路径（如果需要）
        /*sessionfactory.setmapperlocations(
            new pathmatchingresourcepatternresolver()
                .getresources("classpath:mapper/*.xml")
        );*/
        
        // 添加拦截器
        sessionfactory.setplugins(slowsqlinterceptor);

        return sessionfactory.getobject();
    }
}
（3）测试效果
写个简单的查询接口：

@service
public class userservice {
    @autowired
    private usermapper usermapper;
    
    public user getuserbyid(long id) {
        return usermapper.selectbyid(id);
    }
}

执行后控制台输出：

[sql监控] 执行时间: 30ms, sql: select id,username,phone from user where id = ?
如果sql执行时间超过500ms（比如查询大数据量表）：

[慢查询警告] 执行时间: 1430ms, sql: select * from user where id = ?, 参数: {id=1, param1=1}
踩坑提示：如果拦截不到sql，检查@signature注解的args参数是否与方法参数类型完全匹配！

四、实战二：数据脱敏拦截器（敏感信息保护）

4.1 需求说明

查询用户信息时，自动将敏感字段脱敏：

手机号：13812345678 → 138****5678
身份证号：110101199001011234 → ****************34

4.2 完整实现代码

（1）自定义脱敏注解

import java.lang.annotation.*;

// 作用在字段上
@target(elementtype.field)
// 运行时生效
@retention(retentionpolicy.runtime)
public @interface sensitive {
    // 脱敏类型（手机号、身份证号等）
    sensitivetype type();
}

// 脱敏类型枚举
public enum sensitivetype {
    phone,    // 手机号
    id_card   // 身份证号
}

（2）实体类添加注解

import lombok.data;

@data
public class user {
    private long id;
    private string username;
    
    @sensitive(type = sensitivetype.phone)  // 手机号脱敏
    private string phone;
    
    @sensitive(type = sensitivetype.id_card)  // 身份证号脱敏
    private string idcard;
}

（3）脱敏工具类

public class sensitiveutils {
    // 手机号脱敏：保留前3位和后4位
    public static string maskphone(string phone) {
        if (phone == null || phone.length() != 11) {
            return phone;  // 非手机号格式不处理
        }
        return phone.replaceall("(\d{3})\d{4}(\d{4})", "$1****$2");
    }
    
    // 身份证号脱敏：保留最后2位
    public static string maskidcard(string idcard) {
        if (idcard == null || idcard.length() < 18) {
            return idcard;  // 非身份证格式不处理
        }
        return idcard.replaceall("\d{16}(\d{2})", "****************$1");
    }
}

（4）结果集拦截器

import lombok.extern.slf4j.slf4j;
import org.apache.ibatis.executor.resultset.resultsethandler;
import org.apache.ibatis.plugin.*;
import java.lang.reflect.field;
import java.sql.statement;
import java.util.list;
import java.util.properties;

@slf4j
@intercepts({
    @signature(
        type = resultsethandler.class,
        method = "handleresultsets",
        args = {statement.class}
    )
})
public class sensitiveinterceptor implements interceptor {

    @override
    public object intercept(invocation invocation) throws throwable {
        // 1. 执行原方法，获取查询结果
        object result = invocation.proceed();
        
        // 2. 如果结果是list，遍历处理每个元素
        if (result instanceof list<?>) {
            list<?> resultlist = (list<?>) result;
            for (object obj : resultlist) {
                // 3. 对有@sensitive注解的字段进行脱敏
                desensitize(obj);
            }
        }
        return result;
    }

    // 反射处理对象中的敏感字段
    private void desensitize(object obj) throws illegalaccessexception {
        if (obj == null) {
            return;
        }
        class<?> clazz = obj.getclass();
        field[] fields = clazz.getdeclaredfields();  // 获取所有字段（包括私有）
        
        for (field field : fields) {
            // 4. 检查字段是否有@sensitive注解
            if (field.isannotationpresent(sensitive.class)) {
                sensitive annotation = field.getannotation(sensitive.class);
                field.setaccessible(true);  // 开启私有字段访问权限
                object value = field.get(obj);  // 获取字段值
                
                if (value instanceof string) {
                    string strvalue = (string) value;
                    // 5. 根据脱敏类型处理
                    switch (annotation.type()) {
                        case phone:
                            field.set(obj, sensitiveutils.maskphone(strvalue));
                            break;
                        case id_card:
                            field.set(obj, sensitiveutils.maskidcard(strvalue));
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    }

    @override
    public object plugin(object target) {
        return plugin.wrap(target, this);
    }

    @override
    public void setproperties(properties properties) {
        // 可配置更多脱敏规则，此处省略
    }
}

（5）注册多个拦截器

修改mybatisconfig，添加脱敏拦截器：

@configuration
@mapperscan("com.example.mapper")
public class mybatisconfig {
    // ... 慢查询拦截器配置 ...

    @bean
    public sensitiveinterceptor sensitiveinterceptor() {
        return new sensitiveinterceptor();
    }

    @bean
    public sqlsessionfactory sqlsessionfactory(datasource datasource, 
                                             slowsqlinterceptor slowsqlinterceptor,
                                             sensitiveinterceptor sensitiveinterceptor) throws exception {
        sqlsessionfactorybean sessionfactory = new sqlsessionfactorybean();
        sessionfactory.setdatasource(datasource);
        sessionfactory.setmapperlocations(
            new pathmatchingresourcepatternresolver().getresources("classpath:mapper/*.xml")
        );
        
        // 注册多个拦截器（注意顺序！先执行的拦截器先注册）
        sessionfactory.setplugins(slowsqlinterceptor, sensitiveinterceptor);
        
        return sessionfactory.getobject();
    }
}

（6）测试效果

查询用户信息：

user user = userservice.getuserbyid(1l);
system.out.println(user); 
// 输出：user(id=1, username=张三, phone=138****5678, idcard=****************34)

五、实战踩坑指南

5.1 拦截器顺序问题

坑：多个拦截器时，注册顺序就是执行顺序。比如先注册慢查询拦截器，再注册脱敏拦截器：

sql执行 → 慢查询拦截器（记录时间） → 脱敏拦截器（处理结果）
如果顺序反了，脱敏拦截器会先处理结果，慢查询拦截器记录的sql就看不到原始参数了。

解决：按"执行sql前→执行sql后→处理结果"的顺序注册。

5.2 拦截器签名配置错误

坑：@signature的args参数类型写错，导致拦截不到方法。比如statementhandler.prepare方法有两个重载：

// 正确的参数类型
prepare(connection connection, integer transactiontimeout)
// 错误示例：写成了(int)
@signature(args = {connection.class, int.class}) // 出现下面的异常！

java.lang.nosuchmethodexception: org.apache.ibatis.executor.statement.statementhandler.prepare(java.sql.connection,int)

解决：通过ide查看方法参数类型，确保完全一致。

5.3 性能问题

坑：在拦截器中做复杂操作（如反射遍历所有字段）会影响性能。

解决：

反射操作缓存class信息
非必要不拦截（如只拦截查询方法）
敏感字段脱敏可考虑在dto层处理

到此这篇关于springboot集成mybatis实现sql拦截器的实战指南的文章就介绍到这了,更多相关springboot mybatis拦截sql内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

SpringBoot集成MyBatis实现SQL拦截器的实战指南

2025年07月21日 • Java •我要评论