JavaSharding-JDBC

为什么要读写分离？

读写分离则是将事务性的增、改、删操作在主库执行，查询操作在从库执行。
一般业务的写操作都是比较耗时，为了避免写操作影响查询的效率，可以使用读写分离。
当然读写分离并不是万能的，还有前面的分库分表方案。

读写分离如何搭建？

MySQL搭建读写分离非常简单，一般有一主一从、一主多从，对于MySQL的主从的相关概念这里就不再详细介绍了。
下面就以MySQL5.7为例，使用docker搭建一个一主一从的架构，步骤如下：

1、pull镜像

使用如下命令从镜像仓库中下载镜像：

  1. docker pull mysql:5.7.26

2、创建目录

MySQL数据和配置文件挂载的目录：

  1. mkdir -p /usr/local/mysqlData/master/cnf
  2. mkdir -p /usr/local/mysqlData/master/data
  4. mkdir /usr/local/mysqlData/slave/cnf -p
  5. mkdir /usr/local/mysqlData/slave/cnf -p

3、编写配置master节点配置

修改MySQL主节点的配置文件，内容如下：

  1. vim /usr/local/mysqlData/master/cnf/mysql.cnf
  3. [mysqld]
  4. ## 设置server_id,注意要唯一
  5. server-id=1
  6. ## 开启binlog
  7. log-bin=mysql-bin
  8. ## binlog缓存
  9. binlog_cache_size=1M
  10. ## binlog格式(mixed、statement、row,默认格式是statement)
  11. binlog_format=mixed

4、编写配置slave节点配置

修改MySQL从节点的配置文件，内容如下：

  1. vim /usr/local/mysqlData/slave/cnf/mysql.cnf
  3. [mysqld]
  4. ## 设置server_id,注意要唯一
  5. server-id=2
  6. ## 开启binlog,以备Slave作为其它Slave的Master时使用
  7. log-bin=mysql-slave-bin
  8. ## relay_log配置中继日志
  9. relay_log=edu-mysql-relay-bin
  10. ## 如果需要同步函数或者存储过程
  11. log_bin_trust_function_creators=true
  12. ## binlog缓存
  13. binlog_cache_size=1M
  14. ## binlog格式(mixed、statement、row,默认格式是statement)
  15. binlog_format=mixed
  16. ## 跳过主从复制中遇到的所有错误或指定类型的错误,避免slave端复制中断
  17. ## 如:1062错误是指一些主键重复,1032错误是因为主从数据库数据不一致
  18. slave_skip_errors=1062

5、启动MySQL主节点

命令如下：

  1. docker run -itd -p 3306:3306 --name master -v /usr/local/mysqlData/master/cnf:/etc/mysql/conf.d -v /usr/local/mysqlData/master/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.26

6、添加复制master数据的用户reader，供从服务器使用

命令如下：

  1. [root@aliyun /]# docker ps
  2. CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
  3. 6af1df686fff        mysql:5.7           "docker-entrypoint..."   5 seconds ago       Up 4 seconds        0.0.0.0:3306->3306/tcp, 33060/tcp   master
  5. [root@aliyun /]# docker exec -it master /bin/bash
  7. root@41d795785db1:/# mysql -u root -p123456
  9. mysql> GRANT REPLICATION SLAVE ON *.* to 'reader'@'%' identified by 'reader';
  10. Query OK, 0 rows affected, 1 warning (0.00 sec)
  12. mysql> FLUSH PRIVILEGES;
  13. Query OK, 0 rows affected (0.00 sec)

7、创建并运行mysql从服务器

命令如下：

  1. docker run -itd -p 3307:3306 --name slaver -v /usr/local/mysqlData/slave/cnf:/etc/mysql/conf.d -v /usr/local/mysqlData/slave/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.26

8、在从服务器上配置连接主服务器的信息

首先主服务器上查看master_log_file、master_log_pos两个参数，然后切换到从服务器上进行主服务器的连接信息的设置。
主服务上执行：

  1. root@6af1df686fff:/# mysql -u root -p123456
  3. mysql> show master status;
  4. +------------------+----------+--------------+------------------+-------------------+
  5. | File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
  6. +------------------+----------+--------------+------------------+-------------------+
  7. | mysql-bin.000003 |      591 |              |                  |                   |
  8. +------------------+----------+--------------+------------------+-------------------+
  9. 1 row in set (0.00 sec)

docker查看主服务器容器的ip地址：

  1. [root@aliyun /]# docker inspect --format='{{.NetworkSettings.IPAddress}}' master
  2. 172.17.0.2

从服务器上执行：

  1. [root@aliyun /]# docker exec -it slaver /bin/bash
  2. root@fe8b6fc2f1ca:/# mysql -u root -p123456  
  4. mysql> change master to master_host='172.17.0.2',master_user='reader',master_password='reader',master_log_file='mysql-bin.000003',master_log_pos=591;

9、从服务器启动I/O 线程和SQL线程

  1. mysql> start slave;
  2. Query OK, 0 rows affected, 1 warning (0.00 sec)
  4. mysql> show slave status\G
  5. *************************** 1. row ***************************
  6.                Slave_IO_State: Waiting for master to send event
  7.                   Master_Host: 172.17.0.2
  8.                   Master_User: reader
  9.                   Master_Port: 3306
  10.                 Connect_Retry: 60
  11.               Master_Log_File: mysql-bin.000003
  12.           Read_Master_Log_Pos: 591
  13.                Relay_Log_File: edu-mysql-relay-bin.000002
  14.                 Relay_Log_Pos: 320
  15.         Relay_Master_Log_File: mysql-bin.000003
  16.              Slave_IO_Running: Yes
  17.             Slave_SQL_Running: Yes

Slave_IO_Running: Yes，Slave_SQL_Running: Yes即表示启动成功。

Sharding-JDBC 实现读写分离

上面使用Docker搭建了一个MySQL的一主一从的架构，如下：

ip:port 节点 数据库
192.168.47.149:3306 主节点 product_db_1
192.168.47.149:3307 从节点 product_db_1

Sharding-JDBC对于读写分离的配置非常简单，分为如下几个步骤：

1、数据源配置

无论是分库分表还是读写分离，数据源的声明肯定是必须的，如下：

  1. spring:
  2.   # Sharding-JDBC的配置
  3.   shardingsphere:
  4.     datasource:
  5.       # 数据源，这里配置两个，分别是ds1，ds2
  6.       names: ds1,ds2
  7.       # 主库
  8.       ds1:
  9.         type: com.alibaba.druid.pool.DruidDataSource
  10.         driver-class-name: com.mysql.jdbc.Driver
  11.         url: jdbc:mysql://192.168.47.149:3306/product_db1?useUnicode=true&characterEncoding=utf-8
  12.         username: root
  13.         password: 123456
  14.       # 从库
  15.       ds2:
  16.         type: com.alibaba.druid.pool.DruidDataSource
  17.         driver-class-name: com.mysql.jdbc.Driver
  18.         url: jdbc:mysql://192.168.47.149:3307/product_db1?useUnicode=true&characterEncoding=utf-8
  19.         username: root
  20.         password: 123456

2、主从节点配置

第①步仅仅配置了数据源，并未指定哪个是主库，哪个是从库，Sharding-JDBC 默认是不知道哪个主库还是从库的，因此需要自己配置。
配置规则如下：

  1. #主库数据源名称，名称随意
  2. spring.shardingsphere.masterslave.<master-slave-data-source-name>.master-data-source-name= 
  4. #从库数据源名称列表
  5. spring.shardingsphere.masterslave.<master-slave-data-source-name>.slave-data-source-names[0]= 
  7. #从库数据源名称列表
  8. spring.shardingsphere.masterslave.<master-slave-data-source-name>.slave-data-source-names[1]= 
  10. #从库负载均衡算法类名称。该类需实现MasterSlaveLoadBalanceAlgorithm接口且提供无参数构造器
  11. spring.shardingsphere.masterslave.<master-slave-data-source-name>.load-balance-algorithm-class-name=
  13. #从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM。若`load-balance-algorithm-class-name`存在则忽略该配置
  14. spring.shardingsphere.masterslave.<master-slave-data-source-name>.load-balance-algorithm-type=

这里的<master-slave-data-source-name>一定要注意，这个是主从配置的名称（相当于逻辑数据源），名称可以随意，但是一定要唯一。
配置如下：

  1. spring:
  2.   # Sharding-JDBC的配置
  3.   shardingsphere:
  4.     # 主从节点配置
  5.     masterslave:
  6.       # 从库负载均衡算法，内置两个值：RANDOM、ROUND_ROBIN
  7.       load-balance-algorithm-type: round_robin
  8.       # 主从的名称，随意，但是要保证唯一
  9.       name: ms
  10.       # 指定主数据源
  11.       master-data-source-name: ds1
  12.       # 指定从数据源
  13.       slave-data-source-names:
  14.         - ds2

指定的逻辑数据源为ms，主库为ds1，从库为ds2。
load-balance-algorithm-type：指定从库的负载均衡算法。

3、测试

经过上面两步的配置，Sharding-JDBC的读写分离已经配置成功，下面来测试一下。
理想效果：

  • 写操作：任何的写操作都应该在主库数据源ds1中执行
  • 读操作：任何的读操作都应该在从库数据源ds2中执行

    1、写操作

    直接insert插入一条数据，查看Sharding-JDBC的日志，如下：
    Sharding-JDBC 实现 读写分离 - 图1
    可以看到都在ds1中执行了

    2、读操作

    根据商品ID查询一条数据，效果如下：
    Sharding-JDBC 实现 读写分离 - 图2
    可以看到都在ds2中执行了