前言:
关于spring+mybatis的多源数据库配置, 其实是个老生常谈的事情. 网上的方案出奇的一致, 都是借助AbstractRoutingDataSource进行动态数据源的切换.
这边再无耻地做一回大自然的搬运工, 除了做下笔记, 更多的希望是作为一个切入点, 能探寻下mybatis实现分库分表的解决方案.
基本原理:
关于mybatis的配置, 基本遵循如下的概念流:
DB(数据库对接信息)->数据源(数据库连接池配置)->session工厂(连接管理与数据访问映射关联)->DAO(业务访问封装).
对于定义的sqlmapper接口类, mybatis会为这些类动态生成一个代理类, 隐藏了连接管理(获取/释放), 参数设置/SQL执行/结果集映射等细节, 大大简化了开发工作.
而连接管理涉及到具体的DataSource类实现机制, 在具体执行sql前, 其DB源的选定还有操作空间. 这也为DB路由(切换)提供了口子, 而AbstractRoutingDataSource的引入, 一定程度上为DB*切换提供了便利.
配置工作:
先编写jdbc.properties的内容:
# db1的配置
db1.jdbc.url=jdbc:mysql://127.0.0.1:3306/db_account_1?useUnicode=true&characterEncoding=utf-8
db1.jdbc.username=rd
db1.jdbc.password=rd
db1.jdbc.driver=com.mysql.jdbc.Driver # db2的配置
db2.jdbc.url=jdbc:mysql://127.0.0.1:3306/db_account_2?useUnicode=true&characterEncoding=utf-8
db2.jdbc.username=rd
db2.jdbc.password=rd
db2.jdbc.driver=com.mysql.jdbc.Driver
编辑mybatis-config.xml(对mybatis做一些基础通用配置)的内容:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 配置mybatis的缓存，延迟加载等等一系列属性 -->
<settings>
<!-- 全局映射器启用缓存 -->
<setting name="cacheEnabled" value="true" />
<!-- 查询时，关闭关联对象即时加载以提高性能 -->
<setting name="lazyLoadingEnabled" value="true" />
<!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指定)，不会加载关联表的所有字段，以提高性能 -->
<setting name="aggressiveLazyLoading" value="false" />
<!-- 允许插入 NULL -->
<setting name="jdbcTypeForNull" value="NULL" />
</settings>
</configuration>
编辑application-context.xml的配置:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <aop:aspectj-autoproxy proxy-target-class="true"/> <context:component-scan base-package="com.springapp.mvc"/>
<context:annotation-config /> <!-- 加载jdbc.properties配置文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:conf/jdbc.properties</value>
</list>
</property>
<property name="fileEncoding" value="UTF-8"/>
<property name="ignoreUnresolvablePlaceholders" value="true"/>
</bean> <!-- 配置数据源1 -->
<bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="${db1.jdbc.url}"/>
<property name="username" value="${db1.jdbc.username}"/>
<property name="password" value="${db1.jdbc.password}"/>
<property name="driverClassName" value="${db1.jdbc.driver}" />
</bean> <!-- 配置数据源2 -->
<bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="${db2.jdbc.url}"/>
<property name="username" value="${db2.jdbc.username}"/>
<property name="password" value="${db2.jdbc.password}"/>
<property name="driverClassName" value="${db2.jdbc.driver}" />
</bean> <!-- 配置动态数据源 -->
<bean id="dynamicDatasource" class="com.springapp.mvc.datasource.DynamicDataSource">
<property name="targetDataSources">
<map>
<entry key="db1" value-ref="dataSource1"/>
<entry key="db2" value-ref="dataSource2"/>
</map>
</property>
<property name="defaultTargetDataSource" ref="dataSource1"/>
</bean> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dynamicDatasource"/>
<property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
<property name="mapperLocations">
<list></list>
</property>
</bean> <!--mybatis的配置-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.springapp.mvc.dal"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean> </beans>
注: 这里面涉及一些类, 会在下文中定义.
依赖引入:
这边使用了alibaba开源的druid作为数据库连接池.
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency> <dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency> <dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.6</version>
</dependency> <dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.2</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.1.1.RELEASE</version>
</dependency>
基础代码编写:
主要是db路由的datasource实现类, 以及辅助的注解工具类.
定义db来源的枚举类:
@Getter
@AllArgsConstructor
public enum DataSourceKey { DB1("db1"),
DB2("db2"); private String dbKey; }
定义标示当前激活db的工具类:
public class DatasourceContextHolder {
private static final ThreadLocal<String> contextHolder
= new ThreadLocal<String>();
// 设置数据源
public static void setDataSourceType(DataSourceKey dbKey) {
contextHolder.set(dbKey.getDbKey());
}
// 获取当前的数据源
public static String getDataSourceType() {
return contextHolder.get();
}
// 清空数据源
public static void clearDataSourceType() {
contextHolder.remove();
}
}
注: 利用了ThreadLocal来保存当前选择的db源
定义AbstractRoutingDataSource的实现类:
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return DatasourceContextHolder.getDataSourceType();
}
}
注: 只要重载determineCurrentLookupKey()函数即可.
定义注解:
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceSelector {
DataSourceKey dataSource() default DataSourceKey.DB1;
}
定义切面类:
@Aspect
@Component
@Order(1)
public class DataSourceSelectorAdvice { // 定义切点, 用于db源切换
@Pointcut("@annotation(com.springapp.mvc.datasource.DataSourceSelector)")
public void selectorDB() {
} @Around("selectorDB() && @annotation(dataSourceSelector)")
public Object aroundSelectDB(ProceedingJoinPoint pjp, DataSourceSelector dataSourceSelector) throws Throwable {
// 设置具体的数据源
DatasourceContextHolder.setDataSourceType(dataSourceSelector.dataSource());
try {
// 执行拦截的方法本体
return pjp.proceed();
} finally {
// 清空设置的数据源
DatasourceContextHolder.clearDataSourceType();
}
} }
这些代码构成了动态切换db源的主干框架.
业务代码编写:
编写DO类:
@Getter
@Setter
@ToString
public class AccountDO { private String username; private String password; }
编写sqlmapper接口类:
@Repository
public interface AccountMapper { @Select("SELECT username, password FROM tb_account WHERE user_id = #{user_id}")
@Results({
@Result(property = "userId", column = "user_id", jdbcType = JdbcType.VARCHAR),
@Result(property = "username", column = "username", jdbcType = JdbcType.VARCHAR),
@Result(property = "password", column = "password", jdbcType = JdbcType.VARCHAR),
})
AccountDO queryByUserId(@Param("user_id") String userId); }
编写service类:
@Service
public class AccountService { @Resource
private AccountMapper accountMapper; // *) 从db1获取数据
@DataSourceSelector(dataSource = DataSourceKey.DB1)
public AccountDO queryByUserId1(String userId) {
return accountMapper.queryByUserId(userId);
} // *) 从db2获取数据
@DataSourceSelector(dataSource = DataSourceKey.DB2)
public AccountDO queryByUserId2(String userId) {
return accountMapper.queryByUserId(userId);
} }
Aspectj对接口(interface)无效, 对具体的实体类才其作用, 因为sqlmapper接口类会被mybatis生成一个动态类, 因此需要加切面(db切换), 需要在service层去实现.
验证数据准备:
本地创建了两个db, 都创建相同的表tb_account.
CREATE TABLE `tb_account` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` varchar(32) NOT NULL,
`username` varchar(32) DEFAULT NULL,
`password` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`), UNIQUE KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
db1的tb_account有账号数据(1001, lilei).
db2的tb_account有账号数据(2001, hanmeimei).
测试:
编写单测:
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:application-context.xml"})
public class AccountServiceTest { @Resource
private AccountService accountService; @Test
public void queryByUserId1() {
// 用户id:1001, 落在db1中, 不在db2
String userId = "1001"; AccountDO accountDO1 = accountService.queryByUserId1(userId);
Assert.assertNotNull(accountDO1); // 存在断言 AccountDO accountDO2 = accountService.queryByUserId2(userId);
Assert.assertNull(accountDO2); // 不存在断言
} @Test
public void queryByUserId2() {
// 用户id:2001, 不在db1中, 在db2中
String userId = "2001"; AccountDO accountDO1 = accountService.queryByUserId1(userId);
Assert.assertNull(accountDO1); // 不存在断言 AccountDO accountDO2 = accountService.queryByUserId2(userId);
Assert.assertNotNull(accountDO2); // 存在断言
} }
运行的结果符合预期.
后记:
对于微服务的盛行, 其实多源的数据源(基于业务划分)基本就不存在, 如果存在, 要么业务刚发展起来, 要么就是公司的基础设施太薄弱了^_^. 网上也看到有人用来主从(master/slave)的配置, 其实对于有一定规模的公司而言, mysql的主从分离都由类db proxy的中间件服务承包了.
那他的意义究竟在哪呢? 其实我感觉还是给mysql的分库分表, 提供了一种可行的思路.