什么是 ShardingSphere
1、一套开源的分布式数据库中间件解决方案
2、有三个产品：Sharding-JDBC 和 Sharding-Proxy
3、定位为关系型数据库中间件，合理在分布式环境下使用关系型数据库操作

什么是分库分表

Sharding Sphere - 图1
1、数据库数据量不可控的，随着时间和业务发展，造成表里面数据越来越多，如果再去对数 据库表 curd 操作时候，造成性能问题。
2、方案 1：从硬件上
3、方案 2：分库分表
* 为了解决由于数据量过大而造成数据库性能降低问题。

水平分库：库是一样的，表也是相同的 垂直分库： 库是不一样的。垂直分表，分成多个不一样的表

垂直分表，垂直分库都是针对结构发生变化。 水平分库、分表都是按照字段或者数据量进行不同的显示。比如把每一万的数据存到不同表中，把每一万的数据存到不同库中

分库分表的方式

Sharding Sphere - 图2
1、分库分表有两种方式：垂直切分和水平切分
2、垂直切分：垂直分表和垂直分库
3、水平切分：水平分表和水平分库

4、垂直分表
（1）操作数据库中某张表，把这张表中一部分字段数据存到一张新表里面，再把这张表另一 部分字段数据存到另外一张表里面
Sharding Sphere - 图3

5、垂直分库
（1）把单一数据库按照业务进行划分，专库专表
image.png
6、水平分库

Sharding Sphere - 图5
7、水平分表
image.png
分库分表应用和问题

1、应用

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

2、分库分表问题

  1. 跨节点连接查询问题（分页、排序）
  2. 多数据源管理问题

Sharding-JDBC 简介

1、是轻量级的 java 框架，是增强版的 JDBC 驱动
2、Sharding-JDBC
（1）主要目的是：简化对分库分表之后数据相关操作

Sharding Sphere - 图7

Sharding-JDBC 实现水平分表

Sharding Sphere - 图8

1、搭建环境

  1. 技术：SpringBoot 2.2.1+ MyBatisPlus + Sharding-JDBC + Druid 连接池
  2. 创建 SpringBoot 工程
  3. 修改工程 SpringBoot 版本 2.2.1
    1. <parent>
    2.  <groupId>org.springframework.boot</groupId>
    3.  <artifactId>spring-boot-starter-parent</artifactId>
    4.  <version>2.2.1.RELEASE</version>
    5.  <relativePath/> <!-- lookup parent from repository -->
    6. </parent>
    （4）引入需要的依赖
    1. <dependencies>
    2.  <dependency>
    3.    <groupId>org.springframework.boot</groupId>
    4.    <artifactId>spring-boot-starter</artifactId>
    5.  </dependency>
    6.  <dependency>
    7.    <groupId>org.springframework.boot</groupId>
    8.    <artifactId>spring-boot-starter-test</artifactId>
    9.  </dependency>
    10.  <dependency>
    11.    <groupId>com.alibaba</groupId>
    12.    <artifactId>druid-spring-boot-starter</artifactId>
    13.    <version>1.1.20</version>
    14.  </dependency>
    15.  <dependency>
    16.    <groupId>mysql</groupId>
    17.    <artifactId>mysql-connector-java</artifactId>
    18.  </dependency>
    19.  <dependency>
    20.    <groupId>org.apache.shardingsphere</groupId>
    21.    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    22.    <version>4.0.0-RC1</version>
    23.  </dependency>
    24.  <dependency>
    25.    <groupId>com.baomidou</groupId>
    26.    <artifactId>mybatis-plus-boot-starter</artifactId>
    27.    <version>3.0.5</version>
    28.  </dependency>
    29.  <dependency>
    30.    <groupId>org.projectlombok</groupId>
    31.    <artifactId>lombok</artifactId>
    32.  </dependency>
    33. </dependencies>

2、按照水平分表的方式，创建数据库和数据库表

  1. 创建数据库 course_db
  2. 在数据库创建两张表 course_1 和 course_2
  3. 约定规则：如果添加课程 id 是偶数把数据添加 course_1，如果奇数添加到 course_2

Sharding Sphere - 图9Sharding Sphere - 图10
Sharding Sphere - 图11

3、编写代码实现对分库分表后数据的操作

（1）创建实体类，mapper

4、配置 Sharding-JDBC 分片策略

（1）在项目 application.properties 配置文件中进行配置

  1. # shardingjdbc 分片策略 
  2. #配置数据源，给数据源起名称 
  3. spring.shardingsphere.datasource.names=m1 
  4. # 一个实体类对应两张表，覆盖 
  5. spring.main.allow-bean-definition-overriding=true 
  7. #配置数据源具体内容，包含连接池，驱动，地址，用户名和密码
  8. spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource 
  9. spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/course_db? serverTimezone=GMT%2B8 
  10. spring.shardingsphere.datasource.m1.username=root 
  11. spring.shardingsphere.datasource.m1.password=root 
  13. #指定 course 表分布情况，配置表在哪个数据库里面，表名称都是什么 m1.course_1 , m1.course_2 
  14. spring.shardingsphere.sharding.tables.course.actual-data-nodes=m1.course_$->{1..2} 
  16. # 指定 course 表里面主键 cid 生成策略 
  17. SNOWFLAKE spring.shardingsphere.sharding.tables.course.key-generator.column=cid 
  18. #主键生成策略 雪花算法
  19. spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE 
  21. # 指定分片策略 约定 cid 值偶数添加到 course_1 表，如果cid 是奇数添加到 course_2表 
  22. spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding- column=cid 
  23. spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm- expression=course_$->{cid % 2 + 1} 
  25. # 打开 sql 输出日志
  26. spring.shardingsphere.props.sql.show=true

5、编写测试代码@RunWith(SpringRunner.class) @SpringBootTest

  1. public class ShardingjdbcdemoApplicationTests { 
  2.     //注入 mapper 
  3.     @Autowired 
  4.     private CourseMapper courseMapper; 
  5.     //添加课程的方法 
  6.     @Test 
  7.     public void addCourse() { 
  8.             for(int i=1;i<=10;i++) { 
  9.             Course course = new Course(); 
  10.             course.setCname("java"+i); 
  11.             course.setUserId(100L); 
  12.             course.setCstatus("Normal"+i); 
  13.                 courseMapper.insert(course); 
  14.         } 
  15.     } 
  16.     //查询课程的方法 
  17.     @Test 
  18.     public void findCourse() { 
  19.         QueryWrapper<Course> wrapper = new QueryWrapper<>(); 
  20.         wrapper.eq("cid",465114665106538497L); 
  21.         Course course = courseMapper.selectOne(wrapper); 
  22.         System.out.println(course); 
  23.     } 
  24. }

Sharding-JDBC 实现水平分库

1、需求分析

Sharding Sphere - 图12

2、创建数据库和表

Sharding Sphere - 图13

3、在 SpringBoot 配置文件配置数据库分片规则

  1. # shardingjdbc 分片策略
  2. # 配置数据源，给数据源起名称, # 水平分库，配置两个数据源
  3. spring.shardingsphere.datasource.names=m1,m2
  5. # 一个实体类对应两张表，覆盖
  6. spring.main.allow-bean-definition-overriding=true
  8. #配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码
  9. spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
  10. spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
  11. spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8
  12. spring.shardingsphere.datasource.m1.username=root
  13. spring.shardingsphere.datasource.m1.password=root
  15. #配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码
  16. spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource
  17. spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver
  18. spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8
  19. spring.shardingsphere.datasource.m2.username=root
  20. spring.shardingsphere.datasource.m2.password=root
  22. #指定数据库分布情况，数据库里面表分布情况 # m1 m2 course_1 course_2
  23. spring.shardingsphere.sharding.tables.course.actual-data-nodes=m$->{1..2}.course_$->{1..2}
  25. # 指定 course 表里面主键 cid 生成策略 SNOWFLAKE
  26. spring.shardingsphere.sharding.tables.course.key-generator.column=cid
  27. spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE
  29. # 指定表分片策略 约定 cid 值偶数添加到 course_1 表，如果 cid 是奇数添加到course_2 表
  30. spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding-column=cid
  31. spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm-expression=course_$->{cid % 2 + 1}
  33. # 指定数据库分片策略 约定 user_id 是偶数添加 m1，是奇数添加 m2
  34. #spring.shardingsphere.sharding.default-database-strategy.inline.sharding- column=user_id
  35. #spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
  36. spring.shardingsphere.sharding.tables.course.database-strategy.inline.sharding-column=user_id
  37. spring.shardingsphere.sharding.tables.course.database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
  40. # 打开 sql 输出日志
  41. spring.shardingsphere.props.sql.show=true

4、编写测试方法

  1. //======================测试水平分库=====================
  2. //添加操作 
  3. @Test 
  4. public void addCourseDb() { 
  5.     Course course = new Course(); 
  6.     course.setCname("javademo1"); 
  7.     //分库根据 user_id 
  8.     course.setUserId(111L); 
  9.     course.setCstatus("Normal1"); 
  10. courseMapper.insert(course); 
  11. } 
  12. //查询操作 
  13. @Test 
  14. public void findCourseDb() { 
  15.     QueryWrapper<Course> wrapper = new QueryWrapper<>(); 
  16.     //设置 userid 值 
  17.     wrapper.eq("user_id",100L); 
  18.     //设置 cid 值 
  19.     wrapper.eq("cid",465162909769531393L); 
  20.     Course course = courseMapper.selectOne(wrapper); 
  21.     System.out.println(course); 
  22. }

Sharding-JDBC 实现垂直分库

1、需求分析

Sharding Sphere - 图14

2、创建数据库和表

Sharding Sphere - 图15Sharding Sphere - 图16

3、编写操作代码

创建 user 实体类和 mapper

  1. @Data 
  2. @TableName(value = "t_user")
  3. public class User { 
  4.     private Long userId; 
  5.     private String username; 
  6.     private String ustatus; 
  7. }

配置垂直分库策略

  • 在 application.properties 进行配置 ```properties

    shardingjdbc 分片策略

    配置数据源，给数据源起名称, # 水平分库，配置两个数据源

    spring.shardingsphere.datasource.names=m1,m2,m0

一个实体类对应两张表，覆盖

spring.main.allow-bean-definition-overriding=true

配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSourc e

spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8 spring.shardingsphere.datasource.m1.username=root spring.shardingsphere.datasource.m1.password=root

配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8 spring.shardingsphere.datasource.m2.username=root spring.shardingsphere.datasource.m2.password=root

配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?serverTimezone=GMT%2B8 spring.shardingsphere.datasource.m0.username=root spring.shardingsphere.datasource.m0.password=root

配置 user_db 数据库里面 t_user 专库专表

spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user

指定 course 表里面主键 cid 生成策略 SNOWFLAKE

spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE

指定表分片策略 约定 cid 值偶数添加到 course_1 表，如果 cid 是奇数添加到

course_2 表 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

  1. 编写测试代码
  2. ```java
  3. @Autowired 
  4. private UserMapper userMapper; 
  5. //======================测试垂直分库================== 
  6. //添加操作 
  7. @Test 
  8. public void addUserDb() { 
  9.     User user = new User(); 
  10.     user.setUsername("lucy"); 
  11.     user.setUstatus("a"); 
  12.         userMapper.insert(user); 
  13. }

Sharding-JDBC 操作公共表

1、公共表

  1. 存储固定数据的表，表数据很少发生变化，查询时候经常进行关联
  2. 在每个数据库中创建出相同结构公共表

2、在多个数据库都创建相同结构公共表

Sharding Sphere - 图17Sharding Sphere - 图18

3、在项目配置文件 application.properties 进行公共表配置

# 配置公共表

spring.shardingsphere.sharding.broadcast-tables=t_udict spring.shardingsphere.sharding.tables.t_udict.key-generator.column=dictid spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE

4、编写测试代码

  1. 创建新实体类和 mapper

@Data
@TableName(value = “t_udict”) public class Udict {
private Long dictid;
private String ustatus;
private String uvalue;
}

  1. 编写添加和删除方法进行测试
    1. @Autowired 
    2. private UdictMapper udictMapper; 
    3. //======================测试公共表=================== 
    4. //添加操作 
    5. @Test 
    6. public void addDict() { 
    7.  Udict udict = new Udict(); 
    8.  udict.setUstatus("a"); 
    9.  udict.setUvalue("已启用"); 
    10. udictMapper.insert(udict); 
    11. } 
    12. //删除操作 
    13. @Test 
    14. public void deleteDict() { 
    15.  QueryWrapper<Udict> wrapper = new QueryWrapper<>(); 
    16.  //设置 userid 值 
    17.  wrapper.eq("dictid",465191484111454209L); 
    18.  udictMapper.delete(wrapper); 
    19. }

Sharding-JDBC 实现读写分离

Sharding Sphere - 图19Sharding Sphere - 图20
1、读写分离概念
读写分离原理：
Sharding-JDBC 通过 sql 语句语义分析，实现读写分离过程，不会做数据同步
Sharding Sphere - 图21Sharding Sphere - 图22Sharding Sphere - 图23

2、MySQL 配置读写分离
第一步 创建两个 MySQL 数据库服务，并且启动两个 MySQL 服务

  1. 复制之前MySQL 目录
  2. 修改复制之后配置文件
  • 修改端口号，文件路径
  • 需要把数据文件目录再复制一份

Sharding Sphere - 图24Sharding Sphere - 图25Sharding Sphere - 图26Sharding Sphere - 图27Sharding Sphere - 图28

  1. 把复制修改之后从数据库在 windows 安装服务
  • 使用命令： mysqld install mysqls1 —defaults-file=”D:\Program Files\MySQL\MySQL Server-s1\my.ini”

第二步 配置 MySQL 主从服务器

  1. 在主服务器配置文件

[mysqld] #开启日志
log‐bin = mysql‐bin
#设置服务id，主从不能一致
server‐id = 1
#设置需要同步的数据库binlog‐do‐db=user_db #屏蔽系统库同步binlog‐ignore‐db=mysql
binlog‐ignore‐db=information_schema binlog‐ignore‐db=performance_schema

  1. 在从服务器配置文件

[mysqld] #开启日志
log‐bin = mysql‐bin
#设置服务id，主从不能一致
server‐id = 2
Sharding Sphere - 图29Sharding Sphere - 图30Sharding Sphere - 图31
#设置需要同步的数据库replicate_wild_do_table=user_db.% #屏蔽系统库同步
replicate_wild_ignore_table=mysql.% replicate_wild_ignore_table=information_schema.% replicate_wild_ignore_table=performance_schema.%

  1. 把主和从服务器重启

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

第四步 主从数据同步设置
#切换至从库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.000177’, master_log_pos = 107;

启动同步START SLAVE;

查看Slave_IO_Runing和Slave_SQL_Runing字段值都为Yes，表示同步配置成功。如果不为Yes，请排查相关异常。
show slave status
3、Sharding-JDBC 操作
（1）配置读写分离策略
# user_db 从服务器spring.shardingsphere.datasource.s0.type=com.alibaba.druid.pool.DruidDataSourc e
spring.shardingsphere.datasource.s0.driver-class-name=com.mysql.cj.jdbc.Driver spring.shardingsphere.datasource.s0.url=jdbc:mysql://localhost:3307/user_db?se rverTimezone=GMT%2B8
spring.shardingsphere.datasource.s0.username=root

spring.shardingsphere.datasource.s0.password=root

# 主库从库逻辑数据源定义 ds0 为user_db spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source- name=m0
spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source- names=s0

# 配置 user_db 数据库里面 t_user 专库专表#spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user # t_user 分表策略，固定分配至 ds0 的t_user 真实表spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds0.t_user

（2）编写测试代码
//添加操作
@Test
public void addUserDb() {
User user = new User();
user.setUsername(“lucymary”);
user.setUstatus(“a”);
userMapper.insert(user);
}
//查询操作
@Test
public void findUserDb() {
QueryWrapper wrapper = new QueryWrapper<>();
//设置 userid 值
wrapper.eq(“user_id”,465508031619137537L);
User user = userMapper.selectOne(wrapper);
System.out.println(user);
}

Sharding-Proxy 简介

Sharding Sphere - 图32
1、定位为透明的数据库代理端

Sharding Sphere - 图33
2、Sharding-Proxy 独立应用，需要安装服务，进行分库分表或者读写分离配置，启动使用

3、安装

  1. 下载安装软件

Sharding Sphere - 图34

  1. 把下载之后压缩文件，解压，启动 bin 目录启动文件就可以了

Sharding-Proxy 配置（分表）

1、进入 conf 目录，修改文件 server.yaml，打开两段内容注释

Sharding Sphere - 图35Sharding Sphere - 图36Sharding Sphere - 图37Sharding Sphere - 图38

2、进入 conf 目录，修改 config-sharding.yaml

（1）复制 mysql 驱动 jar 包到 lib 目录

Sharding Sphere - 图39

（2）配置分库分表规则
schemaName: sharding_db

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

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

3、启动 Sharding-Proxy 服务
（1）Sharding-Proxy 默认端口号 3307

Sharding Sphere - 图40Sharding Sphere - 图41

Sharding Sphere - 图42

4、通过 Sharding-Proxy 启动端口进行连接

  1. 打开 cmd 窗口连接 Sharding-Proxy，连接方式和连接 mysql 一样的

Sharding Sphere - 图43

  1. 进行 sql 命令操作看到只有一个库
  1. 在 sharding_db 数据库创建表

Sharding Sphere - 图44
Sharding Sphere - 图45

（4）向表添加一条记录
Sharding Sphere - 图46

5、回到本地 3306 端口实际数据库中，看到已经创建好了表和添加数据

Sharding Sphere - 图47Sharding-Proxy 配置（分库）

Sharding Sphere - 图48
1、创建两个数据库

2、找到 conf 目录，config-sharding.yaml
schemaName: sharding_db

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

Sharding Sphere - 图49

Sharding Sphere - 图50
password: root connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50

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

3、启动 Sharding-Proxy 服务
Sharding Sphere - 图51

4、打开 cmd 仓库，连接 Sharding-Proxy 服务

  1. 创建数据库表，向表添加记录

Sharding Sphere - 图52

  1. 连接本地 3306 的 MySql 数据库服务器，表已经创建出来，表里面有数据

Sharding Sphere - 图53

Sharding Sphere - 图54Sharding Sphere - 图55Sharding-Proxy 配置（读写分离）

Sharding Sphere - 图56
1、创建三个数据

2、修改 conf 里面配置文件，config-master-slave.yaml

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: root 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
Sharding Sphere - 图57Sharding Sphere - 图58Sharding Sphere - 图59
password: root 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: root connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50

masterSlaveRule:
Sharding Sphere - 图60name: ms_ds masterDataSourceName: master_ds slaveDataSourceNames:

  • slave_ds_0
  • slave_ds_1

3、启动 Sharding-Proxy 服务

4、通过 cmd 连接 Sharding-Proxy，进行创建表和添加记录操作

  1. 在主数据库和从数据库里面，都创建数据库表
  1. 向表添加记录，不指定向哪个库添加
  • 把添加数据添加到主数据库里面

Sharding Sphere - 图61
Sharding Sphere - 图62

（3）查询数据库表数据，不指定查询哪个库
* 直接执行查询从库里面的数据

Sharding Sphere - 图63课程总结

一、基本概念
1、什么是 Sharding Sphere 2、什么是分库分表
（1）水平切分和垂直切分

二、Sharding-JDBC
1、什么是 Sharding-JDBC
2、使用 Sharding-JDBC 水平切分3 、使用 Sharding-JDBC 垂直切分4 、使用 Sharding-JDBC 操作公共表
5、使用使用 Sharding-JDBC 读写分离

三、Sharding-Proxy
1、什么是 Sharding-Proxy
2、使用 Sharding-Proxy 分库分表
3、使用 Sharding-Proxy 读写分离