高效数据隔离方案：SpringBoot+Mybatis拦截器+JSqlParser全解析

关注

转载最新推荐文章于 2026-07-16 16:33:57 发布 157 阅读 AI 写同款· GEO 优化 ›

高效数据隔离方案：SpringBoot+JSqlParser 全解析 Mybatis 支持在 SQL 执行的不同阶段拦截并插入自定义逻辑。本文将通过拦截接口的prepare方法修改SQL语句，实现数据隔离的目的。拦截所有 query 语句并在条件中加入 env 条件@Component/*** 从配置文件中环境变量*/@Override//确保只有拦截的目标对象是 StatementHandler 类型时才执行特定逻辑// 获取 BoundSql 对象，包含原始 SQL 语句。阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：

《项目实战（视频）》：从书中学，往事上“练”
《互联网高频面试题》：面朝简历学习，春暖花开
《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题
《精进 Java 学习指南》：系统学习，互联网主流技术栈
《必读 Java 源码专栏》：知其然，知其所以然

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目，前端包括管理后台 + 微信小程序，后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、ERP、CRM、AI 大模型等等功能：

Boot 多模块架构：https://gitee.com/zhijiantianya/ruoyi-vue-pro
Cloud 微服务架构：https://gitee.com/zhijiantianya/yudao-cloud
视频教程：https://doc.iocoder.cn

【国内首批】支持 JDK 17/21 + SpringBoot 3.3、JDK 8/11 + Spring Boot 2.7 双版本

来源：juejin.cn/post/
7352075798067986458

在构建多租户系统或需要数据权限控制的应用时，数据隔离是一个关键问题，而解决这一问题的有效方案之一是在项目的数据库访问层实现数据过滤。

本文将介绍如何在 Spring Boot 项目中利用Mybatis的强大拦截器机制结合JSqlParser —— 一个功能丰富的 SQL 解析器，来轻松实现数据隔离的目标。本文根据示例展示如何根据当前的运行环境来实现数据隔离。

工具介绍

Mybatis拦截器

Mybatis 支持在 SQL 执行的不同阶段拦截并插入自定义逻辑。

本文将通过拦截 StatementHandler 接口的 prepare方法修改SQL语句，实现数据隔离的目的。

JSqlParser

JSqlParser 是一个开源的 SQL 语句解析工具，它可以对 SQL 语句进行解析、重构等各种操作：

能够将 SQL 字符串转换成一个可操作的抽象语法树（AST），这使得程序能够理解和操作 SQL 语句的各个组成部分。
根据需求对解析出的AST进行修改，比如添加额外的过滤条件，然后再将AST转换回SQL字符串，实现需求定制化的SQL语句构建。

SELECT语法树简图：

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

项目地址：https://github.com/YunaiV/ruoyi-vue-pro
视频教程：https://doc.iocoder.cn/video/

详细步骤

1. 导入依赖

Mybatis 依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>

JSqlParser 依赖：

<dependency>
    <groupId>com.github.jsqlparser</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>4.6</version>
</dependency>

注意：如果项目选择了 Mybatis Plus 作为数据持久层框架，那么就无需另外添加 Mybatis 和 JSqlParser 的依赖。

Mybatis Plus 自身已经包含了这两项依赖，并且保证了它们之间的兼容性。重复添加这些依赖可能会引起版本冲突，从而干扰项目的稳定性。

2. 定义一个拦截器

拦截所有 query 语句并在条件中加入 env 条件

import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.RowConstructor;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.statement.update.Update;
import net.sf.jsqlparser.statement.values.ValuesStatement;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
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.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
@Intercepts(
        {
                @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
        }
)
public class DataIsolationInterceptor implements Interceptor {
    /**
     * 从配置文件中环境变量
     */
    @Value("${spring.profiles.active}")
    private String env;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object target = invocation.getTarget();
        //确保只有拦截的目标对象是 StatementHandler 类型时才执行特定逻辑
        if (target instanceof StatementHandler) {
            StatementHandler statementHandler = (StatementHandler) target;
            // 获取 BoundSql 对象，包含原始 SQL 语句
            BoundSql boundSql = statementHandler.getBoundSql();
            String originalSql = boundSql.getSql();
            String newSql = setEnvToStatement(originalSql);
            // 使用MetaObject对象将新的SQL语句设置到BoundSql对象中
            MetaObject metaObject = SystemMetaObject.forObject(boundSql);
            metaObject.setValue("sql", newSql);
        }
        // 执行SQL
        return invocation.proceed();
    }

    private String setEnvToStatement(String originalSql) {
        net.sf.jsqlparser.statement.Statement statement;
        try {
            statement = CCJSqlParserUtil.parse(originalSql);
        } catch (JSQLParserException e) {
            throw new RuntimeException("EnvironmentVariableInterceptor::SQL语句解析异常："+originalSql);
        }
        if (statement instanceof Select) {
            Select select = (Select) statement;
            PlainSelect selectBody = select.getSelectBody(PlainSelect.class);
            if (selectBody.getFromItem() instanceof Table) {
                Expression newWhereExpression;
                if (selectBody.getJoins() == null || selectBody.getJoins().isEmpty()) {
                    newWhereExpression = setEnvToWhereExpression(selectBody.getWhere(), null);
                } else {
                    // 如果是多表关联查询，在关联查询中新增每个表的环境变量条件
                    newWhereExpression = multipleTableJoinWhereExpression(selectBody);
                }
                // 将新的where设置到Select中
                selectBody.setWhere(newWhereExpression);
            } else if (selectBody.getFromItem() instanceof SubSelect) {
                // 如果是子查询，在子查询中新增环境变量条件
                // 当前方法只能处理单层子查询，如果有多层级的子查询的场景需要通过递归设置环境变量
                SubSelect subSelect = (SubSelect) selectBody.getFromItem();
                PlainSelect subSelectBody = subSelect.getSelectBody(PlainSelect.class);
                Expression newWhereExpression = setEnvToWhereExpression(subSelectBody.getWhere(), null);
                subSelectBody.setWhere(newWhereExpression);
            }

            // 获得修改后的语句
            return select.toString();
        } else if (statement instanceof Insert) {
            Insert insert = (Insert) statement;
            setEnvToInsert(insert);

            return insert.toString();
        } else if (statement instanceof Update) {
            Update update = (Update) statement;
            Expression newWhereExpression = setEnvToWhereExpression(update.getWhere(),null);
            // 将新的where设置到Update中
            update.setWhere(newWhereExpression);

            return update.toString();
        } else if (statement instanceof Delete) {
            Delete delete = (Delete) statement;
            Expression newWhereExpression = setEnvToWhereExpression(delete.getWhere(),null);
            // 将新的where设置到delete中
            delete.setWhere(newWhereExpression);

            return delete.toString();
        }
        return originalSql;
    }

    /**
     * 将需要隔离的字段加入到SQL的Where语法树中
     * @param whereExpression SQL的Where语法树
     * @param alias 表别名
     * @return 新的SQL Where语法树
     */
    private Expression setEnvToWhereExpression(Expression whereExpression, String alias) {
        // 添加SQL语法树的一个where分支，并添加环境变量条件
        AndExpression andExpression = new AndExpression();
        EqualsTo envEquals = new EqualsTo();
        envEquals.setLeftExpression(new Column(StringUtils.isNotBlank(alias) ? String.format("%s.env", alias) : "env"));
        envEquals.setRightExpression(new StringValue(env));
        if (whereExpression == null){
            return envEquals;
        } else {
            // 将新的where条件加入到原where条件的右分支树
            andExpression.setRightExpression(envEquals);
            andExpression.setLeftExpression(whereExpression);
            return andExpression;
        }
    }

    /**
     * 多表关联查询时，给关联的所有表加入环境隔离条件
     * @param selectBody select语法树
     * @return 新的SQL Where语法树
     */
    private Expression multipleTableJoinWhereExpression(PlainSelect selectBody){
        Table mainTable = selectBody.getFromItem(Table.class);
        String mainTableAlias = mainTable.getAlias().getName();
        // 将 t1.env = ENV 的条件添加到where中
        Expression newWhereExpression = setEnvToWhereExpression(selectBody.getWhere(), mainTableAlias);
        List<Join> joins = selectBody.getJoins();
        for (Join join : joins) {
            FromItem joinRightItem = join.getRightItem();
            if (joinRightItem instanceof Table) {
                Table joinTable = (Table) joinRightItem;
                String joinTableAlias = joinTable.getAlias().getName();
                // 将每一个join的 tx.env = ENV 的条件添加到where中
                newWhereExpression = setEnvToWhereExpression(newWhereExpression, joinTableAlias);
            }
        }
        return newWhereExpression;
    }

    /**
     * 新增数据时，插入env字段
     * @param insert Insert 语法树
     */
    private void setEnvToInsert(Insert insert) {
        // 添加env列
        List<Column> columns = insert.getColumns();
        columns.add(new Column("env"));
        // values中添加环境变量值
        List<SelectBody> selects = insert.getSelect().getSelectBody(SetOperationList.class).getSelects();
        for (SelectBody select : selects) {
            if (select instanceof ValuesStatement){
                ValuesStatement valuesStatement = (ValuesStatement) select;
                ExpressionList expressions = (ExpressionList) valuesStatement.getExpressions();
                List<Expression> values = expressions.getExpressions();
                for (Expression expression : values){
                    if (expression instanceof RowConstructor) {
                        RowConstructor rowConstructor = (RowConstructor) expression;
                        ExpressionList exprList = rowConstructor.getExprList();
                        exprList.addExpressions(new StringValue(env));
                    }
                }
            }
        }
    }
}

3. 测试

Select

Mapper：

<select id="queryAllByOrgLevel" resultType="com.lyx.mybatis.entity.AllInfo">
    SELECT a.username,a.code,o.org_code,o.org_name,o.level
    FROM admin a left join organize o on a.org_id=o.id
    WHERE a.dr=0 and o.level=#{level}
</select>

刚进入拦截器时，Mybatis 解析的 SQL 语句：

SELECT a.username,a.code,o.org_code,o.org_name,o.level
        FROM admin a left join organize o on a.org_id=o.id
        WHERE a.dr=0 and o.level=?

执行完 setEnvToStatement(originalSql) 方法后，得到的新 SQL 语句：

SELECT a.username, a.code, o.org_code, o.org_name, o.level 
FROM admin a LEFT JOIN organize o ON a.org_id = o.id 
WHERE a.dr = 0 AND o.level = ? AND a.env = 'test' AND o.env = 'test'

Insert

刚进入拦截器时，Mybatis 解析的 SQL 语句：

INSERT INTO admin  ( id, username, code,   org_id )  VALUES (  ?, ?, ?,   ?  )

执行完 setEnvToInsert(insert) 方法后，得到的新 SQL 语句：

INSERT INTO admin (id, username, code, org_id, env) VALUES (?, ?, ?, ?, 'test')

Update

刚进入拦截器时，Mybatis 解析的 SQL 语句：

UPDATE admin  SET username=?, code=?,   org_id=?  WHERE id=?

执行完 setWhere(newWhereExpression) 方法后，得到的新 SQL 语句：

UPDATE admin SET username = ?, code = ?, org_id = ? WHERE id = ? AND env = 'test'

Delete

刚进入拦截器时，Mybatis 解析的 SQL 语句：

DELETE FROM admin WHERE id=?

执行完 setWhere(newWhereExpression) 方法后，得到的新 SQL 语句：

DELETE FROM admin WHERE id = ? AND env = 'test'

4. 为什么要拦截 StatementHandler 接口的 prepare 方法？

可以注意到，在这个例子中定义拦截器时 @Signature 注解中拦截的是 StatementHandler 接口的 prepare 方法，为什么拦截的是 prepare 方法而不是 query 和 update 方法？为什么拦截 query 和 update 方法修改 SQL 语句后仍然执行的是原 SQL ？

这是因为 SQL 语句是在 prepare 方法中被构建和参数化的。prepare 方法是负责准备 PreparedStatement 对象的，这个对象表示即将要执行的 SQL 语句。在 prepare 方法中可以对 SQL 语句进行修改，而这些修改将会影响最终执行的 SQL 。

而 query 和 update 方法是在 prepare 方法之后被调用的。它们主要的作用是执行已经准备好的 PreparedStatement 对象。在这个阶段，SQL 语句已经被创建并绑定了参数值，所以拦截这两个方法并不能改变已经准备好的 SQL 语句。

简单来说，如果想要修改SQL语句的内容（比如增加 WHERE 子句、改变排序规则等），那么需要在 SQL 语句被准备之前进行拦截，即在 prepare 方法的执行过程中进行。

以下是 MyBatis 执行过程中的几个关键步骤：

解析配置和映射文件： MyBatis 启动时，首先加载配置文件和映射文件，解析里面的 SQL 语句。
生成 StatementHandler 和 BoundSql： 当执行一个操作，比如查询或更新时，MyBatis 会创建一个 StatementHandler 对象，并包装了 BoundSql 对象，后者包含了即将要执行的 SQL 语句及其参数。
执行 prepare 方法： StatementHandler 的 prepare 方法被调用，完成 PreparedStatement 的创建和参数设置。
执行 query 或 update： 根据执行的是查询操作还是更新操作，MyBatis 再调用 query 或 update 方法来实际执行 SQL 。

通过在 prepare 方法进行拦截，我们可以在 SQL 语句被最终确定之前更改它，从而使修改生效。如果在 query 或 update 方法中进行拦截，则无法更改 SQL 语句，只能在执行前后进行其他操作，比如日志记录或者结果处理。

欢迎加入我的知识星球，全面提升技术能力。

👉 加入方式，“长按”或“扫描”下方二维码噢：

星球的内容包括：项目实战、面试招聘、源码解析、学习路线。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）

标签

#spring boot #mybatis #后端 #java #spring

原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247607241&idx=2&sn=810ff36aff6f1314e86d336861341dfa&chksm=fbe87dc7ad4c9cbb144415c978439c2685777e3b972137aacd561ac81b7dcd0e073e00a7f3a2&scene=126&sessionid=0>

SpringBoot+MyBatis数据权限实战：基于拦截器的SQL动态过滤方案数据权限是企业级应用安全架构的核心组成部分，它确保不同角色的用户在同一功能界面下只能访问授权范围内的数据。其实现原理是在数据库查询执行时动态注入过滤条件，从而在数据源头实现访问控制。这一技术对于保障系统安全、满足合规要求具有关键价值，广泛应用于金融、医疗、企业管理等对数据敏感度高的行业场景。通过MyBatis拦截器机制，可以在SQL执行前自动拼接权限条件，实现与业务逻辑的完全解耦。本文结合SpringBoot框架，深入探讨如何设计可解析的权限规则引擎，并解决多表关联、分页查询等工程实践中的典型问题，为构建健阅读详情

高效数据隔离方案：SpringBoot+Mybatis拦截器+JSqlParser全解析

相关推荐