原因: 在工作中因数据量的问题需要分表，在添加分表拦截器时发现使用springboot自动加载pageHelper插件时无法将分页插件放置到分表插件后执行，导致分表插件处理参数的逻辑过于复杂。
-
mybatis 拦截器执行顺序
15232868-72c3acc43e6e85b9.png
2.pageHelper和分表插件的先后顺序
2.1 pageHelper插件实现方式是Executor接口，最先执行的接口，若要分表插件在分页插件之前执行也只能使用Executor接口。
2.2 分页插件自动加载代码存在于第三方jar包中，而分表插件为自己实现，逻辑存在于项目源码中，若使用springboot 的自动扫描加载首先加载的是自定义的分表插件，导致分表插件最后执行。
2.3 实现方式
项目中的实现方式为实现ApplicationListener接口监听程序启动事件，再程序启动后加载分表插件，确保分表插件在分页插件后加载。
/**
* mybatis拦截器配置，确保分表拦截器在分页拦截器前执行(分页拦截器不会将任务责任链向后传递)，最后加载分表拦截器
* mybatis拦截器配置的先后顺序类似栈的数据结构，先入后出
*/
@Configuration
@AutoConfigureAfter({PageHelperAutoConfiguration.class})
public class SubTableAutoConfiguration implements ApplicationListener<ContextRefreshedEvent> {
@Resource
private List<SqlSessionFactory> sqlSessionFactoryList;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
//分表插件对象
MybatisSubTable mybatisSubTable = new MybatisSubTable();
//遍历添加拦截器
sqlSessionFactoryList.forEach(e -> e.getConfiguration().addInterceptor(mybatisSubTable));
}
}
3.分表插件实现方式
3.1 实现逻辑
分表插件使用注解的方式实现，扫描分表注解，记录分表的表明和分表的属性
/**
* 启用分表注解，当sql为查询时，若查询多个表单，设置查询参数的分表字段为 英文(,)逗号分隔的字符串
* 如：
* 以工单表为例 当查询t_domain_task_26000422021031816303800000，t_domain_task_23000422016110910302325284两张表时
* 设置domainCode=26000422021031816303800000,23000422016110910302325284
* 注：
* 在查询sql中不能出现 where domainCode=?样式
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SubTableAnnotation {
/**
* 分表的属性,分表策略，以何属性分表
*/
String value();
/**
* 分表的表名,为不包含分表字段属性的原始表名 <br>
* eg:t_domain_task_2019 原生表名为t_domain_task
*/
String baseTableName();
}
3.2 拦截器实现
因要做分表操作，所以需要拦截query 和 update方法
@Intercepts(
{
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
}
)
初始化时记录需要分表操作的表名及属性，拦截到sql后获取表名和参数修改表名，具体实现如下
/**
* 分表查询拦截器 在分页拦截器后面运行 包含crud 不存在分表属性时会抛异常
*/
@Intercepts(
{
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
}
)
@Slf4j
public class MybatisSubTable implements Interceptor {
private Map<String, String> init() {
//获取标记了@SubTableAnnotation的Bean
Map<String, Object> beansWithAnnotation = SpringApplicationContextUtil.getApplicationContext().getBeansWithAnnotation(SubTableAnnotation.class);
Map<String, String> stringStringMap = new HashMap<>();
beansWithAnnotation.forEach((n, v) -> {
//spring管理的bean只能使用AnnotationUtils获取注解
SubTableAnnotation annotation = AnnotationUtils.findAnnotation(v.getClass(), SubTableAnnotation.class);
Assert.notNull(annotation, "@SubTableAnnotation 注解获取异常");
String value = annotation.value();
String tableName = annotation.baseTableName();
stringStringMap.put(tableName, value);
});
return stringStringMap;
}
/**
* 需要分表查询的类
* key 表明
* value 分表标识字段
*/
private Map<String, String> subTable = null;
@Override
public Object intercept(Invocation invocation) throws Throwable {
if (Objects.isNull(subTable)) {
subTable = init();
}
//不存在分表属性 直接返回
if (subTable.isEmpty()) {
return invocation.proceed();
}
//获取参数组PreparedStatement
Object[] args = invocation.getArgs();
MappedStatement mappedStatement = (MappedStatement) args[0];
Object parameter = args[1];
BoundSql boundSql = mappedStatement.getBoundSql(parameter);
String sql = boundSql.getSql().toLowerCase().replaceAll("\\s+", " ").trim();
// 1 获取表名
String tableName = getTableNameBySql(sql);
// sql中不存在表名,不支持分表查询的表,不存在的表
if (tableName == null) {
return invocation.proceed();
}
//分表属性名查询校验,失败时抛出异常
checkKeyFromWhere(tableName, sql);
Object subValueObj = getValue(parameter, tableName);
//分表参数的属性值为空时，放弃处理，直接返回
// 20191025 改为为空时，抛异常
Assert.notNull(subValueObj, "分表参数为空,将会抛出异常 sql:[" + sql + "]");
String[] subValue = subValueObj.toString().split(",");
//参数构建
List<ParameterMapping> newParameterMappings = Arrays.stream(subValue).flatMap(e -> boundSql.getParameterMappings().stream()).collect(Collectors.toList());
//新sql
String newSql = updateSql(sql, subValue, tableName);
//构建新的BoundSql对象
BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), newSql, newParameterMappings, boundSql.getParameterObject());
//创建新的MappedStatement 对象
MappedStatement newMappedStatement = createNewMappedStatement(mappedStatement, newBoundSql);
args[0] = newMappedStatement;
return invocation.proceed();
}
private MappedStatement createNewMappedStatement(MappedStatement mappedStatement, BoundSql newBoundSql) {
MappedStatement.Builder builder = new MappedStatement.Builder(mappedStatement.getConfiguration(), mappedStatement.getId(), parameterObject -> newBoundSql, mappedStatement.getSqlCommandType());
builder.resource(mappedStatement.getResource());
builder.fetchSize(mappedStatement.getFetchSize());
builder.statementType(mappedStatement.getStatementType());
builder.keyGenerator(mappedStatement.getKeyGenerator());
if (mappedStatement.getKeyProperties() != null && mappedStatement.getKeyProperties().length > 0) {
builder.keyProperty(mappedStatement.getKeyProperties()[0]);
}
builder.timeout(mappedStatement.getTimeout());
builder.parameterMap(mappedStatement.getParameterMap());
builder.resultMaps(mappedStatement.getResultMaps());
builder.resultSetType(mappedStatement.getResultSetType());
builder.cache(mappedStatement.getCache());
builder.flushCacheRequired(mappedStatement.isFlushCacheRequired());
builder.useCache(mappedStatement.isUseCache());
return builder.build();
}
/**
* 当类型为Executor时才返回代理,减少不必要的代理
*/
@Override
public Object plugin(Object target) {
if (target instanceof Executor) {
return Plugin.wrap(target, this);
} else {
return target;
}
}
/**
* 构建新的sql
*
* @param sql 源sql
* @param subValue 分表属性值
* @return 新sql
*/
private String updateSql(String sql, String[] subValue, String tableName) {
return Stream.of(subValue).map(value -> {
//不为空时，替换表名
String replaceTableName = tableName + "_" + value;
//加上前后空格，防止短表名和长表名已相同的字符串开始 如 t_domain 和 t_domain_task
return sql.replace(tableName, " " + replaceTableName + " ");
}).collect(Collectors.joining(" union all "));
}
/**
* sql中存在库中表单且sql中使用的表单启用了分表 返回分表名，反之返回null
*/
private String getTableNameBySql(String sql) {
if (sql.contains("last_insert_id()")) {
return null;
}
if (sql.toLowerCase().startsWith("select")
|| sql.toLowerCase().startsWith("update")
|| sql.toLowerCase().startsWith("delete")
|| sql.toLowerCase().startsWith("insert")) {
//修改为使用druid的解析器,提升健壮性
log.trace(sql);
MySqlStatementParser parser = new MySqlStatementParser(sql);
SQLStatement sqlStatement = parser.parseStatement();
MySqlSchemaStatVisitor visitor = new MySqlSchemaStatVisitor();
sqlStatement.accept(visitor);
String tableName = visitor.getTables().keySet().stream().findFirst().orElse(new TableStat.Name(null)).getName();
if (subTable.containsKey(tableName)) {
return tableName;
}
}
return null;
}
/**
* 获取分表属性的值
*
* @param param 参数对象
* @param tableName 表名
*/
private String getValue(Object param, String tableName) {
//dao接口获取的参数对象
//map类型参数 包含多个参数时以map形式传递
if (param instanceof HashMap) {
//真实类型为 MapperMethod的ParamMap get方法获取不存在的key值时会抛异常
HashMap<?, ?> param2 = (HashMap<?, ?>) param;
//多参数，且没有名为 分表字段名 的参数，遍历所有参数获取分表字段
if (!param2.containsKey(subTable.get(tableName))) {
HashMap<?, ?> param1 = (HashMap<?, ?>) param;
for (Object key : param1.keySet()) {
Object value1 = param1.get(key);
//非基本类型及其包装类型或字符串类型时，开始套娃
if (!(ClassUtils.isPrimitiveOrWrapper(value1.getClass()) || value1 instanceof String)) {
return getValue(value1,tableName);
}
}
}else {
Object value = param2.get(subTable.get(tableName));
return value == null ? null : value.toString();
}
//String类型参数， 单参数
} else if (param instanceof String) {
return param.toString();
} else {
//对象参数
try {
Method method = param.getClass().getMethod("get" + subTable.get(tableName).substring(0, 1).toUpperCase() + subTable.get(tableName).substring(1));
Object value = method.invoke(param);
return value == null ? null : value.toString();
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
log.error("获取分表参数失败，请校验参数", e);
return null;
}
}
return null;
}
/**
* 校验sql中是否存在分表参数的查询
*
* @param tableName 表名
* @param sql 查询语句
*/
private void checkKeyFromWhere(String tableName, String sql) {
String subKey = subTable.get(tableName);
String[] split = sql.split(" where");
if (split.length > 1 && split[1].contains(" " + subKey.toLowerCase())) {
log.error("分表处理失败：分表查询时 where 语句参数不能包含分表字段参数 {}【{}】", tableName, subKey);
throw new BusinessException("分表处理失败：分表查询时 where 语句参数不能包含分表字段参数 {}【{}】", tableName, subKey);
}
}
}
``
