SSM框架实现Mysql的读写分离

在上一篇文章中，我们实现了数据库的读写分离，主数据库发生改变，从数据库会跟着发生改变（https://www.jianshu.com/p/73e75c6abd6c）。这样主从数据库就保持一致了。那么在SSM框架中，我们如何实现读写分离呢？以下就为大家带来SSM框架读写分离的相关配置。

1.创建开一个继承AbstractRoutingDataSource抽象类的类

Spring框架中，为我们提供了一个多数据源的抽象类，叫做AbstractRoutingDataSource，其中有个方法如下：

protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        // 该类中的一个方法，用来获取数据源
        Object lookupKey = this.determineCurrentLookupKey();
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }

        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        } else {
            return dataSource;
        }
    }

从上面的这个方法中，我们可以看出这个方法会根据我们传入的lookupKey，从而判断是选择哪个数据源，而lookupKey是由该类的determineCurrentLookupKey()获取，所以，要实现多数据源，我们需要创建一个类，用来继承AbstractRoutingDataSource这个类，同时新建的这个类要重写该抽象类中的determineCurrentLookupKey方法。
在这里，为了保证代码的复用性以及新建的类的简单，我们新建了两个类，DynamicDataSource （继承AbstractRoutingDataSource这个抽象类），DynamicDataSourceHolder用来存放以及获取数据源。

package cn.xdw.o2o.dao.split;

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

public class DynamicDataSource extends AbstractRoutingDataSource {

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

package cn.xdw.o2o.dao.split;

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

public class DynamicDataSourceHolder {

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

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

    public static final String DB_MASTER = "master";

    public static final String DB_SLAVE = "slave";

    /**
     * 获取数据库类型
     * @return
     */
    public static Object getDbType() {
         String db = contextHolder.get();
         if (db == null) {
             return DB_MASTER;
         }
         return db;
    }

    /**
     * 设置连接类型
     * @param target
     */
    public static void setDbType(String target) {
        logger.debug("所使用的数据源为：" + target);
        contextHolder.set(target);
    }

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

}

DynamicDataSourceHolder 中使用了ThreadLocal，这个类是线程安全的，即上述代码中的context对象中保存的参数每个线程相互独立，不会产生影响。

2.创建mybatis拦截器，拦截增删改查操作

创建一个实现Intercepter接口的拦截器，对SQL进行拦截，代码如下：

package cn.xdw.o2o.dao.split;

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 java.util.Locale;
import java.util.Properties;

@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 final Logger logger = LoggerFactory.getLogger(DynamicDataSourceInterceptor.class);

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

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 首先判断是否是事务
        boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive();
        Object[] object = invocation.getArgs();
        MappedStatement ms = (MappedStatement)object[0];
        String lookUpkey = null;
        // 如果没有开启事务
        if (synchronizationActive != true) {
            if (ms.getSqlCommandType().equals(SqlCommandType.SELECT)) {
                // 如果是查询最后一条记录（select_last_record）,还是使用主库
                if (ms.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)) {
                    lookUpkey = DynamicDataSourceHolder.DB_MASTER;
                } else {
                    lookUpkey = DynamicDataSourceHolder.DB_SLAVE;
                }
            } else {
                BoundSql boundSql = ms.getSqlSource().getBoundSql(object[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();
    }

    @Override
    public Object plugin(Object target) {
        // Executor表示增删改查的操作，如果存在增删改查的操作，将其拦截下来
        if (target instanceof Executor) {
            return Plugin.wrap(target, this);
        }
        return target;
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

代码中的plugin方法，主要作用时拦截增删改查的操作，如果不是增删改查操作，返回传入对象，如果是增删改查操作，返回数据库代理对象。代理对象的处理逻辑，就在intercept这个方法中，详细的逻辑在代码中有注释。

3.相关xml文件的配置

第一步，我们要在mybatis的xml文件中将拦截器配置进去

<plugins>
        <plugin interceptor="cn.xdw.o2o.dao.split.DynamicDataSourceInterceptor"></plugin>
</plugins>

第二步： 将主从数据库相关信息，配置到我们的jdbc.properites文件当中

jdbc.driver=com.mysql.jdbc.Driver
jdbc.master.url=jdbc:mysql://localhost:3307/o2o?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false&allowPublicKeyRetrieval=true
jdbc.slave.url=jdbc:mysql://localhost:3308/o2o?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false&allowPublicKeyRetrieval=true
jdbc.username=root
jdbc.password=123456

第三步：在spring-dao.xml中配置数据源,将原先的id=datasource的bean替换为下面的几个bean。

 <!-- 2.配置数据库连接池 -->
    <!-- 2.数据库连接池存放一些公用的配置  destroy-method设为close当数据库连接不使用时，将该连接放回数据库池中，方便下次使用时调用-->
    <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.username}" />
        <property name="password" value="${jdbc.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.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- 配置动态数据源，这里的targetDataSource对应的就是路由数据源对应的名称 -->
    <bean id="dynamicDataSource" class="cn.xdw.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>

至此，主从数据库的读写分离代码层配置完成！

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Spring 整合MySql实现无侵入式的读写分离
    一、背景描述 项目发展到一定的阶段，数据库可能成为访问性能的一个瓶颈，并且我们发现数据库的读写基本上符合2-8定律...
    GeekerLou阅读 1,665评论 0赞 2
  • MySQL主从读写分离
    今天我们来说一说主从库的读写分离的问题 主从结构 一般情况下主从的结构是由一个Master和多个Slave来组成的...
    帅可儿妞阅读 450评论 2赞 0
  • 面试题
    Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对...
    cosWriter阅读 11,142评论 1赞 32
  • mysql读写分离
    前言 随着业务的不断扩展，数据量的不断增大,由单台Mysql作为独立的数据库是完全不能满足实际需求的。读和写又存在...
    slicn阅读 1,004评论 0赞 0
  • 他有一个很棒的名字
    这些天，我家的“乌巴”生病了，让人嫌弃的病，全身的肉都快烂了。没有人给他治，农村这地方也不会因为狗而专门存在兽医。...
    苏木不姓苏阅读 256评论 0赞 0