java自定义注解、mybatis 插件 实现数据库 分库分表

一、自定义注解实现分库

为什么会有数据库切库一说

首先，许多项目都有主库与从库，有的主库后面甚至会有很多个从库，主从库之间的通常同步也很快，这为数据库切库提供了一个基础，因为可以去不同的数据库查询，得到相同的结果（如果不同的数据库是完全不同的，这个不在我们这篇文章讨论的范围之内，那个属于让项目支持多个数据源）

其次，随着项目越来越大、操作的用户越来越多，对数据库的请求操作越来越多，很容易想到的是将读写请求分开，将写请求交给主库处理，读请求直接从某个从库读取。这样可以极大的减少大量对主库的请求，提升主库的性能。

接下来具体说一下如何通过自定义注解完成切库（代码使用springboot实现）：

第一步、定义我们自己的切库注解类

自定义注解有几点需要注意：

1）@Target 是作用的目标，接口、方法、类、字段、包等等，具体看：ElementType

2）@Retention 是注解存在的范围，RUNTIME代表的是注解会在class字节码文件中存在，在运行时可以通过反射获取到，具体看：RetentionPolicy

3）允许的变量，通常都要给定默认值，比如我们使用一个service时，可以@Service，也可以@Service("xxxx")

[code]@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.METHOD
})
public @interface RoutingDataSource {

String value() default DataSources.MASTER_DB;
}

第二步、定义需要使用的数据库及配置

1、数据库配置：application.properties，这里要注意不同db的前缀区别

[code]## datasource master #
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/master?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=466420182

## datasource slave #
spring.datasourceslave.type=com.alibaba.druid.pool.DruidDataSource
spring.datasourceslave.driver-class-name=com.mysql.jdbc.Driver
spring.datasourceslave.url=jdbc:mysql://localhost:3306/slave?characterEncoding=UTF-8
spring.datasourceslave.username=root
spring.datasourceslave.password=466420182

2、定义支持的数据源id：

[code]public interface DataSources {

String MASTER_DB = "masterDB";

String SLAVE_DB = "slaveDB";
}

3、定义数据库实体类并配置为多数据源的形式

这里不要忽略了通过 MapperScan 指定需要扫描的mybatis的接口类

[code]@Configuration
public class DatasourceConfig {
//destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用.
@Bean(destroyMethod =  "close", name = DataSources.MASTER_DB)
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}

@Bean(destroyMethod =  "close", name = DataSources.SLAVE_DB)
@ConfigurationProperties(prefix = "spring.datasourceslave")
public DataSource dataSourceSlave() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}
}

4、配置成动态数据源：

[code]@Configuration
public class MybatisConfig {

@Autowired
@Qualifier(Datasources.MASTER_DB)
private DataSource masterDB;

@Autowired
@Qualifier(DataSources.SLAVE_DB)
private DataSource slaveDB;

/**
* 动态数据源
*/
@Bean(name = "dynamicDataSource")
public DataSource dynamicDataSource() {
DynamicDataSource dynamicDataSource = new DynamicDataSource();
// 默认数据源
dynamicDataSource.setDefaultTargetDataSource(masterDB);

// 配置多数据源
Map<Object, Object> dsMap = Maps.newHashMap();
dsMap.put(DataSources.MASTER_DB, masterDB);
dsMap.put(DataSources.SLAVE_DB, slaveDB);
dynamicDataSource.setTargetDataSources(dsMap);

return dynamicDataSource;
}

@Bean
@ConfigurationProperties(prefix = "mybatis")
public SqlSessionFactoryBean sqlSessionFactoryBean() {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
// 配置数据源，此处配置为关键配置，如果没有将 dynamicDataSource 作为数据源则不能实现切换
sqlSessionFactoryBean.setDataSource(dynamicDataSource());
return sqlSessionFactoryBean;
}
}

第三步、使用ThreadLocal安全的管理当前进程使用的数据源连接

[code]@Slf4j
public class DataSourceContextHolder {

/**
* 默认数据源
*/
public static final String DEFAULT_DATASOURCE = DataSources.MASTER_DB;

private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

// 设置数据源名
public static void setDB(String dbType) {
log.debug("切换到{}数据源", dbType);
contextHolder.set(dbType);
}

// 获取数据源名
public static String getDB() {
return (contextHolder.get());
}

// 清除数据源名
public static void clearDB() {
contextHolder.remove();
}
}

第四步、通过编写切面，对所有我们自定义切库注解的方法进行拦截，动态的选择数据源

这里是为下一步提供铺垫，动态调整DataSourceContextHolder里存储的值，使用threadLocal来管理是为了避免多线程之间互相影响。

自定义注解，核心的处理就是写处理这个注解的逻辑，然后通过指定的拦截方案根据当前的数据做一些动态的处理。比如Spring提供的@Controller、@Service等注解，都是需要我们在配置文件里配置好需要扫描的路径，然后项目启动时，spring根据配置去指定路径读取这些配置，然后这些类才可以被spring进行管理。

这里不要忽略了默认数据源要选择主库，如果切库出现什么问题，比如配置错误等，可以保证访问主库来得到正确的结果；另外，请求完了不要忘记调用提供的clearDB的操作，防止threadLocal误用带来的内存泄露。

[code]@Aspect
@Component
@Slf4j
public class DynamicDataSourceAspect {

@Before("@annotation(RoutingDataSource)")
//注意：这个参数里面要写RoutingDataSource和注解里面名称保持一致，不然会报错
public void beforeSwitchDS(JoinPoint point,RoutingDataSource RoutingDataSource){

//获得当前访问的class
Class<?> className = point.getTarget().getClass();

//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
String dataSource = DataSourceContextHolder.DEFAULT_DATASOURCE;
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);

// 判断是否存在@DS注解
if (method.isAnnotationPresent(RoutingDataSource.class)) {
RoutingDataSource annotation = method.getAnnotation(RoutingDataSource.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
log.error("routing datasource exception, " + methodName, e);
}
// 切换数据源
DataSourceContextHolder.setDB(dataSource);
}

@After("@annotation(RoutingDataSource)")
public void afterSwitchDS(JoinPoint point,RoutingDataSource RoutingDataSource){
DataSourceContextHolder.clearDB();
}
}

第五步、动态的取出我们在切面里设置的数据源的字符串即可

这里需要把原理介绍一下，在连接数据库时其实是先选择一个配置好的spring管理的datasource的id，就是我们之前在 DatasourceConfig 类里定义的Datasource实体类的id：masterDB 和 slaveDB。然后根据id去spring的上下文选择配置，进行数据库连接。有兴趣的可以看一下源码。

[code]@Slf4j
public class DynamicDataSource extends AbstractRoutingDataSource {

@Override
protected Object determineCurrentLookupKey() {
log.debug("数据源为{}", DataSourceContextHolder.getDB());
return DataSourceContextHolder.getDB();
}
}

第六步、取消自动配置数据源，使用我们这里定义的数据源配置

在SpringBoot启动类上通常直接使用@SpringBootApplication就可以了，这里需要调整为：

[code]@SpringBootApplication(exclude = {
DataSourceAutoConfiguration.class
})

使用

如何使用呢，我们简单演示一下：

[code]@Service
public class DataSourceRoutingService {

@Resource
private SysUserMapper sysUserMapper;

@RoutingDataSource(DataSources.MASTER_DB) // 这个注解这时是可以省略，因为默认就是访问主库
public SysUser test1(int id) {
return sysUserMapper.selectByPrimaryKey(id);
}

@RoutingDataSource(DataSources.SLAVE_DB)
public SysUser test2(int id) {
return sysUserMapper.selectByPrimaryKey(id);
}
}

如此，数据库切库就OK了。如果你的系统已经有主库、从库之分了，那么赶紧在你的系统里利用起来吧。

扩展

这里呢，还可以支持多个扩展。比如现在一个主库后面有多个从库，在切面拿到需要切换从库时，还可以选择随机选择一个，或者根据类名、方法名或业务配置等选择某一个从库，这样不但可以分担每个从库的压力，也可以有针对性的让指定的读请求打到指定的从库上。如果有多个主库，也可以有更多的选择~

二、多个数据源的轻松支持

前面文章里介绍了 自定义注解完成数据库切库 ，今天接着这个高并发的话题，继续说一下项目里多个数据源的支持。

如何理解支持多个数据源呢？简单的说，就是一个项目里，同时可以访问多个不同的数据库。

实现的原理先交待一下：单个数据源在配置时会绑定一套mybatis配置，多个数据源时，不同的数据源绑定不同的mybatis配置就可以了，简单的思路就是让不同的数据源扫描不同的包，让不同的包下的mapper对应连接不同的数据源去处理逻辑。

场景假设：项目底层有正常业务库和日志库，希望解决的是将项目中的一些日志单独记录到一个库里，比如用户操作记录、产品更新记录等。

说一下为什么会有这个需求：用户操作记录和产品更新记录可能很多，而实际中使用的又很少，就只是在某些页面单独展示一下操作或更新记录，绝大部分时间都在不停的做着插入操作，这时就可以把这种记录放到业务核心库外面。

自己还遇到一个场景，就是底层产品、订单什么的是存在不同的库里的，但是代码重构还没做到产品相关的一个项目、订单相关的一个项目这一步，这时候也可以考虑在一个项目里同时支持多个数据源，订单相关的类操作订单库，产品相关的类操作产品库，前期做好配置就可以了，尽量别去跨库join表，基本什么都不影响。

不多说了，代码走起来 : （依旧使用springboot进行实现）

第一步、定义多个数据源的mybatis配置

[code]application.properties

mybatis.mapper-locations=mappers/*.xml
mybatisLog.mapper-locations=mappersLog/*.xml

## datasource master #
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test1?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=466420182

## datasource log #
spring.datasourceLog.type=com.alibaba.druid.pool.DruidDataSource
spring.datasourceLog.driver-class-name=com.mysql.jdbc.Driver
spring.datasourceLog.url=jdbc:mysql://localhost:3306/log?characterEncoding=UTF-8
spring.datasourceLog.username=root
spring.datasourceLog.password=466420182

第二步、定义多个数据源

[code]@Configuration
public class DatasourceConfig {

@Bean(destroyMethod =  "close", name = DataSources.MASTER_DB)
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}

@Bean(destroyMethod =  "close", name = DataSources.LOG_DB)
@ConfigurationProperties(prefix = "spring.datasourceLog")
public DataSource dataSourceLog() {
return DataSourceBuilder.create().type(DruidDataSource.class).build();
}
}

第三步、分别配置多个数据源

[code]@Configuration
@MapperScan(basePackages = {"com.mmall.practice.dao"})
public class MybatisConfig {

@Autowired
@Qualifier(DataSources.MASTER_DB)
private DataSource masterDB;

@Bean
@Primary
@ConfigurationProperties(prefix = "mybatis")
public SqlSessionFactoryBean sqlSessionFactoryBean() {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(masterDB);
return sqlSessionFactoryBean;
}
}

[code]@Configuration
@MapperScan(basePackages = {"com.mmall.practice.daoLog"}, sqlSessionFactoryRef = "logSqlSessionFactory")
public class MybatisLogConfig {

@Autowired
@Qualifier("logDB")
private DataSource logDB;

@Bean(name = "logSqlSessionFactory")
@ConfigurationProperties(prefix = "mybatisLog")
public SqlSessionFactoryBean sqlSessionFactoryBean() {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(logDB);
return sqlSessionFactoryBean;
}
}

这里需要注意两个数据源配置的差别，也是支持多数据源的关键

1）Configuration 扫描不同的前缀，取不同包下的sql对应的xml文件

2）SqlSessionFactoryBean 实例化时，默认的额外添加了 @Primary注解

3）MapperScan 扫描的不同的包，如果扫描相同的包也能做，但是还需要做额外的配置，可以自己尝试

4）不同的数据源使用不同的SqlSessionFactoryBean实例

至此，不同包下面的 Mapper.java 文件就可以连接不同的数据源了。这里就不说如何去使用了，和之前正常一样去使用 Mapper.java 就可以了，只是操作的是不同的数据库。

多数据源支持是不是特别简单，赶紧在你的项目里用起来吧~

三 、mybatis 的 分表插件shardbatis 实现 分表

　　Mybatis中实现分表，有个很简单的插件，叫shardbatis，使用maven构建的工程，可以在pom.xml中添加依赖性即可：

[code]<!-- 分库分表插件 -->
<dependency>
<groupId>org.shardbatis</groupId>
<artifactId>shardbatis</artifactId>
<version>2.0.0B</version>
</dependency>
<!-- sql解析插件 -->
<dependency>
<groupId>net.sf.jsqlparser</groupId>
<artifactId>jsqlparser</artifactId>
<version>0.8.0</version>
</dependency>

　使用方式：shardbatis-2.0.0B.jar中有一个ShardStrategy接口，源码如下：

[code]public abstract interface ShardStrategy
{
public abstract String getTargetTableName(String paramString1, Object paramObject, String paramString2);
}

　　用户可以自定义实现该接口的getTargetTableName方法，例如按年月分表实现：

[code]/**
* 分表策略，自动按当前年月分表
* @author yehx
*
*/
public class ShardStrategyByYearMonthImpl implements ShardStrategy {

private static Log log = LogFactory.getLog(ShardStrategyByYearMonthImpl.class);

private static SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");
/**
* 得到实际表名
* @param baseTableName 逻辑表名,一般是没有前缀或者是后缀的表名
* @param params        mybatis执行某个statement时使用的参数
* @param mapperId      mybatis配置的statement id
* @return
*/

public String getTargetTableName(String baseTableName,Object params, String mapperId) {
return baseTableName +"_" + sdf.format(new Date());
}
}

　　按年月分表的实现写好了之后，那这时候就需要配置，哪个mapperId需要按照该策略进行操作，即需要配置shard_config.xml：

[code]<shardingConfig>
<!-- ignoreList可选配置 ignoreList配置的mapperId会被分表参加忽略解析,不会对sql进行修改，value可配置多个 -->
<ignoreList>
<value></value>
</ignoreList>
<!-- parseList可选配置 如果配置了parseList,只有在parseList范围内并且不再ignoreList内的sql才会被解析和修改，value可配置多个 -->
<parseList>
<value>com.**.mapper.UserMapper.addUser</value>
</parseList>
<!-- 配置分表策略 -->
<strategy tableName="demo_user"
strategyClass="com.**.splittable.ShardStrategyByDayImpl" />
</shardingConfig>

　　那么，如何加载该文件呢，很简单，只需要在mybatis-config.xml文件中增加插件配置即可，配置如下：

[code]<configuration>
<!-- 插件配置 -->
<plugins>
<!-- 分表插件配置 -->
<plugin interceptor="com.google.code.shardbatis.plugin.ShardPlugin">
<property name="shardingConfig" value="shard_config.xml"/>
</plugin>
</plugins>
</configuration>

　　而mybatis-config.xml文件是在哪加载的呢？是在配置sqlSessionFactory的地方指定的，如用spring的话，则在spring-mybatis.xml中配置：

[code]<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- mybatis-config配置文件 -->
<property name="configLocation" value="classpath:mybatis-config.xml" />
<!-- 自动扫描mapping.xml文件 -->
<property name="mapperLocations" value="classpath:mapper/*.xml"></property>
</bean>

好了，配置ok，接下来就可以完美地实现分表的需求了！！！

 

阅读更多