在Mybatis分页插件一章我们了解到了Mybatis的插件机制。下面我们继续使用Mybatis的插件机制来实现数据库的简单读写分离与负载均衡。
使用Mybatis插件机制进行读写分离的主要思路是将写SQL路由到主库，将查询SQL路由到从库。
- 首先我们先定义一下数据源：
public class MasterSlaveDataSource extends AbstractDataSource implements InitializingBean {
private static final Logger LOGGER = LoggerFactory.getLogger(MasterSlaveDataSource.class);
private DataSource master;
private List<DataSource> slaves;
private LoadBalanceStrategy loadBalanceStrategy = new RandomLoadBalanceStrategy();
@Override
public Connection getConnection() throws SQLException {
if (ReadWriteManager.getInstance().isReadable()) {
DataSource slave = getSlaveDataSource();
return slave.getConnection();
}
return master.getConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
if (ReadWriteManager.getInstance().isReadable()) {
DataSource slave = getSlaveDataSource();
return slave.getConnection(username, password);
}
return master.getConnection(username, password);
}
private DataSource getSlaveDataSource() { return slaves.get(loadBalanceStrategy.pick(slaves.size()));}
@Override
public void afterPropertiesSet() throws Exception {
if (master == null) {
throw new IllegalStateException("master datasource has not set");
}
if (slaves == null || slaves.isEmpty()) {
throw new IllegalStateException("slave datasource has not set");
}
}
public interface LoadBalanceStrategy { int pick(int count);}
class RandomLoadBalanceStrategy implements LoadBalanceStrategy {
private Random r = new Random();
@Override
public int pick(int count) { return r.nextInt(count); }
}
class RoundRobinLoadBalanceStrategy implements LoadBalanceStrategy {
private AtomicInteger next = new AtomicInteger(0);
@Override
public int pick(int count) {
next.compareAndSet(count, 0);
return next.getAndIncrement() % count;
}
}
public DataSource getMaster() { return master;}
public void setMaster(DataSource master) { this.master = master;}
public List<DataSource> getSlaves() { return slaves;}
public void setSlaves(List<DataSource> slaves) { this.slaves = slaves;}
这是一个主从数据源，根据简单的负载均衡策略从选取适当的数据源。
- 接着我们来看一下ReadWriteManager是什么呢？
先上代码：
public class ReadWriteManager {
private static ThreadLocal<Boolean> READ = new ThreadLocal<>();
private static final ReadWriteManager INSTANCE = new ReadWriteManager();
public static final ReadWriteManager getInstance() { return INSTANCE; }
public void setReadable() { READ.set(true); }
public void clear() { READ.remove(); }
public boolean isReadable() { return READ.get() != null && READ.get().booleanValue(); }
}
代码很少，主要是使用ThreadLocal来保存一个读写的状态，通过这个状态来选择写数据源还是读数据源，这个标志需要在适当的时机进行设置。
- 接着我们就可以定义Mybatis的拦截器了
@Intercepts(
{
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class ReadWriteSplitInterceptor implements Interceptor {
private DataSource dataSource;
@Override
public Object intercept(Invocation invocation) throws Throwable {
ConnectionHolder connectionHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (connectionHolder != null && connectionHolder.getConnection() != null && connectionHolder.isSynchronizedWithTransaction()) {
return invocation.proceed();
}
try {
ReadWriteManager.getInstance().setReadable();
return invocation.proceed();
} finally {
ReadWriteManager.getInstance().clear();
}
}
@Override
public Object plugin(Object target) {
if (target instanceof Executor) {
return Plugin.wrap(target, this);
}
return target;
}
@Override
public void setProperties(Properties properties) {}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
1. 首先通过Intercepts注解在`ReadWriteSplitInterceptor`定义要被拦截的对象和方法；
2. 接着定义一个数据源实例变量；
3. 通过这个实例变量获取当前事务，若连接事务之中，则不处理（这时选择写数据源），否则将`ReadWriteManager`标记为读状态，好选择读数据源。
- 代码已经写完了，我们该如何使用呢？
- 首先在Spring的配置文件中配置主从数据源，一个用于写、一个用于读（读数据源可以配置多个），如下：
<bean id="masterDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value=""/>
</bean>
<bean id="slaveDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test1"/>
<property name="username" value="root"/>
<property name="password" value=""/>
</bean>
<bean id="masterSlaveDataSource" class="mybatis.ds.MasterSlaveDataSource">
<property name="master" ref="masterDataSource" />
<property name="slaves">
<list>
<ref bean="slaveDataSource" />
</list>
</property>
</bean>
- 配置事务管理器时将数据源设置成主从数据源，如下：
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="masterSlaveDataSource" />
</bean>
- 接着在配置
SqlSessionFactoryBean时配置一下Mybatis的插件，如下：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="masterSlaveDataSource"/>
<property name="plugins">
<array>
<bean class="mybatis.interceptor.ReadWriteSplitInterceptor">
<property name="dataSource" ref="masterSlaveDataSource" />
</bean>
</array>
</property>
</bean>
- 总结：通过前面简单的介绍，我们基本上实现了对数据源的读写分离，这种方案在使用上还有一些限制（必须配合Spring事务一起使用和不加事务的场景），在做一些后台管理系统时我们不妨使用一下。
