mybatis 拦截器+ sqlparser 实现系统数据隔离

前言：因为系统要服务另外一家公司，那么问题就来了。1，采用分布式系统，推翻原有的系统架构。2，业务是一致的主要是不同的公司，互补影响，那么就要从数据上做隔离，想到了分库。总之，大概思考了一个小时，决定来使用mybatis拦截器尝试来实现。大致是在现有数据库所有的业务表都加入 companyId 字段，以此字段来作为区分和拦截的由于之前没有使用过mybatis拦截器，那么一切都从0 开始百度+查询资料；网上有很多关于拦截器的资料信息，这里贴上两处本人认为有用的参考资料 A 拦截器原理出处：https://www.jianshu.com/p/7c7b8c2c985d

1 拦截器的四种代理模式， StatementHandler是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里我采用的是其中的一种模式用插件来实现对一级缓存的操作(禁用等等)。

2 拦截器模式定下，那么开始在spring-mybatis.xml 加入拦截器插件；

<array>

</array>

</property>

package com.wangzhixuan.commons.intercept;

import java.io.StringReader;

import java.lang.reflect.InvocationTargetException;

import java.sql.Connection;

import java.util.Properties;

import org.apache.ibatis.executor.statement.StatementHandler;

import org.apache.ibatis.mapping.BoundSql;

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.Plugin;

import org.apache.ibatis.plugin.Signature;

import org.apache.ibatis.reflection.MetaObject;

import org.apache.ibatis.reflection.SystemMetaObject;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import com.wangzhixuan.commons.sqlparser.SelectVisitorImpl;

import net.sf.jsqlparser.parser.CCJSqlParserManager;

import net.sf.jsqlparser.statement.select.Select;

@Intercepts({

@Signature(method = "prepare", type = StatementHandler.class, args = { Connection.class, Integer.class})

})

public class TestInterceptor implements Interceptor {

// 控制器本来就是单例，这样似乎更加合理

protected Logger logger = LogManager.getLogger(getClass());

private CCJSqlParserManager parserManager = new CCJSqlParserManager();

@Override

public Object intercept(Invocation invocation) throws InvocationTargetException, IllegalAccessException {

if(invocation.getTarget() instanceof StatementHandler) {

//逻辑代码区

StatementHandler statementHandler = (StatementHandler)invocation.getTarget();

MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);

// 分离代理对象链(由于目标类可能被多个拦截器拦截，从而形成多次代理，通过下面的两次循环

// 可以分离出最原始的的目标类)

while (metaStatementHandler.hasGetter("h")) {

Object object = metaStatementHandler.getValue("h");

metaStatementHandler = SystemMetaObject.forObject(object);

}

// 分离最后一个代理对象的目标类

while (metaStatementHandler.hasGetter("target")) {

Object object = metaStatementHandler.getValue("target");

metaStatementHandler = SystemMetaObject.forObject(object);

}

MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement");

//获取sql

BoundSql boundSql = statementHandler.getBoundSql();

String sql = boundSql.getSql();

if(sql.contains("NEXTVAL")){ // 去掉子序列函数

return invocation.proceed();

}

//获取方法id

String id = mappedStatement.getId();

if (id.contains("InventoryInoutMapper") || id.contains("selectSaleReportByGmtCreate")

|| id.contains("selectBiShipReportByGmtCreate") || id.contains("selectTransNoinventoryReport")

|| id.contains("queryPurStoDetails") || id.contains("queryTaskDailyCloseIds")) { // 剔除不需要走拦截器的方法

return invocation.proceed();

}

//获得方法类型

SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();

if ("SELECT".equals(sqlCommandType.toString())) { // 拦截主要是针对查询语句的

//如果是select就将sql转成SELECT对象

try {

Select select = (Select)parserManager.parse(new StringReader(sql));

//访问各个visitor

select.getSelectBody().accept(new SelectVisitorImpl());

//将增强后的sql放回

metaStatementHandler.setValue("delegate.boundSql.sql", select.toString());

return invocation.proceed();

} catch(Throwable e) {

logger.error("拦截器异常Start");

logger.error(e);

logger.error("拦截器异常End");

}

return invocation.proceed();

}

@Override

public Object plugin(Object target) {

//生成代理对象

return Plugin.wrap(target, this);

}

@Override

public void setProperties(Properties properties) {

}

//下面是sqlpase的具体用法（这里我采用的是访问者模式对于所涉及的业务表进行隔离）

package com.wangzhixuan.commons.sqlparser;

import java.util.HashSet;

import org.apache.shiro.SecurityUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.google.common.collect.Sets;

import com.wangzhixuan.commons.shiro.ShiroUser;

import net.sf.jsqlparser.expression.Expression;

import net.sf.jsqlparser.expression.LongValue;

import net.sf.jsqlparser.expression.operators.conditional.AndExpression;

import net.sf.jsqlparser.expression.operators.relational.Between;

import net.sf.jsqlparser.expression.operators.relational.EqualsTo;

import net.sf.jsqlparser.expression.operators.relational.GreaterThan;

import net.sf.jsqlparser.expression.operators.relational.GreaterThanEquals;

import net.sf.jsqlparser.expression.operators.relational.IsNullExpression;

import net.sf.jsqlparser.expression.operators.relational.LikeExpression;

import net.sf.jsqlparser.expression.operators.relational.MinorThan;

import net.sf.jsqlparser.expression.operators.relational.MinorThanEquals;

import net.sf.jsqlparser.expression.operators.relational.NotEqualsTo;

import net.sf.jsqlparser.schema.Column;

import net.sf.jsqlparser.schema.Table;

import net.sf.jsqlparser.statement.select.FromItemVisitor;

import net.sf.jsqlparser.statement.select.LateralSubSelect;

import net.sf.jsqlparser.statement.select.SubJoin;

import net.sf.jsqlparser.statement.select.SubSelect;

import net.sf.jsqlparser.statement.select.TableFunction;

import net.sf.jsqlparser.statement.select.ValuesList;

public class FromItemVisitorImpl implements FromItemVisitor {

private static Logger logger = LoggerFactory.getLogger(FromItemVisitorImpl.class);

// 声明增强条件

private Expression enhancedCondition;

// 定义需要数据隔离的表

private static HashSet<String> interceptTableSet = Sets.newHashSet();

static {

interceptTableSet.add("ITEM");//商品管理数据隔离; 同时item 表中新增 company_id 字段

interceptTableSet.add("ITEM_SKU");//SKU管理数据隔离;

interceptTableSet.add("INVENTORY");//SKU 管理展示库存

interceptTableSet.add("BRAND");//品牌管理

interceptTableSet.add("`OUTER_ORDER`");//主订单管理

interceptTableSet.add("`OUTER_ORDER_DETAIL`");// 主订单明细管理

interceptTableSet.add("ERP_ORDER");//子订单管理

interceptTableSet.add("TASK_DAILY");//采购单

interceptTableSet.add("TASK_DAILY_DETAIL");//采购单明细

interceptTableSet.add("PURCHASE_STORAGE");//采购入库单

interceptTableSet.add("PURCHASE_STORAGE_DETAIL");//采购入库单明细

interceptTableSet.add("INVENTORY_AREA");//库存占用表

interceptTableSet.add("INVENTORY_OUT");//库存记录库记录表

interceptTableSet.add("WAREHOUSE");//仓库改造

interceptTableSet.add("INVENTORY_INOUT");//出入库记录表 {硬编码}

//interceptTableSet.add("`SHIPPING_ORDER`");//发货管理 {硬编码}

//interceptTableSet.add("TASK_DAILY_ORDER");//订单生成采购单 {硬编码}

//interceptTableSet.add("TASK_DAILY_ORDER_HISTORY");// 订单生成采购单历史记录 {硬编码}

interceptTableSet.add("TASK_DAILY_ORDER_UNCOMPLETE"); //未完成采购表

interceptTableSet.add("`ERP_RETURN_ORDER`"); //退单表

interceptTableSet.add("`SELLER_TYPE`");//销售类别表

interceptTableSet.add("`SELLER`");//销售人员表

interceptTableSet.add("`WX_PURCHASE_USER`");//买手人员表

interceptTableSet.add("`GOODS_CASE`");//货源信息反馈表

interceptTableSet.add("LOGISTIC_COMPANY");//快递公司

interceptTableSet.add("RECEIPT");//小票

interceptTableSet.add("RECEIPT_GROUP");//小票另存表

interceptTableSet.add("TASK_RECEIPT");//小票明细

interceptTableSet.add("FIND_ITEM");//发现商品

interceptTableSet.add("FIND_ITEM_SKU");//发现商品sku

interceptTableSet.add("FILE_MANAGE");//文件管理

}

// FROM 表名 <----主要的就是这个，判断用户对这个表有没有权限

@Override

public void visit(Table tableName) {

//判断该表是否是需要操作的表

if (isActionTable(tableName.getFullyQualifiedName())) {

// 声明表达式数组

Expression[] expressions;

// 其他情况,也就是最常用的情况，比如where 1 = 1

Column column = new Column(new Table(tableName.getAlias()!=null?tableName.getAlias().getName():tableName.getFullyQualifiedName()), "company_id");

if(getShiroUser()== null){

return;

}else {

expressions = new Expression[] {column, new LongValue(getShiroUser().getCompanyId())};

}

// 根据运算符对原始数据进行拼接

Expression operator = this.getOperator("=", expressions);

if (this.enhancedCondition != null) {

enhancedCondition = new AndExpression(enhancedCondition , operator);

} else {

enhancedCondition = operator;

}

// FROM 子查询

@Override

public void visit(SubSelect subSelect) {

// 如果是子查询的话返回到select接口实现类

subSelect.getSelectBody().accept(new SelectVisitorImpl());

}

// FROM subjoin

@Override

public void visit(SubJoin subjoin) {

subjoin.getLeft().accept(new FromItemVisitorImpl());

subjoin.getJoin().getRightItem().accept(new FromItemVisitorImpl());

}

// FROM 横向子查询

@Override

public void visit(LateralSubSelect lateralSubSelect) {

lateralSubSelect.getSubSelect().getSelectBody()

.accept(new SelectVisitorImpl());

}

// FROM value列表

@Override

public void visit(ValuesList valuesList) {

}

// FROM tableFunction

@Override

public void visit(TableFunction tableFunction) {

}

// 将字符串类型的运算符转换成数据库运算语句

private Expression getOperator(String op, Expression[] exp) {

if ("=".equals(op)) {

EqualsTo eq = new EqualsTo();

eq.setLeftExpression(exp[0]);

eq.setRightExpression(exp[1]);

return eq;

} else if (">".equals(op)) {

GreaterThan gt = new GreaterThan();

gt.setLeftExpression(exp[0]);

gt.setRightExpression(exp[1]);

return gt;

} else if (">=".equals(op)) {

GreaterThanEquals geq = new GreaterThanEquals();

geq.setLeftExpression(exp[0]);

geq.setRightExpression(exp[1]);

return geq;

} else if ("<".equals(op)) {

MinorThan mt = new MinorThan();

mt.setLeftExpression(exp[0]);

mt.setRightExpression(exp[1]);

return mt;

} else if ("<=".equals(op)) {

MinorThanEquals leq = new MinorThanEquals();

leq.setLeftExpression(exp[0]);

leq.setRightExpression(exp[1]);

return leq;

} else if ("<>".equals(op)) {

NotEqualsTo neq = new NotEqualsTo();

neq.setLeftExpression(exp[0]);

neq.setRightExpression(exp[1]);

return neq;

} else if ("is null".equalsIgnoreCase(op)) {

IsNullExpression isNull = new IsNullExpression();

isNull.setNot(false);

isNull.setLeftExpression(exp[0]);

return isNull;

} else if ("is not null".equalsIgnoreCase(op)) {

IsNullExpression isNull = new IsNullExpression();

isNull.setNot(true);

isNull.setLeftExpression(exp[0]);

return isNull;

} else if ("like".equalsIgnoreCase(op)) {

LikeExpression like = new LikeExpression();

like.setNot(false);

like.setLeftExpression(exp[0]);

like.setRightExpression(exp[1]);

return like;

} else if ("not like".equalsIgnoreCase(op)) {

LikeExpression nlike = new LikeExpression();

nlike.setNot(true);

nlike.setLeftExpression(exp[0]);

nlike.setRightExpression(exp[1]);

return nlike;

} else if ("between".equalsIgnoreCase(op)) {

Between bt = new Between();

bt.setNot(false);

bt.setLeftExpression(exp[0]);

bt.setBetweenExpressionStart(exp[1]);

bt.setBetweenExpressionEnd(exp[2]);

return bt;

} else if ("not between".equalsIgnoreCase(op)) {

Between bt = new Between();

bt.setNot(true);

bt.setLeftExpression(exp[0]);

bt.setBetweenExpressionStart(exp[1]);

bt.setBetweenExpressionEnd(exp[2]);

return bt;

} else {

// 如果没有该运算符对应的语句

return null;

}

public Expression getEnhancedCondition() {

return enhancedCondition;

}

// 判断传入的table是否是要进行操作的table

public boolean isActionTable(String tableName) {

boolean flag = false;

if (interceptTableSet.contains(tableName.toUpperCase())) {

flag = true;

}

return flag;

}

public ShiroUser getShiroUser() {

ShiroUser one = (ShiroUser) SecurityUtils.getSubject().getPrincipal();

return one;

}

mybatis 拦截器+ sqlparser 实现系统数据隔离

继续阅读

数据隔离、访问授权，用好大数据为什么这么难？

京东三面：spring事务中的数据隔离——JUMap

数据和行为两者兼顾的所有权只有聚合才能具有通常情况下，数据和行为是分离的，行为在服务中实现，而数据隔离在数据表中，行为通

手机APP每一次更新，都是在修复和增加功能，需要的空间就会越来越大。常用的APP涉及的功能太多，重构的话不太现实，应用都

关于并发编程线程间数据隔离和安全，ThreadLocal给出高质量答案

鼎桥又出新手机了，“华为智选”你还买吗？最近，鼎桥又推出了新产品，分别是Mate50、Mate50E与Mate50Pro

Spark源码解析之SparkSql

LeaRun快速开发框架支持开启多租户模式，提供多种数据隔离实现方式，可以通过数据库级别隔离，也可以通过租户ID字段隔离

SaaS 多租户架构持久层的设计（四）SQL数据库的数据隔离

为什么要做数据可视化设计呢？因为数据大屏可以打破数据隔离，通过数据采集、清洗、分析到直观实时的数据可视化，即时呈现隐藏在

兴业普惠触摸屏设计[无辜笑][无辜笑][无辜笑]，为了承载业务的新发展和满足各个模块的运营需求，给业务赋能。1.构建统一

数字能力新基座。数据存储在UDC中是以何种形态存在？传统的存储方式以文件为单位，然而企业级的文件中台需要附带业务属性，否

关于shell文本处理