mysql主从分离java项目实现_基于MySql主从分离的代码层实现

前言

该文是基于上篇《MySQL主从分离的实现》的代码层实现，所以本文配置的主数据库和从数据库的数据源都是在上篇博文中已经介绍了的。

动态选择数据源的配置

由于我们在写数据的时候需要使用主库的数据源，读的时候需要从库的数据源，我们可以在Spring源码中，通过DataSource可以找到AbstractDataSource抽象类，由于我们需要动态的选择数据源，我们可以通过AbstractDataSource发现他的一个子类是AbstractRoutingDataSource的抽象类，通过类名我们可以知道该类是具有路由功能的，可以路由到不同的数据源，这个类中有一个方法determineTargetDateSource()，该方法就是决定目标数据源的，该方法会调用determineCurrentLookupKey()，就是决定数据源的名字了，该方法是一个抽象的，所以我们需要去继承AbstractRoutingDataSource这个类，并实现determineCurrentLookupKey()这个方法，来动态选择数据源，读数据的时候选择从库的数据源，写操作的时候选择主库的数据源

public class DynamicDataSource extends AbstractRoutingDataSource {

@Override

protected Object determineCurrentLookupKey() {

return DynamicDataSourceHolder.getDBType();

}

}

编写DynamicDataSourceHolder

public class DynamicDataSourceHolder {

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

//ThreadLocal是线程安全的

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

public static final String DB_MASTER = "master";

public static final String DB_SLAVE = "slave";

public static String getDBType() {

String db = contextHolder.get();

if (db == null){

db = DB_MASTER; // 默认为master,因为master即支持读也支持写

}

return db;

}

/**

* 设置线程的dbType

* @param str

*/

public static void setDBType(String str) {

logger.debug("所使用的数据源："+ str);

contextHolder.set(str);

}

/**

* 清理连接类型

*/

public static void clearDBType(){

contextHolder.remove();

}

}

设置mybatis的拦截器

完成路由后，我们需要依靠拦截器对传递进来的SQL信息来选择数据源，例如传进来的是insert,update,delete语句，就使用主库的数据源，如果是select就选择从库的数据源。

@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.*";

/**

* 拦截方法

* @param invocation

* @return

* @throws Throwable

*/

@Override

public Object intercept(Invocation invocation) throws Throwable {

// 判断当前操作是否是事务的

// 使用@Transactional来处理，则会返回true

boolean transactionActive = TransactionSynchronizationManager.isActualTransactionActive();

Object[] args = invocation.getArgs();

MappedStatement ms = (MappedStatement) args[0];

String lookupKey = DynamicDataSourceHolder.DB_MASTER;

if ( !transactionActive ) {

// 如果是查询操作

if (ms.getSqlCommandType().equals(SqlCommandType.SELECT)) {

//selectKey 为自增id查询主键SELECT_KEY_SUFFIX()方法，使用主库

if (ms.getId().contains(SelectKeyGenerator.SELECT_KEY_SUFFIX)){

lookupKey = DynamicDataSourceHolder.DB_MASTER;

} else {

BoundSql boundSql = ms.getSqlSource().getBoundSql(args[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();

}

/**

* 决定返回封装好的对象还是代理对象

* 增删改查得操作

* @param target

* @return

*/

@Override

public Object plugin(Object target) {

//当我们拦截的对象是Executor时，就拦截，通过intercept()方法 决定所使用的数据源

//为什么要拦截Executor类型呢？因为在我们的mybatis中，Executor是用来支持一系列增删改查操作的

//只要我们检测到拦截的对象包含增删改查操作，就拦截下来，使用intercept()方法，决定所使用的数据源

if (target instanceof Executor) {

return Plugin.wrap(target,this);

} else {

return target;

}

}

/**

* 在类初始化的时候，去做一些相关的设置

* @param properties

*/

@Override

public void setProperties(Properties properties) {

}

}

只是编写完这个方法是没用的，我们还需要在mybaties-config.xml配置文件中，配置上我们实现的拦截器，如下：

/p>

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

配置多数据源

将原来配置dataSource的bean，改为abstractDatasource，并增加主库数据源和从库数据源的配置，如下：

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

我们在jdbc.properties配置文件中，配置主从库数据源的地址：

## 主库数据源配置

jdbc.master.driver=com.mysql.jdbc.Driver

jdbc.master.url=jdbc:mysql://192.168.0.188:3306/o2o?useUnicode=true&characterEncoding=utf8

jdbc.master.username=root

jdbc.master.password=123456

## 从库数据源配置

jdbc.slave.driver=com.mysql.jdbc.Driver

jdbc.slave.url=jdbc:mysql://192.168.0.152:3306/o2o?useUnicode=true&characterEncoding=utf8

jdbc.slave.username=root

jdbc.slave.password=root

测试

我们在执行查询操作时，就会从从库中去查询，我们可以通过查看日志的知，如下：

当我们执行增删改操作时，就会使用从库的数据源，如下：

通过测试可知，我们配置主从分离，代码层实现已经成功了，我们从日志也可以看到，我们的系统用户执行更多的操作都是在执行查询操作，我们也可以配置一主多从来减轻服务器的压力。