Spring 整合MySql实现无侵入式的读写分离

一、背景描述

项目发展到一定的阶段，数据库可能成为访问性能的一个瓶颈，并且我们发现数据库的读写基本上符合2-8定律，因此有必要对数据库进行主从备份和读写分离，通过扩展读数据库的数目来横线的分散读数取数据的访问压力。

在之前的文章中有介绍过Mysql层面的主从复制的原理以及环境的搭建，这里不再赘述，直接介绍如何对一个原来只有一个读写库的项目进行改造，使其读写分离。

为了最小化项目的改造成本，我们自然希望对于原有的项目的代码改造量最小，因此我们考虑通过在dao层对Mybatis的Executor执行语句进行拦截：如果是事务性的操作或者INSERT、UPDATE、DELETE等操作，则使用主库（写库）；如果是SELECT查询语句，则使用从库（读库）。

代码实现

在dao package下新增一个split的子package，在该package下依次编写如下的三个类：

2.1 代码编写

2.1.1 编写DynamicDatasource

该类继承自AbstractRoutingDataSource，通过复写determineCurrentLookupKey()方法决定使用主库还是从库。

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceHolder.getDbType();
    }
}

2.1.2 编写DynamicDataSourceHolder

该类使用一个ThreadLocal的变量用于保存实现线程安全的主从库信息的存取。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DynamicDataSourceHolder {

    private static Logger logger = LoggerFactory.getLogger(DynamicDataSourceHolder.class);

    public static final String DB_MASTER = "master";

    public static final String DB_SLAVE = "slave";

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

    /**
     * 获取线程的dbType
     *
     * @return
     */
    public static String getDbType() {
        String db = contextHolder.get();
        if (db == null) {
            db = DB_MASTER;
        }
        return db;
    }

    /**
     * 设置线程的dbType
     *
     * @param str
     */
    public static void setDbType(String str) {
        logger.debug("所使用的数据源为：" + str);
        contextHolder.set(str);
    }

    /**
     * 清理连接类型
     */
    public static void clearDbType() {
        contextHolder.remove();
    }

}

2.1.3 编写DynamicDatasourceInterceptor

自定义的数据源拦截器DynamicDatasourceInterceptor ，继承自Mybatis的Interceptor拦截器，用于在Exectutor执行时对实际执行语句进行拦截，确定使用主库还是从库，并且将信息保存到线程安全的DynamicDataSourceHolder中，后面在具体确定使用哪个数据源时，会到DynamicDataSourceHolder中进行查询。

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.keygen.SelectKeyGenerator;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.plugin.*;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import javax.swing.tree.RowMapper;
import java.util.Locale;
import java.util.Properties;

/**
 * Mybatis级别的拦截器
 * <p>
 * 该拦截器会去拦截传递进来的SQL信息：
 * - 如果是INSERT、UPDATE则采用写数据源（Master）
 * - 如果是SELECT则采用读数据源(Slave)
 */
@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class DynamicDatasourceInterceptor implements Interceptor {

    private static Logger logger = LoggerFactory.getLogger(DynamicDatasourceInterceptor.class);

    private static final String REGEX = ".*insert\\u0020.*|.*delete\\u0020.*|.*update\\u0020.*";

    /**
     * SQL语句拦截
     *
     * @param invocation
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        String lookupKey = DynamicDataSourceHolder.DB_MASTER;
        Object[] objects = invocation.getArgs();
        MappedStatement ms = (MappedStatement) objects[0];
        // 是否启用事务支持，检测@Transactional注解是否启用，启用这里就为true,否则为false
        boolean synchronizationActive = TransactionSynchronizationManager.isActualTransactionActive();
        if (synchronizationActive != true) {
            //读方法
            if (ms.getSqlCommandType().equals(SqlCommandType.SELECT)) {
                // selectKey为自增id查询主键（SELECT_LAST_INSERT_ID()）方法则使用主库
                if (ms.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)) {
                    lookupKey = DynamicDataSourceHolder.DB_MASTER;
                } else {
                    BoundSql boundSql = ms.getSqlSource().getBoundSql(objects[1]);
                    String sql = boundSql.getSql().toLowerCase(Locale.CHINA).replaceAll("[\\t\\n\\r]", " ");
                    if (sql.matches(REGEX)) {
                        lookupKey = DynamicDataSourceHolder.DB_MASTER;
                    } else {
                        lookupKey = DynamicDataSourceHolder.DB_SLAVE;
                    }
                }
            }
        } else {
            lookupKey = DynamicDataSourceHolder.DB_MASTER;
        }
        logger.debug("设置方法[{}] use [{}] Strategy, SqlCommandType [{}]..", ms.getId(), lookupKey, ms.getSqlCommandType().name());
        DynamicDataSourceHolder.setDbType(lookupKey);
        return invocation.proceed();
    }

    /**
     * 决定返回本体还是编织好的代理类,
     * 代理类会去调用intercept方法决定是使用主库还是从库
     *
     * @param target
     * @return
     */
    @Override
    public Object plugin(Object target) {
        if (target instanceof Executor) {//Executor是用来支持一系列增删改查操作的，因此需要对该对象进行拦截，其他的放过
            return Plugin.wrap(target, this);
        } else {//返回本体，不做拦截
            return target;
        }
    }

    /**
     * 做一些相关的参数设置，不是关键
     *
     * @param properties
     */
    @Override
    public void setProperties(Properties properties) {

    }
}

2.2 配置变更

原来只有一个数据库部署在192.168.91.134这台机器上，后面为它在192.168.91.137上配置了一个从库，访问的端口、账号、密码都一样。

2.2.1 修改数据库配置参数

原始的jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.91.134:3306/o2o?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=123

修改后的jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.master.url=jdbc:mysql://192.168.91.134:3306/o2o?useUnicode=true&characterEncoding=utf8
jdbc.master.username=root
jdbc.master.password=123

jdbc.slave.url=jdbc:mysql://192.168.91.137:3306/o2o?useUnicode=true&characterEncoding=utf8
jdbc.slave.username=root
jdbc.slave.password=123

2.2.3 修改数据源配置

原始的Spring-dao.xml中关于dataSource的配置：

<!--数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--配置连接池属性-->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!--c3p0连接池私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>

        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间设置-->
        <property name="checkoutTimeout" value="10000"/>
        <!--当获取连接失败时重试的次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

修改后的Spring-dao.xml中关于dataSource的配置：

<!--数据库连接池-->
    <bean id="abstractDatasource" abstract="true" class="com.mchange.v2.c3p0.ComboPooledDataSource"
          destroy-method="close">
        <!--c3p0连接池私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>

        <!--关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间设置-->
        <property name="checkoutTimeout" value="10000"/>
        <!--当获取连接失败时重试的次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!--配置主库连接池属性-->
    <bean id="master" parent="abstractDatasource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.master.url}"/>
        <property name="user" value="${jdbc.master.username}"/>
        <property name="password" value="${jdbc.master.password}"/>
    </bean>

    <!--配置从库连接池属性-->
    <bean id="slave" parent="abstractDatasource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.slave.url}"/>
        <property name="user" value="${jdbc.slave.username}"/>
        <property name="password" value="${jdbc.slave.password}"/>
    </bean>

    <!--
        配置动态数据源：
        这儿的targetDatasources就是路由数据源所对应的名称。
    -->
    <bean id="dynamicDatasource" class="com.netease.o2o.dao.split.DynamicDataSource">
        <property name="targetDataSources">
            <map>
                <entry value-ref="master" key="master"></entry>
                <entry value-ref="slave" key="slave"></entry>
            </map>
        </property>
    </bean>

    <!--延迟懒加载机制：是在mybatis生成sql语句时才去执行-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">
        <property name="targetDataSource">
            <ref bean="dynamicDatasource"/>
        </property>
    </bean>

三、测试

3.1 测试查询

 2018-12-17 16:14:04.859 [main] DEBUG c.n.o2o.dao.split.DynamicDatasourceInterceptor - 设置方法[com.netease.o2o.dao.AreaDao.findAll] use [master] Strategy, SqlCommandType [SELECT]..
2018-12-17 16:14:04.863 [main] DEBUG com.netease.o2o.dao.split.DynamicDataSourceHolder - 所使用的数据源为：slave
2018-12-17 16:14:04.871 [main] DEBUG com.netease.o2o.dao.AreaDao.findAll - ==>  Preparing: SELECT area_id,area_name,priority,create_time,last_edit_time FROM tb_area ORDER BY priority DESC
2018-12-17 16:14:04.894 [main] DEBUG com.netease.o2o.dao.AreaDao.findAll - ==> Parameters:
 2018-12-17 16:14:04.909 [main] DEBUG com.netease.o2o.dao.AreaDao.findAll - <==      Total: 2

3.2 测试插入

2018-12-17 16:13:09.348 [main] DEBUG c.n.o2o.dao.split.DynamicDatasourceInterceptor - 设置方法[com.netease.o2o.dao.ShopDao.insertShop] use [master] Strategy, SqlCommandType [INSERT]..
2018-12-17 16:13:09.351 [main] DEBUG com.netease.o2o.dao.split.DynamicDataSourceHolder - 所使用的数据源为：master
2018-12-17 16:13:09.357 [main] DEBUG com.netease.o2o.dao.ShopDao.insertShop - ==>  Preparing: INSERT INTO tb_shop (owner_id,area_id,shop_category_id,shop_name,shop_description,shop_address,phone,shop_image, priority,create_time,last_edit_time,enable_status,advice) VALUES (?,?,?,?,? ,?,?,?,?,?,?,?,?)
2018-12-17 16:13:09.387 [main] DEBUG com.netease.o2o.dao.ShopDao.insertShop - ==> Parameters: 1(Long), 1(Integer), 1(Long), test(String), test(String), test(String), test(String), (String), 1(Integer), 2018-12-17 16:13:09.336(Timestamp), 2018-12-17 16:13:09.336(Timestamp), 1(Integer), 审核中(String)
2018-12-17 16:13:09.388 [main] DEBUG com.netease.o2o.dao.ShopDao.insertShop - <==    Updates: 1
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 关于Mongodb的全面总结
    关于Mongodb的全面总结 MongoDB的内部构造《MongoDB The Definitive Guide》...
    中v中阅读 32,032评论 2赞 89
  • 致喜欢与爱——观电影《王尔德的情人》
    电影《后会无期》中有一句台词“喜欢就会放肆，但爱就是克制。” 在我浅略地观览了一回王尔德的一生中似乎得到了共鸣。 ...
    方目阅读 6,848评论 1赞 3
  • 逐光者
    雨水切断光的视线 站在黑暗边缘 厚厚壁垒 脚下粘稠 有光在褶皱 僵化的脊椎 粘连的眼皮 也许太多的夜晚 没有光洗礼...
    达悟希阅读 425评论 0赞 6