mysql水平分表 mybatis_玩转SpringBoot之整合Mybatis拦截器对数据库水平分表

利用Mybatis拦截器对数据库水平分表

需求描述

当数据量比较多时，放在一个表中的时候会影响查询效率；或者数据的时效性只是当月有效的时候；这时我们就会涉及到数据库的分表操作了。当然，你也可以使用比较完善的第三方组件：sharding-jdbc来实现；但是你使用后会发现，貌似对oracle的兼容性不是很好。所以最后我还是决定使用Mybatis拦截器对数据库进行水平分表。

为什么要选用Mybatis拦截器

拦截器：我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。

Mybatis拦截器：就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。

MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。对于拦截器Mybatis为我们提供了一个Interceptor接口，通过实现该接口就可以定义我们自己的拦截器。

MyBatis默认调用四种类型的方法：

1.Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)

2.ParameterHandler (getParameterObject, setParameters)

3.ResultSetHandler (handleResultSets, handleOutputParameters)

4.StatementHandler (prepare, parameterize, batch, update, query)

以上4个都是Configuration的方法，这些方法在MyBatis的一个操作(新增，删除，修改，查询)中都会被执行到，执行的先后顺序是Executor，ParameterHandler，ResultSetHandler，StatementHandler。

开始构建项目

0、导入依赖包

org.springframework.boot

spring-boot-starter

2.0.4.RELEASE

org.springframework.boot

spring-boot-starter-web

org.springframework.boot

spring-boot-starter-logging

org.springframework.boot

spring-boot-starter-log4j2

com.oracle

ojdbc6

11.2.0.3

com.alibaba

druid-spring-boot-starter

1.1.10

org.mybatis.spring.boot

mybatis-spring-boot-starter

1.3.2

org.projectlombok

lombok

org.codehaus.plexus

plexus-classworlds

2.5.1

org.mybatis.generator

mybatis-generator-core

1.3.2

jar

1、自定义分表规则和分表策略拦截注解类

package com.java.mmzsit.framework.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 分表规则

* @author mmzsit

*

*/

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE})

public @interface TableSplitRule {

public String tableName();

//暂时只支持单参数

public String paramName();

public String targetName();

}

package com.java.mmzsit.framework.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 分表策略拦截

* @author tianwei

*

*/

@Retention(RetentionPolicy.RUNTIME)

@Target({ElementType.TYPE})

public @interface TableSplitTarget {

boolean interFale() default true;

//分表规则

public TableSplitRule[] rules();

}

2、实现策略分表拦截器

package com.java.mmzsit.framework.interceptor;

import com.java.mmzsit.framework.annotation.TableSplitRule;

import com.java.mmzsit.framework.annotation.TableSplitTarget;

import com.java.mmzsit.framework.mybatisStrategy.strategy.Strategy;

import com.java.mmzsit.framework.mybatisStrategy.StrategyManager;

import lombok.extern.slf4j.Slf4j;

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

import org.apache.ibatis.mapping.MappedStatement;

import org.apache.ibatis.plugin.*;

import org.apache.ibatis.reflection.DefaultReflectorFactory;

import org.apache.ibatis.reflection.MetaObject;

import org.apache.ibatis.reflection.SystemMetaObject;

import org.springframework.beans.factory.annotation.Autowired;

import java.lang.reflect.Field;

import java.sql.Connection;

import java.util.Map;

import java.util.Properties;

/**

* @author ：mmzsit

* @description：

* @date ：2019/6/14 10:10

*/

@Slf4j(topic="策略分表拦截器【TableSplitInterceptor】")

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

public class TableSplitInterceptor implements Interceptor {

@Autowired

StrategyManager strategyManager;

@Override

public Object intercept(Invocation invocation) throws Throwable {

log.info("进入mybatisSql拦截器：====================");

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

MetaObject metaStatementHandler =

MetaObject.forObject(statementHandler,SystemMetaObject.DEFAULT_OBJECT_FACTORY, SystemMetaObject.DEFAULT_OBJECT_WRAPPER_FACTORY, new DefaultReflectorFactory());

Object parameterObject = metaStatementHandler.getValue("delegate.boundSql.parameterObject");

doSplitTable(metaStatementHandler,parameterObject);

// 传递给下一个拦截器处理

return invocation.proceed();

}

@Override

public Object plugin(Object arg0) {

//System.err.println(arg0.getClass());

if (arg0 instanceof StatementHandler) {

return Plugin.wrap(arg0, this);

} else {

return arg0;

}

}

@Override

public void setProperties(Properties arg0) {

}

private void doSplitTable(MetaObject metaStatementHandler,Object param) throws ClassNotFoundException{

String originalSql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");

if (originalSql != null && !originalSql.equals("")) {

log.info("分表前的SQL："+originalSql);

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

String id = mappedStatement.getId();

String className = id.substring(0, id.lastIndexOf("."));

Class> classObj = Class.forName(className);

// 根据配置自动生成分表SQL

TableSplitTarget tableSplit = classObj.getAnnotation(TableSplitTarget.class);

if(tableSplit==null||!tableSplit.interFale()) {

return ;

}

TableSplitRule[] rules = tableSplit.rules();

if (rules != null && rules.length>0) {

String convertedSql= null;

// StrategyManager可以使用ContextHelper策略帮助类获取，本次使用注入

for(TableSplitRule rule : rules) {

Strategy strategy = null;

if(rule.targetName()!=null&&!rule.targetName().isEmpty()) {

strategy = strategyManager.getStrategy(rule.targetName());

}

if(!rule.paramName().isEmpty()&&!rule.tableName().isEmpty()) {

String paramValue = getParamValue(param, rule.paramName());

//System.err.println("paramValue:"+paramValue);

//获取 参数

String newTableName = strategy.returnTableName(rule.tableName(), paramValue);

try {

convertedSql = originalSql.replaceAll(rule.tableName(),newTableName );

} catch (Exception e) {

e.printStackTrace();

}

}

}

log.info("新sql是：" + convertedSql);

metaStatementHandler.setValue("delegate.boundSql.sql",convertedSql);

}

}

}

public String getParamValue(Object obj,String paramName) {

if(obj instanceof Map) {

return (String) ((Map) obj).get(paramName);

}

Field[] fields = obj.getClass().getDeclaredFields();

for(Field field : fields) {

field.setAccessible(true);

//System.err.println(field.getName());

if(field.getName().equalsIgnoreCase(paramName)) {

try {

return (String) field.get(obj);

} catch (IllegalArgumentException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

}

}

return null;

}

}

3、编写策略服务接口

package com.java.mmzsit.framework.mybatisStrategy.strategy;

/**

* 分表策略服务接口

* @author mmzsit

*

*/

public interface Strategy {

/**

* 传入表名 和分表参数

* @param tableName

* @param splitParam

* @return

*/

String returnTableName(String tableName,String splitParam);

}

4、实现一个策略服务接口

package com.java.mmzsit.framework.mybatisStrategy.strategy.impl;

import com.java.mmzsit.framework.mybatisStrategy.framework.util.DateUtil;

import com.java.mmzsit.framework.mybatisStrategy.strategy.Strategy;

import java.text.ParseException;

/**

* @author ：mmzsit

* @description：按月分表策略

* @date ：2019/6/13 10:29

*/

public class YYYYMM01Strategy implements Strategy {

@Override

public String returnTableName(String tableName, String param) {

try {

// 结果类似 20190601

return tableName+"_"+ DateUtil.get_MM01Str(param);

} catch (ParseException e) {

e.printStackTrace();

return tableName;

}

}

}

5、编写策略管理类

package com.java.mmzsit.framework.mybatisStrategy;

import com.java.mmzsit.framework.mybatisStrategy.strategy.Strategy;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

/**

* @author ：mmzsit

* @description：

* @date ：2019/6/13 10:28

*/

public class StrategyManager {

public static final String _YYYYMM01 = "YYYYMM01"; //策略名称

public static final String _YYYYMMDD = "YYYYMMDD";

public static final String _YYYYMM = "YYYYMM";

private Map strategies = new ConcurrentHashMap(10);

/**

* 向管理器中添加策略

* @param strategyName

* @param strategy

*/

public void addStrategy(String strategyName,Strategy strategy) {

strategies.put(strategyName, strategy);

}

public Strategy getStrategy(String key){

return strategies.get(key);

}

public Map getStrategies() {

return strategies;

}

public void setStrategies(Map strategies) {

for(Map.Entry entry : strategies.entrySet()){

try {

this.strategies.put(entry.getKey(),(Strategy)Class.forName(entry.getValue()).newInstance());

} catch (Exception e) {

System.out.println("实例化策略出错"+e);

}

}

}

}

6、最后，也是最重要的一点：拦截器已经写好了，但是如何使用呢？

很简单，在你需要进行分表的dao层添加如下注解即可：

@TableSplitTarget(rules={@TableSplitRule(tableName="TESTDATAS",paramName="updatedate",targetName=StrategyManager._YYYYMM01)})

测试

0、建表语句

CREATE TABLE

TESTDATAS_20190701

(

ID NUMBER(4) NOT NULL,

NAME NVARCHAR2(30),

AGE NVARCHAR2(2),

INFORMATION NVARCHAR2(30),

UPDATEDATE NVARCHAR2(14),

PRIMARY KEY (ID)

);

2019-07-12 09:24:45.937 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 进入mybatisSql拦截器：====================

2019-07-12 09:24:45.947 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 分表前的SQL：insert into TESTDATAS (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:45.964 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 新sql是：insert into TESTDATAS_20190501 (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:46.140 INFO 5548 --- [nio-8001-exec-1] 数据插入分表【AddDataImpl】 : 插入数据成功

2019-07-12 09:24:46.141 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 进入mybatisSql拦截器：====================

2019-07-12 09:24:46.149 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 分表前的SQL：insert into TESTDATAS (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:46.150 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 新sql是：insert into TESTDATAS_20190601 (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:46.190 INFO 5548 --- [nio-8001-exec-1] 数据插入分表【AddDataImpl】 : 插入数据成功

2019-07-12 09:24:46.191 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 进入mybatisSql拦截器：====================

2019-07-12 09:24:46.191 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 分表前的SQL：insert into TESTDATAS (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:46.192 INFO 5548 --- [nio-8001-exec-1] 策略分表拦截器【TableSplitInterceptor】 : 新sql是：insert into TESTDATAS_20190701 (ID, NAME, AGE, INFORMATION,

UPDATEDATE)

values (?, ?, ?, ?, ?)

2019-07-12 09:24:46.204 INFO 5548 --- [nio-8001-exec-1] 数据插入分表【AddDataImpl】 : 插入数据成功

4、查看数据库信息

总结

其实这也算是对mybatis底层的一种使用了，因为对其需要执行的mysql语句进行了拦截，然后进行重新拼接后才继续执行操作的。

代码已经提交github：springboot-mybatisInterceptor