数据库中间件ShardingSphere

数据库中间件ShardingSphere

去ShardingSphere官网了解

一、基本的概念

Apache ShardingSphere是一个开源分布式数据库中间件解决方案，子产品有三种Sharding-JDBC、Sharding-Proxy和Sidecar(规划中)，该软件的定位为关系型数据库中间件，合理分布式环境下使用关系型数据库操作

1.分库分表

在关系型数据库中，数据量随着业务与时间的发展，会使得表里的数据越来越多，如果再对数据库表进行增删改查时，会产生性能减低的问题

解决方案是分库分表，对于不同的业务将数据库中的表放置在不同的数据库服务器上，表中的数据量过大时，将表拆分成多个表来存储数据信息。

2.分库分表的方式

分库分表的方式有：垂直切分和水平切分

垂直切分分为：垂直分表和垂直分库

水平切分分为：水平分表和水平分库

3.垂直分表

操作数据库中某张表，把这张表中的一部分字段数据存到一张新表里，再把这张表另一部分字段数据存储到另一张表中

4.垂直分库

将单一的数据库按照业务进行划分，例如商品表、订单表、人员表，对这些表放置在不同的服务器中，一个数据库只做一个业务事件。

5.水平分库

相同的数据表进行复制放在另一个数据库中，两个数据库中存放的数据表是相同的数据表，数据存储时，根据某种规则将数据进行分开存储例如按照id的奇偶性。

6.水平分表

在同一个数据库中，创建相同结构的数据库表，根据某种规则将数据存储到对应的数据表中。

7.分库分表的应用和问题

应用时考虑：

1.设计数据库时，需要考虑数据库垂直分库和垂直分表

2.随着数据库数据量的增加，不要马上考虑水平切分，首先考虑缓存处理，读写分离，使用索引等等方式，如果这些方式不能根本解决问题，在考虑做水平分库和水平分表

问题：

1.跨界点连接查询问题(分页、排序)

2.多数据源管理的问题

二、Sharding-JDBC

0.基本概念

ShardingSphere-JDBC自身定义为轻量级Java框架，可在Java JDBC层提供额外的服务。客户端直接连接到数据库时，它以jar的形式提供服务，不需要额外的部署和依赖。它可以被认为是增强的JDBC驱动程序，它与JDBC和各种ORM框架完全兼容。

• 适用于任何基于JDBC的ORM框架，例如JPA，Hibernate，Mybatis，Spring JDBC模板或直接使用JDBC。
• 支持任何第三方数据库连接池，例如DBCP，C3P0，BoneCP，Druid，HikariCP。
• 支持任何种类的JDBC标准数据库：MySQL，Oracle，SQLServer，PostgreSQL和任何遵循SQL92的数据库。

功能：

数据分片和读写分离

简化分库分表之后的数据相关操作

操作

1.水平分表

1) 搭建环境：SpringBoot+MybatisPlus+Sharing-JDBC+Druid连接池

​ 创建工程+引入依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.20</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.18</version>
        </dependency>

        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.5</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

2) 创建数据库、创建数据库表：

创建数据库course_db

在数据库中创建两张表：couse_1和couse_2

约束：课程1和课程2分别添加数据id为奇数或者偶数的数据

创建两张相同结构的表

CREATE TABLE couse_1(
    `cid` BIGINT(20) PRIMARY KEY,
    `cname` VARCHAR(50) NOT NULL,
    `user_id` BIGINT(20) NOT NULL,
    `cstatus` VARCHAR(10) NOT NULL
)ENGINE = INNODB  CHARSET = UTF8;

CREATE TABLE couse_2(
   `cid` BIGINT(20) PRIMARY KEY,
   `cname` VARCHAR(50) NOT NULL,
   `user_id` BIGINT(20) NOT NULL,
  `cstatus` VARCHAR(10) NOT NULL
)ENGINE = INNODB CHARSET = utf8    

3)创建实体类，mybatis的Mapper，测试类中注入Mapper，启动类中开启扫描

@Data
public class Couse {
    private Long cid;
    private String cname;
    private Long userId;
    private String cstatus;
}

4）数据配置

这个配置是真的多，不知道真实项目中会不会用到，哈哈哈

##shardingjdbc分片策略
## 配置数据源，给数据源起一个名称 这里为m1
spring.shardingsphere.datasource.names=m1

#一个实体类对应两个数据库表的问题
spring.main.allow-bean-definition-overriding=true

##配置数据源的信息，连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
##jdbc:mysql://localhost:3306/course_db?serverTimerzone=GMT%2B8,最后面试配置时区
##由于数据库版本的问题
spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/couse_db?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
spring.shardingsphere.datasource.m1.username=root
spring.shardingsphere.datasource.m1.password=123

## 指定couse分布情况，配置数据库里面，变名称都是什么
spring.shardingsphere.sharding.tables.couse.actual-data-nodes=m1.couse_$->{1..2}

##couse表中主键的生成策略,SNOWFLAKE雪花算法，产生一个随机数
spring.shardingsphere.sharding.tables.couse.key-generator.column=cid
spring.shardingsphere.sharding.tables.couse.key-generator.type=SNOWFLAKE

##couse表中数据的插入规则，对于偶数的数据插入在表1中，对于奇数的数据插入在表2中
spring.shardingsphere.sharding.tables.couse.table-strategy.inline.sharding-column=cid
spring.shardingsphere.sharding.tables.couse.table-strategy.inline.algorithm-expression=couse_$->{cid%2 + 1}

##打开sql输出日志
spring.shardingsphere.props.sql.show=true

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class ShardingjdbcApplicationTests { //需要有Runwith注解和public标识
    @Autowired
    private CourseMapper courseMapper;
    //将10条数据加入数据表中
   @Test
    public void addCourse() {
       for (int i = 0; i < 10; i++) {
           Couse course = new Couse();
           course.setCname("java"+i);
           course.setCstatus("Normal"+i);
           course.setUserId(100L);
           courseMapper.insert(course);
       }
    }

}

数据库2的数据

数据库1的数据

总结：水平分表，在同一个数据库中，两个相同结构的数据库表分摊了压力

2.水平分库

1.创建数据

创建两个数据库，具有相同表结构的数据库，例如创建数据库edu_db_1和edu_db_2，然后创建数据表与上面的相同couse_1和couse_1

规则如下：

数据库规则：userid为偶数添加到数据库edu_db_1；为奇数时添加到数据库edu_db_2中

数据表规则：cid为偶数添加到数据表couse_1;为奇数添加到数据表couse_2中

2.指定规则

edu_db_1/couse_1	edu_db_1/couse_2	edu_db_2/couse_1	edu_db_2/couse_2
userid偶数cid为偶数	userid偶数cid为奇数	userid奇数cid为偶数	userid奇数cid为奇数

3.配置分片规则

出现的问题：由于自己粗心，水平分表时的数据库以及数据表的名称中都是couse但是我想写的是course,在当前的测试中对单词修改过来了，但是导致数据库表的名称与实体类不相匹配，修改配置文件中的信息。在配置文件中检查一下名称或者使用注解在实体类上指定数据库表@TableName(“couse”)

##shardingjdbc分片策略
## 配置数据源，给数据源起一个名称 这里为m1  多数据库
spring.shardingsphere.datasource.names=m1,m2

#一个实体类对应两个数据库表的问题
spring.main.allow-bean-definition-overriding=true

##配置数据源1的信息，连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
##jdbc:mysql://localhost:3306/course_db?serverTimerzone=GMT%2B8,最后面试配置时区
spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/course_db_1?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
spring.shardingsphere.datasource.m1.username=root
spring.shardingsphere.datasource.m1.password=123


##配置数据源2的信息，连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver
##jdbc:mysql://localhost:3306/course_db?serverTimerzone=GMT%2B8,最后面试配置时区
spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/course_db_2?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
spring.shardingsphere.datasource.m2.username=root
spring.shardingsphere.datasource.m2.password=123


## 指定数据库分布情况，数据库表的分布情况
##=号前面的信息时实体类的配置信息，等号右面的信息时数据库表的信息，通常两者之间是相同的例如数据库表为course 实体类为 Course
spring.shardingsphere.sharding.tables.couse.actual-data-nodes=m$->{1..2}.course_$->{1..2}

##couse表中主键的生成策略,SNOWFLAKE雪花算法，产生一个随机数
spring.shardingsphere.sharding.tables.couse.key-generator.column=cid
spring.shardingsphere.sharding.tables.couse.key-generator.type=SNOWFLAKE

##指定数据库的分配策略，根据约束，user_id如果是偶数添加到m1，如果是奇数添加到m2
spring.shardingsphere.sharding.tables.couse.database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.couse.database-strategy.inline.algorithm-expression=m$->{user_id%2 + 1}


##数据库表的分片的策略
spring.shardingsphere.sharding.tables.couse.table-strategy.inline.sharding-column=cid
spring.shardingsphere.sharding.tables.couse.table-strategy.inline.algorithm-expression=course_$->{cid%2 + 1}

##打开sql输出日志
spring.shardingsphere.props.sql.show=true

4.测试

 //=====================水平分库===========================
    @Test
    public void addCourseDB() {
            Couse course = new Couse();
            course.setCname("javaDemo");
            course.setUserId(100L);
            course.setCstatus("Normal");
            courseMapper.insert(course);
    }
    @Test
    public void queryCourseDB() {
        QueryWrapper<Couse>  wrapper = new QueryWrapper<>();
        wrapper.eq("cid",509300176519692288L);
        Couse couse = courseMapper.selectOne(wrapper);
        System.out.println(couse);
    }

3.垂直分库

垂直分库是一个数据库固定的执行一件事情，是一个专库专表

1.专库专表的配置

##配置数据源2的信息，连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.m3.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m3.driver-class-name=com.mysql.cj.jdbc.Driver
##jdbc:mysql://localhost:3306/course_db?serverTimerzone=GMT%2B8,最后面试配置时区
spring.shardingsphere.datasource.m3.url=jdbc:mysql://localhost:3306/user_db?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
spring.shardingsphere.datasource.m3.username=root
spring.shardingsphere.datasource.m3.password=123


## 专库专表的配置
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{3}.t_user

##couse表中主键的生成策略,SNOWFLAKE雪花算法，产生一个随机数
spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE

##数据库表的分片的策略
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression=t_user

2.公共表

1).存储固定数据的表，表数据很少发生变化，查询时经常进行关联

2).在每一个数据库文件中都创建出一个相同结构的公共表

##公共表配置
spring.shardingsphere.sharding.broadcast-tables=t_udict
spring.shardingsphere.sharding.tables.t_udict.key-generator.column=udict_id
spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE

3.读写分离

3.1 相关概念

读写分离又相当于主从复制的一个过程，我们在对数据库进行数据修改时，操作数据库1；获取数据信息的时候，操作数据库2。数据库2需要实时与数据库1做一些同步操作，主服务器的数据与从服务器数据相同。

数据库主从复制(一主一从、一主多从、多主多从)

主服务器开启binlog日志，记录增删改操作

从服务器实时监控主服务器的binlog日志文件，当文件有变化时，同步从服务器的数据

Sharding-JDBC通过sql语义分析，实现读写分离过程，不会做数据同步的操作，数据同步由数据库自身实现。

3.2 配置读写分离步骤

1.创建两个Mysql数据库服务器，并且启动两个Mysql服务器

复制原有的mysql文件夹，当做从服务器

2.修改my.ini文件

修改端口号，数据文件路径，从服务器实例的路径

3.将从服务器安装在windows安装的服务中

进入从服务器的bin文件路径下安装从服务器

使用命令：mysqld install mysqls1 –defaults-file=”D:\MYsql\MySQL\MySQL Server 5.5-s1\my.ini”

安装结果如下，手动启动两个数据库服务器实例：

如果安装中出错，删除掉服务器再进行重新安装：

sc delete 服务名称

从服务器是从主服务器复制过来的，因此里面的数据完全一致，使用原先的账号密码进行登录。

3.3 配置主从服务器

1.主服务器配置

[mysqld]
##需要在主服务器的my.ini中添加一下信息 
##开启日志
log-bin = mysql-bin
binlog_format=ROW    ##选择row模式
##设置服务id，主从不能一致
server_id = 1
#设置需要同步的数据库，如果不配置，对于所有的数据库进行同步操作
binlog-do-db = user_db
##屏蔽系统库同步
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
binlog-ignore-db=performance_schema

2.从服务器配置

[mysqld]
##需要在从服务器的my.ini中添加一下信息 
##开启日志
log-bin = mysql-bin   ##binlog文件名
binlog_format=ROW    ##选择row模式
##设置服务id，主从不能一致  
server_id = 2
#设置需要同步的数据库
replicate_wild_do_table = user_db.%
##屏蔽系统库同步
replicate_wild_ignore_table=mysql.%
replicate_wild_ignore_table=information_schema.%
replicate_wild_ignore_table=performance_schema.%

3.创建用于主从复制的账号，在mysql的数据库中创建用户也可以

##切换至主库bin目录，登录主库
mysql -h localhost -uroot -p
##授权主备复制专用账号
GRANT REPLICATION SLAVE ON *.* TO 'db_sync'@'%' IDENTIFIED BY 'db_sync';
##刷新权限
FLUSH PRIVILEGES;
##确认位点，记录下文件名以及位点
show master status;

创建账号信息如下

4.主从同步设置

##切换至主库bin目录，登录从库
mysql -h localhost -P3307 -uroot -p
##先停止同步
STOP SLAVE;
##修改从库指向主库，使用上一步记录的文件名以及位点
CHANGE MASTER TO 
master_host = 'localhost',
master_user = 'db_sync',
master_password = 'db_sync', ##主从用户的密码
master_log_file = 'mysql-bin.000001', ## 主服务器中的那个名字
master_log_pos = 107;   ## 主服务器中的那个编号

##启动同步
START SLAVE;

##查看从库状态Slave_IO_Runing和Slave_SQL_Runing都为yes表示成功，如果不为yes检查error_log，查看异常信息。
show slave status;

##不一定执行
STOP SLAVE IO_THREAD FOR CHANNEL '';
reset slave all;

4.Sharding-jdbc主从复制

##主从配置，从数据库服务器的数据源信息
spring.shardingsphere.datasource.s0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.s0.driver-class-name=com.mysql.cj.jdbc.Driver
##serverTimezone该属性是连接工具6之后必须添加的字段，否则会有空指针异常，本次使用的是8.0.18
spring.shardingsphere.datasource.s0.url=jdbc:mysql://localhost:3307/user_db?characterEncoding=utf8&useSSL=false&serverTimezone=UTC
spring.shardingsphere.datasource.s0.username=root
spring.shardingsphere.datasource.s0.password=123
##主从数据源配置
spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source-name=m3
spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source-names=s0
## 专库专表的配置
#spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{3}.t_user
##读写分离数据库表相关配置
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds0.t_user

添加依赖后测试：

//添加测试，向主服务器插入数据 
@Test
    public void addUserDB() {
        User user = new User();
        user.setUserName("itxing");
        user.setUstatus("001");
        userMapper.insert(user);
    }
//查询测试，从从数据库服务器获取数据
    @Test
    public void queryUserDB() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id",509769424882892801L);
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }

三、Sharding-Proxy

0.介绍

ShardingSphere-Proxy是一个透明数据库代理，它提供了一种数据库服务器，该服务器封装了数据库二进制协议以支持异构语言。对DBA友好的是，现在提供的MySQL版本可以使用与MySQL协议兼容的任何类型的终端（例如MySQL Command Client，MySQL Workbench等）来操作数据。

• 对应用程序完全透明，可以直接用作MySQL。
• 适用于任何与MySQL和PostgreSQL协议兼容的终端。

该工具是一个独立的软件，相当于一个网关服务器，客户端只需要操作中间件，对应的持久化数据不再需要自己去配置。

工具下载地址

注意：下载安装包后直接解压，然后查看解压后的文件夹中的lib文件夹下的.jar文件后缀名是否正确，如果不正确需要手动进行修改。

1.Sharding-Proxy配置

1.0.进入conf文件夹下

1.1.修改server.yaml

authentication:
  users:
    root:
      password: 123
    sharding:
      password: sharding
      authorizedSchemas: sharding_db

props:
  max.connections.size.per.query: 1
  acceptor.size: 16  # The default value is available processors count * 2.
  executor.size: 16  # Infinite by default.
  proxy.frontend.flush.threshold: 128  # The default value is 128.
    # LOCAL: Proxy will run with LOCAL transaction.
    # XA: Proxy will run with XA transaction.
    # BASE: Proxy will run with B.A.S.E transaction.
  proxy.transaction.type: LOCAL
  proxy.opentracing.enabled: false
  proxy.hint.enabled: false
  query.with.cipher.column: true
  sql.show: false
  allow.range.query.with.inline.sharding: false

1.2.修改config-sharding.yaml

该文件中提示我们要将mysql连接的驱动jar包放置在lib的目录下，当然如果连接其他的数据库，就是用其他的jar包。复制maven仓库中的mysql-connection-java的jar包到，sharding-proxy文件的lib中。

配置单一的数据库文件，进行测试

schemaName: sharding_db

dataSources:
  ds_0:
    url: jdbc:mysql://127.0.0.1:3306/user_db?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50

shardingRule:
  tables:
    t_order:
      actualDataNodes: ds_${0}.t_order_${0..1}
      tableStrategy:
        inline:
          shardingColumn: order_id
          algorithmExpression: t_order_${order_id % 2}
      keyGenerator:
        type: SNOWFLAKE
        column: order_id
  bindingTables:
    - t_order
  defaultDatabaseStrategy:
    inline:
      shardingColumn: user_id
      algorithmExpression: ds_${0}
  defaultTableStrategy:
    none:

1.3.启动服务

默认的端口号是3307 因此对于mysql数据库的从服务器尽量使用其余的端口

运行bin下面的.bat文件，成功启动

1.4.连接proxy服务

##连接sharding-proxy服务器，相当于msql，用户名、密码、端口需要注意一下

mysql -P3307 -uroot -proot

##查看数据库信息

show databases;

##选择当前的数据库

use sharding_db

##创建数据库表

create table if not exists ds_0.t_order(
order_id BIGINT NOT NULL,user_id INT NOT NULL,status VARCHAR(50),PRIMARY KEY (order_id));

##插入数据

INSERT INTO t_order(order_id,user_id,status) VALUES(11,1,'init');

1.5.查看数据库文件信息

proxy在mysql中创建表并插入数据信息

2.Sharding-Proxy实现分库

配置config-sharding.yaml

schemaName: sharding_db
##数据源信息
dataSources:
  ds_0:
    url: jdbc:mysql://127.0.0.1:3306/course_db_1?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
  ds_1:
    url: jdbc:mysql://127.0.0.1:3306/course_db_2?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50

##数据插入策略
##根据user_id的奇偶性选择数据表，根据order_id选择数据源信息
shardingRule:
  tables:
    t_order:
      actualDataNodes: ds_${0..1}.t_order_${1..2}
      tableStrategy:
        inline:
          shardingColumn: order_id
          algorithmExpression: t_order_${order_id % 2+1}
      keyGenerator:
        type: SNOWFLAKE
        column: order_id

  bindingTables:
    - t_order
  defaultDatabaseStrategy:
    inline:
      shardingColumn: user_id
      algorithmExpression: ds_${user_id % 2}
  defaultTableStrategy:
    none:

使用cmd本地连接，分库测试

3.Sharding-Proxy读写分离

3.1 创建主从服务器

Sharding-Proxy做到的主从复制在于对Proxy服务器进行增删改操作在主服务器，在查询时从从服务器中查询，主从服务器的数据同步需要使用mysql的相关配置，使得主从服务器同步。

3.2 模拟主从服务器

创建三个数据库，一个作为主服务器，两个作为从服务器

3.3 配置相关的信息

schemaName: master_slave_db

dataSources:
  master_ds:
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_master?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
  slave_ds_0:
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_slave_0?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50
  slave_ds_1:
    url: jdbc:mysql://127.0.0.1:3306/demo_ds_slave_1?serverTimezone=UTC&useSSL=false
    username: root
    password: 123
    connectionTimeoutMilliseconds: 30000
    idleTimeoutMilliseconds: 60000
    maxLifetimeMilliseconds: 1800000
    maxPoolSize: 50

masterSlaveRule:
  name: ms_ds
  masterDataSourceName: master_ds
  slaveDataSourceNames:
    - slave_ds_0
    - slave_ds_1

3.4 测试读写分离

在主库与副库中创建表结构，对于mysql配置主从关系后，只需要在主库中配置信息，从库会与主服务器同步。

插入一条记录，并不指定数据库信息，默认插入的位置为主表，查询一条记录默认是从从服务器查询数据。

向两个从表中手动添加数据，模拟查询

insert into demo_ds_slave_0.t_order values(16,12,"a");
insert into demo_ds_slave_0.t_order values(13,19,"is");

3.5模拟查询

四、总结

对于mysql还是想着夸赞一下，第一个是其设计，不知道还有多少知识点在其中，简单的其存储数据、数据持久化、支持事务，mysql开源的软件，还有其底层的数据结构、索引、集群等相关的知识，使得其在互联网行业中不可或缺。

技术没有高低优劣之分，只要在合适的地点、合适的时间能够使用那么就能够发挥重要的作用，学无止境！！！