mysql读写分离
Posted 反光的小鱼儿
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了mysql读写分离相关的知识，希望对你有一定的参考价值。
mysql的读写分离两种实现方式
第一种方式：我们手动在代码层实现逻辑，来解析读请求或者写请求，分别分发到不同的数据库中，实现读写分离；
第二种方式就是基于中间件做一层proxy，比如MyCat来实现读写分离的效果。
手写实现读写分离
MyBatis+Spring
手写MyBatis拦截器来判断SQL是读或者写，从而选择数据源，最后交给Spring注入数据源，来实现读写分离。
------修改application.yml
server: port: 10001 spring: datasource: master: url: jdbc:mysql://192.168.43.201:3306/springtestdemo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: Object password: Object971103. driver-class-name: com.mysql.cj.jdbc.Driver slave: url: jdbc:mysql://192.168.43.202:3306/springtestdemo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC username: Object password: Object971103. driver-class-name: com.mysql.cj.jdbc.Driver #MyBatis配置 mybatis: mapper-locations: classpath:mapper/*.xml configuration: cache-enabled: true #开启二级缓存 map-underscore-to-camel-case: true
------DataSource的配置
首先要先创建两个ConfigurationProperties类，这一步不是非必须的，直接配置DataSource也是可以的，但是我还是比较习惯去写这个Properties。
package cn.objectspace.springtestdemo.config; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @ConfigurationProperties(prefix = "spring.datasource.master") @Component public class MasterProperties { private String url; private String username; private String password; private String driverClassName; public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getDriverClassName() { return driverClassName; } public void setDriverClassName(String driverClassName) { this.driverClassName = driverClassName; } }
SlaveProperties类似。
------DataSourceConfig主从数据源配置
@Configuration public class DataSourceConfig { private Logger logger = LoggerFactory.getLogger(DataSourceConfig.class); @Autowired private MasterProperties masterProperties; @Autowired private SlaveProperties slaveProperties; //默认是master数据源 @Bean(name = "masterDataSource") @Primary public DataSource masterProperties(){ logger.info("masterDataSource初始化"); HikariDataSource dataSource = new HikariDataSource(); dataSource.setJdbcUrl(masterProperties.getUrl()); dataSource.setUsername(masterProperties.getUsername()); dataSource.setPassword(masterProperties.getPassword()); dataSource.setDriverClassName(masterProperties.getDriverClassName()); return dataSource; } @Bean(name = "slaveDataSource") public DataSource dataBase2DataSource(){ logger.info("slaveDataSource初始化"); HikariDataSource dataSource = new HikariDataSource(); dataSource.setJdbcUrl(slaveProperties.getUrl()); dataSource.setUsername(slaveProperties.getUsername()); dataSource.setPassword(slaveProperties.getPassword()); dataSource.setDriverClassName(slaveProperties.getDriverClassName()); return dataSource; } }
------动态数据源的切换
这里使用到的主要是Spring提供的AbstractRoutingDataSource，其提供了动态数据源的功能，可以帮助我们实现读写分离。其determineCurrentLookupKey()可以决定最终使用哪个数据源，这里我们自己创建了一个DynamicDataSourceHolder，来给他传一个数据源的类型（主、从）。
package cn.objectspace.springtestdemo.dao.split; import java.util.HashMap; import java.util.Map; import javax.annotation.Resource; import javax.sql.DataSource; import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; /** * * @Description: spring提供了AbstractRoutingDataSource，提供了动态选择数据源的功能，替换原有的单一数据源后，即可实现读写分离: * @Author: Object * @Date: 2019年11月30日 */ public class DynamicDataSource extends AbstractRoutingDataSource{ //注入主从数据源 @Resource(name="masterDataSource") private DataSource masterDataSource; @Resource(name="slaveDataSource") private DataSource slaveDataSource; @Override public void afterPropertiesSet() { setDefaultTargetDataSource(masterDataSource); Map<Object, Object> dataSourceMap = new HashMap<>(); //将两个数据源set入目标数据源 dataSourceMap.put("master", masterDataSource); dataSourceMap.put("slave", slaveDataSource); setTargetDataSources(dataSourceMap); super.afterPropertiesSet(); } @Override protected Object determineCurrentLookupKey() { //确定最终的目标数据源 return DynamicDataSourceHolder.getDbType(); } }
------DynamicDataSourceHolder的实现
package cn.objectspace.springtestdemo.dao.split; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * @Description: 获取DataSource * @Author: Object * @Date: 2019年11月30日 */ public class DynamicDataSourceHolder { private static Logger logger = LoggerFactory.getLogger(DynamicDataSourceHolder.class); private static ThreadLocal<String> contextHolder = new ThreadLocal<>(); public static final String DB_MASTER = "master"; public static final String DB_SLAVE="slave"; /** * @Description: 获取线程的DbType * @Param: args * @return: String * @Author: Object * @Date: 2019年11月30日 */ public static String getDbType() { String db = contextHolder.get(); if(db==null) { db = "master"; } return db; } /** * @Description: 设置线程的DbType * @Param: args * @return: void * @Author: Object * @Date: 2019年11月30日 */ public static void setDbType(String str) { logger.info("所使用的数据源为:"+str); contextHolder.set(str); } /** * @Description: 清理连接类型 * @Param: args * @return: void * @Author: Object * @Date: 2019年11月30日 */ public static void clearDbType() { contextHolder.remove(); } }
------MyBatis拦截器的实现（***）
最后就是我们实现读写分离的核心了，这个类可以对SQL进行判断，是读SQL还是写SQL，从而进行数据源的选择，最终调用DynamicDataSourceHolder的setDbType方法，将数据源类型传入。
package cn.objectspace.springtestdemo.dao.split; import java.util.Locale; import java.util.Properties; 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.Interceptor; import org.apache.ibatis.plugin.Intercepts; import org.apache.ibatis.plugin.Invocation; import org.apache.ibatis.plugin.Plugin; import org.apache.ibatis.plugin.Signature; import org.apache.ibatis.session.ResultHandler; import org.apache.ibatis.session.RowBounds; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * @Description: MyBatis级别拦截器，根据SQL信息，选择不同的数据源 * @Author: Object * @Date: 2019年11月30日 */ @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 }) }) @Component public class DynamicDataSourceInterceptor implements Interceptor { private Logger logger = LoggerFactory.getLogger(DynamicDataSourceInterceptor.class); // 验证是否为写SQL的正则表达式 private static final String REGEX = ".*insertu0020.*|.*deleteu0020.*|.*updateu0020.*"; /** * 主要的拦截方法 */ @Override public Object intercept(Invocation invocation) throws Throwable { // 判断当前是否被事务管理 boolean synchronizationActive = TransactionSynchronizationManager.isActualTransactionActive(); String lookupKey = DynamicDataSourceHolder.DB_MASTER; if (!synchronizationActive) { //如果是非事务的，则再判断是读或者写。 // 获取SQL中的参数 Object[] objects = invocation.getArgs(); // object[0]会携带增删改查的信息，可以判断是读或者是写 MappedStatement ms = (MappedStatement) objects[0]; // 如果为读，且为自增id查询主键，则使用主库 // 这种判断主要用于插入时返回ID的操作，由于日志同步到从库有延时 // 所以如果插入时需要返回id，则不适用于到从库查询数据，有可能查询不到 if (ms.getSqlCommandType().equals(SqlCommandType.SELECT) && 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("[ ]", " "); // 正则验证 if (sql.matches(REGEX)) { // 如果是写语句 lookupKey = DynamicDataSourceHolder.DB_MASTER; } else { lookupKey = DynamicDataSourceHolder.DB_SLAVE; } } } else { // 如果是通过事务管理的，一般都是写语句,直接通过主库 lookupKey = DynamicDataSourceHolder.DB_MASTER; } logger.info("在" + lookupKey + "中进行操作"); DynamicDataSourceHolder.setDbType(lookupKey); // 最后直接执行SQL return invocation.proceed(); } /** * 返回封装好的对象，或代理对象 */ @Override public Object plugin(Object target) { // 如果存在增删改查，则直接拦截下来，否则直接返回 if (target instanceof Executor) return Plugin.wrap(target, this); else return target; } /** * 类初始化的时候做一些相关的设置 */ @Override public void setProperties(Properties properties) { // TODO Auto-generated method stub } }
------总结梳理
通过上文中的程序，我们已经可以实现读写分离了，但是这么看着还是挺乱的。所以在这里重新梳理一遍上文中的代码。
其实逻辑并不难：
- 通过@Configuration实现多数据源的配置。
- 通过MyBatis的拦截器，DynamicDataSourceInterceptor来判断某条SQL语句是读还是写，如果是读，则调用DynamicDataSourceHolder.setDbType("slave")，否则调用DynamicDataSourceHolder.setDbType("master")。
- 通过AbstractRoutingDataSource的determineCurrentLookupKey()方法，返回DynamicDataSourceHolder.getDbType();也就是我们在拦截器中设置的数据源。
- 对注入的数据源执行SQL。
AOP+Spring
spring动态数据源设置默认的master数据源和从数据源，aop针对读写的方法名来是读或者写，然后选择数据源去请求。
基于MyCat中间件实现读写分离、故障转移
MyCat配置文件
------server.xml
mycat安装目录下的/conf/server.xml文件，配置文件简化之后大概是这样的一个结构。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
<system>
</system>
<user name="MyCat" defaultAccount="true">
</user>
</mycat:server>
其实对于Server.xml，我们主要配置的就是下面的user模块，我们把它展开，着重讲讲这部分的配置。
<user name="这里写MyCat的用户名 可以自定义" defaultAccount="true">
<property name="password">这里写MyCat的密码</property>
<property name="schemas">这里配置MyCat的虚拟database</property>
<!-- 表级 DML 权限设置 -->
<!--
这里是我们配置的mycat用户对某张表的权限配置，我们这里暂不配置但是还是说一下。下文中的0000 1111，每一位代表CRUD 1111就是有增删改查的权限，0000就 是没有这些权限。以此类推
<privileges check="false">
<schema name="TESTDB" dml="0110" >
<table name="tb01" dml="0000"></table>
<table name="tb02" dml="1111"></table>
</schema>
</privileges>
-->
</user>
user代表MyCat的用户，我们在使用MySQL的时候都会有一个用户，MyCat作为一个虚拟节点，我们可以把它想象成它就是一个MySQL，所以自然而然它也需要有一个用户。但是他的用户并不是我们用命令创建的，而是直接在配置文件中配置好的，我们之后登录MyCat，就是用这里的用户名和密码进行登录。至于如何配置，我在上面的配置中都写好啦。跟着做就没有问题。
当然可以配置多个用户<user>，比如配置root用户有所有权限。普通用户只有读权限。
------schema.xml
myCat安装目录的conf/schema.xml，这个配置文件是我们需要关注的一个配置文件，因为我们的读写分离、分库分表、故障转移、都配置在这个配置文件中。
首先是标签中的内容。这个标签主要是为MyCat虚拟出一个数据库，我们连接到MyCat上能看到的数据库就是这里配置的,而分库分表也主要在这个标签中进行配置。这个标签中的name属性，就是为虚拟数据库指定一个名字，也是我们连接MyCat看到的数据库的库名，dataNode是和下文的dataNode标签中的name相对应的，代表这个虚拟的数据库和下面的dataNode进行绑定。
<schema name="MyCatDatabase" checkSQLschema="false" sqlMaxLimit="100" dataNode="这里写节点名，需要和dataNode中的name相对应">
<!-- 分库分表 -->
<!--<table name="travelrecord" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />-->
</schema>
第二个标签是标签，这个标签是和我们真实数据库中的database联系起来的，name属性是我们对这个dataNode自定义的一个名字，要注意的是，这个名字需要和schema标签中的dataNode内容一致，database属性写的是我们真实数据库中的真实database的名字。而dataHost的内容需要和之后标签中的name属性的值相对应。
<dataNode name="这里写节点名，需要和schema中的dataNode相对应" dataHost="这里也是一个自定义名字，需要和dataHost中的name相对应" database="这里填MySQL真实的数据库名" />
第三个标签要说的是标签，这个标签是和我们真实数据库的主从、读写分离联系起来的标签，什么意思呢。这个标签中有这么两个子标签和分别代表我们的写库和读库，中配置的库可以用于读或者写，而中配置的库只能用于读。
可以看到schema.xml的配置是一环扣一环的，每个标签之间都有相互进行联系的属性。我们最后配置完的schema.xml应该长下面这个样子：
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="这里写虚拟database名，需要和server.xml中的schema相对应" checkSQLschema="false" sqlMaxLimit="100" dataNode="这里写节点名，需要和dataNode中的name相对应">
<!-- 分库分表 -->
<!--<table name="travelrecord" dataNode="dn1,dn2,dn3" rule="auto-sharding-long" />-->
</schema>
<dataNode name="这里写节点名，需要和schema中的dataNode相对应" dataHost="这里也是一个自定义名字，需要和dataHost中的name相对应" database="这里填MySQL真实的数据库名" />
<dataHost name="这里写和dataNode中的dataHost相同的名字" maxCon="1000" minCon="10" balance="1" writeType="0" dbType="mysql" dbDriver="native" switchType="1" slaveThreshold="100">
<!-- 心跳语句，证明myCat和mySQL是相互连接的状态-->
<heartbeat>show slave status</heartbeat>
<!-- 读写分离 -->
<writeHost host="节点的名字，随便取" url="数据库的url（IP:PORT）" user="数据库中给MyCat创建的用户名" password="数据库中给MyCat创建的密码">
<readHost host="节点的名字，随便取" url="数据库的url（IP:PORT）" user="数据库中给MyCat创建的用户名" password="数据库中给MyCat创建的密码">
</readHost>
<readHost host="节点的名字，随便取" url="数据库的url（IP:PORT）" user="数据库中给MyCat创建的用户名" password="数据库中给MyCat创建的密码">
</readHost>
</writeHost>
<!-- 主从切换 -->
<writeHost host="节点的名字，随便取" url="数据库的url（IP:PORT）" user="数据库中给MyCat创建的用户名" password="数据库中给MyCat创建的密码"></writeHost>
<writeHost host="节点的名字，随便取" url="数据库的url（IP:PORT）" user="数据库中给MyCat创建的用户名" password="数据库中给MyCat创建的密码"></writeHost>
</dataHost>
</mycat:schema>
------rules.xml
分库分表相关。
配置故障转移
假如我们的Master数据库突然宕机了，那么是否整个集群就丧失了写功能呢？
在没有故障转移之前，这个答案是肯定的，当主库宕机时，从库作为读库，是不会有写的功能的，整个集群也就丧失了写的功能，这是我们不希望看到的。
我们希望看到的场景是：当主库宕机，某一个从库自动变为主库，承担写的功能，保证整个集群的可用性。
那么我们开始进行配置，其实思路很简单，MyCat的标签中有一个switchType属性，其决定了切换的条件。
switchType指的是切换的模式，目前的取值也有4种： switchType=‘-1‘ 表示不自动切换 switchType=‘1‘ 默认值，表示自动切换 switchType=‘2‘ 基于MySQL主从同步的状态决定是否切换,心跳语句为 show slave status switchType=‘3‘基于MySQL galary cluster的切换机制（适合集群）（1.4.1），心跳语句为 show status like ‘wsrep%‘。
我们直接将switchType修改为2，然后将两个读库配置为第一个写库同级的写库。
<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
<schema name="MyCat" checkSQLschema="false" sqlMaxLimit="100" dataNode="mycatdb">
</schema>
<dataNode name="mycatdb" dataHost="mycluster" database="testcluster" />
<dataHost name="mycluster" maxCon="1000" minCon="10" balance="1"
writeType="0" dbType="mysql" dbDriver="native" switchType="2" slaveThreshold="100">
<heartbeat>show slave status</heartbeat>
<!-- 读写分离 -->
<writeHost host="Master201" url="192.168.43.201:3306" user="MyCat" password="123456">
<readHost host="Slave202" url="192.168.43.202:3306" user="MyCat" password="123456">
</readHost>
<readHost host="Slave203" url="192.168.43.203:3306" user="MyCat" password="123456">
</readHost>
</writeHost>
<!-- 主从切换 -->
<writeHost host="Slave202" url="192.168.43.202:3306" user="MyCat" password="123456"></writeHost>
<writeHost host="Slave203" url="192.168.43.203:3306" user="MyCat" password="123456"></writeHost>
</dataHost>
</mycat:schema>
此时停掉master库即可测试。但是此时我们MySQL的主从架构已经被破坏，如果需要恢复主从结构，就需要手动地重新去恢复我们的主从架构。我们需要将201和203作为Slave，202作为Master，因为Master拥有最完整的数据。
两者的优劣分析
代码层实现读写分离，主要的优点就是灵活，可以自己根据不同的需求对读写分离的规则进行定制化开发，但其缺点也十分明显，就是当我们动态增减主从库数量的时候，都需要对代码进行一个或多或少的修改。并且当主库宕机了，如果我们没有实现相应的容灾逻辑，那么整个数据库集群将丧失对外的写功能。
使用MyCat中间件实现读写分离，优点十分明显，我们只需要进行配置就可以享受读写分离带来的效率的提升，不用写一行代码，并且当主库宕机时，我们还可以通过配置的方式进行主从库的自动切换，这样即使主库宕机我们的整个集群也不会丧失写的功能。其缺点可能就是我们得多付出一台服务器作为虚拟节点了吧，毕竟服务器也是需要成本的。
两种方式如何抉择：如果你目前的项目比较小，或者干脆是一个毕业设计、课程设计之类的，不会有动态增减数据库的需求，那么自己动手实现一个数据库的读写分离会比较适合你，毕竟答辩的时候，可以一行一行代码跟你的导师和同学解（zhuang）释（bi）。如果项目比较大了，数据库节点有可能进行增减，并且需要主从切换之类的功能，那么就使用第二种方式吧。这种配置化的实现可以降低第二天洗头时候下水管堵塞的几率。
以上是关于mysql读写分离的主要内容，如果未能解决你的问题，请参考以下文章