- 开源的分布式数据库中间件解决方案有三个产品 Sharding-JDBC、Sharding-Proxy、Proxy-Sidecar定义为关系型数据库中间件，合理在分布式环境下使用关系型数据库操作
1.2 分库分表 1.2.1 为什么要分库分表？Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。 它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。
问题引入：
电商平台，关系型数据库存有商品表、店铺表。随着业务量不断增加，数据库中数据不断增多，表中 数据量也会越来越大，再做增删改查操作时，性能会受到影响。
数据库数量不可控，业务随着时间发展，造成表的数据越来越多，如果再去对数据库表 crud 操作时候，造成性能问题。
解决方案：
- 从硬件上解决（无法从根本上解决问题）分库分表处理
分库分表：为了解决由于数据量过大而造成数据库性能降低问题，对数据库、数据表进行拆分。
数据库拆分
为商品建立DB（表拆分）
商品表1商品表2 为商家建立DB（表拆分）
商家表1商家表2
1.2.3 分库分表的方式 1）垂直切分 ① 垂直分表（按 “字段” 分割）将原数据表中的数据，按照 字段 分配至多个新表。
优点：
- 基本信息、扩展信息分离查询，减少I/O量基本信息、扩展信息分离修改，无需锁定整张表
分表后，多张信息表在同一数据库中，数据库I/O量增加，压力增大，需进行分库处理。
② 垂直分库（按 “业务” 划分）把单一的数据库，按照业务进行划分，做到专库专用。
2）水平切分按一定数据规模对数据库/表进行切分（eg. 10000条数据）
① 水平分库保留数据库表结构，并按照一定判定原则 (取模)，对数据库进行拆分。
数据库拆分数据过多，会导致难以维护，所以我们在进一步分割时，应对数据表进行分割。
② 水平分表保留数据表结构，并按照一定判定原则 (取模)，对同一数据库的数据表进行叠复。
1.2.4 分库分表应用- 在数据库设计时，考虑垂直分库/分表。随着数据库数据量增加，不要马上考虑做水平切分，首先考虑缓存处理、读写分离、索引等。若无法根本解决问题，再考虑做水平分库/分表。
- 跨节点连接查询问题（分页、排序）
- 多数据源管理问题
轻量级Java框架，增强版的JDBC驱动
Sharding-JDBC并不做分库分表操作，而是操作已经完成分库分表的数据库。
主要功能：数据分片、读写分离
主要目的：简化对分库分表之后数据的操作
轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。
适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC；支持任何第三方的数据库连接池，如：Druid, DBCP, C3P0 , HikariCP 等；支持任意实现 JDBC 规范的数据库，目前支持 MySQL，PostgreSQL，Oracle，SQLServer 以及任何可使用 JDBC 访问的数据库。
2.2 搭建环境 2.3 水平分表 2.3.1 搭建环境SpringBoot + MyBatisPlus + Sharding-JDBC + Druid 连接池
① 引入依赖：② 按照水平分表方式，创建数据库/表org.springframework.boot spring-boot-starter-parent 2.5.8 org.springframework.boot spring-boot-starter com.alibaba druid-spring-boot-starter 1.2.6 mysql mysql-connector-java 8.0.26 com.baomidou mybatis-plus-boot-starter 3.4.2 org.apache.shardingsphere sharding-jdbc-spring-boot-starter 4.0.0-RC1 org.projectlombok lombok 1.18.20 org.springframework.boot spring-boot-starter-test test
创建数据库 commodity_db
在数据库中创建两张表 commodity_tab_1、commodity_tab_2
约定规则：id -> 偶数 commodity_tab_1、奇数 commodity_tab_2
CREATE DATAbase IF NOT EXISTS `commodity_db` CHARACTER SET utf8mb4; USE `commodity_db`; CREATE TABLE commodity_tab_1 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL ); CREATE TABLE commodity_tab_2 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL );③ 编写代码实现对分库分表数据的操作
项目结构：
实体类Commodity：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Commodity {
@TableId("commodity_id")
private Long id;
@TableField("commodity_name")
private String name;
@TableField("commodity_user_id")
private Long userID;
@TableField("commodity_status")
private String status;
}
映射接口ICommodityMapper：
@Repository public interface ICommodityMapper extends baseMapper{ }
main方法：
@MapperScan("com.ljw.shardingjdbcdemo.mapper")
@SpringBootApplication
public class ShardingJdbcDemoApplication {
public static void main(String[] args) {
SpringApplication.run(ShardingJdbcDemoApplication.class, args);
}
}
④ 配置 Sharding-JDBC 分片策略
官网 - 分片策略
行表达式 $->{…}行表达式：
一种特殊的表达式，用于在 Sharding-JDBC 中配置分片策略花括号中可填入数字，代表分片在名称上的区别。
（eg. xx_$->{1…2} 代表，名称为xx_1 / xx_2 的数据库/表）
在项目 applicaiton.properties 中配置：
完整配置：
# 允许一个实体类对应两张表 (覆盖)
spring.main.allow-bean-definition-overriding=true
# Sharing-JDBC分片策略
# 配置数据源起别名
spring.shardingsphere.datasource.names=d1
# 配置数据源具体内容，包含连接池、驱动、地址、用户名、密码 (使用 Mybatis Plus 可更换为 HikariCP)
spring.shardingsphere.datasource.d1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.d1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.d1.url=jdbc:mysql://[ip地址]:3306/commodity_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
spring.shardingsphere.datasource.d1.username=root
spring.shardingsphere.datasource.d1.password=123
# 指定 commodity 表的分布情况，配置 表的位置、名称(commodity表示规则) course_tab_1 course_tab_2
spring.shardingsphere.sharding.tables.commodity.actual-data-nodes=d1.course_tab_$->{1..2}
# 指定 commodity 表里主键生成策略(commodity表示规则) SNOWFLAKE(❄雪花算法：生成随机唯一ID策略)
spring.shardingsphere.sharding.tables.commodity.key-generator.column=commodity_id
spring.shardingsphere.sharding.tables.commodity.key-generator.type=SNOWFLAKE
# 指定分片策略 约定 commodity_id：偶数 -> commodity_tab_1 / 奇数 -> commodity_tab_2
spring.shardingsphere.sharding.tables.commodity.table-strategy.inline.sharding-column=commodity_id
spring.shardingsphere.sharding.tables.commodity.table-strategy.inline.algorithm-expression=commodity_tab_$->{commodity_id % 2 + 1}
# 打开SQL输出日志
spring.shardingsphere.props.sql.show=true
※ 【可能出现的问题】
< 1 > Sharding JDBC 版本过高
版本号的问题：更改为 4.0.0-RC1就不会出现这个错误
< 2 > 允许一个实体类对应两张表在 application.properties 增加一行配置就可以解决：
解决一个实体类无法对应两张表，做一个覆盖操作
# 允许一个实体类对应两张表 (覆盖) spring.main.allow-bean-definition-overriding=true< 3 > JDK 版本 ＞ 8
由于JDK 版本过高 (version＞ 8)，会导致以下错误：
java.lang.ClassNotFoundException: javax.xml.bind.JAXBException
错误分析：
JAXB API是java EE 的API，因此在java SE 9.0 中不再包含这个 Jar 包。
java 9 中引入了模块的概念，默认情况下，Java SE中将不再包含java EE 的Jar包
而在 java 6/7 / 8 时关于这个API 都是捆绑在一起的
两种解决方案：
降低JDK 9 版本到 JDK 1.8
手动/Maven/Gradle 加入这些依赖Jar包
手动导入 Jar包
Maven项目添加如下依赖：
javax.xml.bind jaxb-api 2.3.0 com.sun.xml.bind jaxb-impl 2.3.0 com.sun.xml.bind jaxb-core 2.3.0 javax.activation activation 1.1.1
Gradle项目添加如下依赖：
dependencies {
// JAX-B dependencies for JDK 9+
implementation "javax.xml.bind:jaxb-api:2.3.0"
implementation "com.sun.xml.bind:jaxb-core:2.3.0"
implementation "com.sun.xml.bind:jaxb-impl:2.3.0"
implementation "javax.activation:activation:1.1.1"
}
主键生成策略
sharding-jdbc提供了两种主键生成策略UUID、SNOWFLAKE。
默认使用SNOWFLAKE，还抽离出分布式主键生成器的接口org.apache.shardingsphere.spi.keygen.ShardingKeyGenerator，方便用户自行实现自定义的自增主键生成器。
public class SimpleShardingKeyGenerator implements ShardingKeyGenerator {
private AtomicLong atomic = new AtomicLong(0);
@Getter
@Setter
private Properties properties = new Properties();
@Override
public Comparable generateKey() {
return atomic.incrementAndGet();
}
@Override
public String getType() {
//声明类型
return "SIMPLE";
}
}
2.3.3 最终测试
① 添加商品
测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private ICommodityMapper commodityMapper;
// 添加课程的方法
@Test
public void addCommodities() {
for (int i = 0; i < 10; i++) {
Commodity commodity = new Commodity(
null,
"Game" + i,
100L,
"Normal");
commodityMapper.insert(commodity);
}
}
}
测试结果：
通过测试
数据表
② 查询商品测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private ICommodityMapper commodityMapper;
// 查询课程的方法——主键PK
@Test
public void findCommodities(){
// 条件构造器
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.eq("commodity_id",1479727385778626561L);
// wrapper.eq("commodity_id",1479727383027163138L);
// 查询
Commodity commodity = commodityMapper.selectOne(wrapper);
// 打印
System.out.println(commodity);
}
}
测试结果：
查询非策略相关字段，无论表 顺序先后，总会遍历所有表：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private ICommodityMapper commodityMapper;
// 查询课程的方法——非主键
@Test
public void findCommodities(){
// 条件构造器
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.eq("commodity_name","Game2"); // commodity_tab_2
// wrapper.eq("commodity_name","Game0"); // commodity_tab_1
// 查询
Commodity commodity = commodityMapper.selectOne(wrapper);
// 打印
System.out.println(commodity);
}
}
2.4 水平分库
约定规则：
- 数据库：user_id：偶数，数据添加至commodity_db_1库；奇数，数据添加至commodity_db_2库。数据表：commodity_id：偶数，数据添加至commodity_tab_1表；奇数，数据添加至commodity_tab_2表。
由于前面已经导入依赖，并创建项目，我们将在以前的基础上，对配置进行重构，所以步骤调整至两步。
① 按照为分库分表方式，创建数据库创建 commodity_db_1 数据库：
CREATE DATAbase IF NOT EXISTS `commodity_db_1` CHARACTER SET utf8mb4; USE `commodity_db`; CREATE TABLE commodity_tab_1 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL ); CREATE TABLE commodity_tab_2 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL );
创建 commodity_db_2 数据库：
CREATE DATAbase IF NOT EXISTS `commodity_db_2` CHARACTER SET utf8mb4; USE `commodity_db`; CREATE TABLE commodity_tab_1 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL ); CREATE TABLE commodity_tab_2 ( commodity_id BIGINT(20) PRIMARY KEY, commodity_name VARCHAR(20) NOT NULL, commodity_user_id BIGINT(20) NOT NULL, commodity_status VARCHAR(10) NOT NULL );② 配置 Sharding-JDBC 分片策略
# 一个实体类对应两张表 (覆盖)
spring.main.allow-bean-definition-overriding=true
# Sharing-JDBC分片策略
# 配置数据源起别名：水平分库，两个数据源
spring.shardingsphere.datasource.names=d1,d2
# 配置第1个数据源：具体内容，包含连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.d1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.d1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.d1.url=jdbc:mysql://192.168.1.132:3306/commodity_db_1?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
spring.shardingsphere.datasource.d1.username=root
spring.shardingsphere.datasource.d1.password=123
# 配置第2个数据源：具体内容，包含连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.d2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.d2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.d2.url=jdbc:mysql://192.168.1.132:3306/commodity_db_2?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
spring.shardingsphere.datasource.d2.username=root
spring.shardingsphere.datasource.d2.password=123
# 指定 commodity 数据库、数据表的分布情况，配置 库/表的位置、名称(commodity表示规则) course_tab_1 course_tab_2
# d1 d2 commodity_db_1 commodity_db_2
spring.shardingsphere.sharding.tables.commodity.actual-data-nodes=d$->{1..2}.commodity_tab_$->{1..2}
# 指定 commodity 表里主键生成策略(commodity表示规则) SNOWFLAKE(❄雪花算法：生成随机唯一ID策略)
spring.shardingsphere.sharding.tables.commodity.key-generator.column=commodity_id
spring.shardingsphere.sharding.tables.commodity.key-generator.type=SNOWFLAKE
# [两种方法]指定数据库分片策略 约定 commodity_user_id：偶数 -> d1(commodity_db_1) / 奇数 -> d2(commodity_db_2)
#1、 针对数据库中所有表
#spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=commodity_user_id
#spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=d$->{commodity_user_id % 2 + 1}
#2、 针对数据库中 commodity 相关表
spring.shardingsphere.sharding.tables.commodity.database-strategy.inline.sharding-column=commodity_user_id
spring.shardingsphere.sharding.tables.commodity.database-strategy.inline.algorithm-expression=d$->{commodity_user_id % 2 + 1}
# 指定数据表分片策略 约定 commodity_id：偶数 -> commodity_tab_1 / 奇数 -> commodity_tab_2
spring.shardingsphere.sharding.tables.commodity.table-strategy.inline.sharding-column=commodity_id
spring.shardingsphere.sharding.tables.commodity.table-strategy.inline.algorithm-expression=commodity_tab_$->{commodity_id % 2 + 1}
# 打开SQL输出日志
spring.shardingsphere.props.sql.show=true
2.4.2 最终测试
① 添加商品
测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private ICommodityMapper commodityMapper;
// 添加课程的方法
@Test
public void addCommodities() {
for (int i = 0; i < 10; i++) {
Commodity commodity = new Commodity(
null,
"Game" + i,
100L + i,
"Normal");
commodityMapper.insert(commodity);
}
}
}
测试结果：
通过测试：
数据表：
② 查询商品测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private ICommodityMapper commodityMapper;
// 查询课程的方法
@Test
public void findCommodities(){
// 条件构造器
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.eq("commodity_id",1479791523850661890L);
wrapper.eq("commodity_user_id",101L);
Commodity commodity = commodityMapper.selectOne(wrapper);
System.out.println(commodity);
}
}
测试结果：
根据业务，进行垂直分库，做到专库专表
2.5.2 创建数据库按照垂直分库方式，创建数据库user_db：
CREATE DATAbase IF NOT EXISTS `user_db` CHARACTER SET utf8mb4; USE `user_db`; CREATE TABLE user_tab ( user_id BIGINT(20) PRIMARY KEY, user_name VARCHAR(20) NOT NULL, user_status VARCHAR(10) NOT NULL );2.5.3 编写代码
实体类User：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
@TableId("user_id")
private Long id;
@TableField("user_username")
private String username;
@TableField("user_status")
private String status;
}
映射接口IUserMapper：
@Repository public interface IUserMapper extends baseMapper2.5.4 配置属性{ }
在 application.properties中进行配置：
# 一个实体类对应两张表 (覆盖)
spring.main.allow-bean-definition-overriding=true
# Sharing-JDBC分片策略
# 配置数据源起别名：水平分库，两个数据源
spring.shardingsphere.datasource.names=d5
# 配置第3个数据源：具体内容，包含连接池、驱动、地址、用户名、密码
spring.shardingsphere.datasource.d5.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.d5.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.d5.url=jdbc:mysql://192.168.1.132:3306/user_db?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
spring.shardingsphere.datasource.d5.username=root
spring.shardingsphere.datasource.d5.password=123
# 配置垂直分库：专库专表 user_db : user_tab(user表示规则)
spring.shardingsphere.sharding.tables.user.actual-data-nodes=d$->{5}.user_tab
# 指定 user 表里主键生成策略(user表示规则) SNOWFLAKE(❄雪花算法：生成随机唯一ID策略)
spring.shardingsphere.sharding.tables.user.key-generator.column=user_id
spring.shardingsphere.sharding.tables.user.key-generator.type=SNOWFLAKE
# 针对 user 指定数据表、字段
spring.shardingsphere.sharding.tables.user.table-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.user.table-strategy.inline.algorithm-expression=user_tab
2.5.5 最终测试
① 添加用户
测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private IUserMapper userMapper;
// 添加用户的方法
@Test
public void addUsers() {
User user = new User(
null,
"Mike",
"Normal"
);
userMapper.insert(user);
}
}
测试结果：
测试成功：
数据库：
② 查询用户测试类：
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class ShardingJdbcDemoApplicationTests {
// 注入Mapper
@Autowired
private IUserMapper userMapper;
@Test
// 查询用户的方法
public void findUsers() {
// 条件构造器
QueryWrapper wrapper = new QueryWrapper<>();
wrapper.eq("user_id", 1479815887484628993L);
User user = userMapper.selectOne(wrapper);
System.out.println(user);
}
}
测试结果：
2.6 公共表 — 广播公共表：
存储固定数据的表，表数据很少发生变化，查询时候经常进行关联在每个数据库中创建出相同结构公共表 2.6.1 创建公共表
在3个数据库中，分别创建公共表 dict_tab：
CREATE TABLE dict_tab (
dict_id BIGINT(20) PRIMARY KEY,
dict_status VARCHAR(100) NOT NULL,
dict_value VARCHAR(100) NOT NULL
)
2.6.2 配置属性
在 application.properties 配置文件中添加以下属性：
# 配置公共表 spring.shardingsphere.sharding.broadcast-tables=dict_tab # 指定 dict 表里主键生成策略(dict表示规则) SNOWFLAKE(❄雪花算法：生成随机唯一ID策略) spring.shardingsphere.sharding.dict.user.key-generator.column=dict_id spring.shardingsphere.sharding.dict.user.key-generator.type=SNOWFLAKE # 针对 dict 指定数据表、字段 spring.shardingsphere.sharding.dict.user.table-strategy.inline.sharding-column=dict_id spring.shardingsphere.sharding.dict.user.table-strategy.inline.algorithm-expression=dict_tab2.6.4 编写代码
实体类 Dict：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dict {
@TableId("dict_id")
private Long id;
@TableField("dict_status")
private String status;
@TableField("dict_value")
private String value;
}
映射接口 IDictMapper：
@Repository public interface IDictMapper extends baseMapper2.6.5 最终测试{ }
注入Mapper：
// 注入Mapper @Autowired private IDictMapper dictMapper;① 添加操作
测试方法：
// 添加操作
@Test
public void addDictByBroadcast() {
for (int i = 0; i < 3; i++) {
Dict dict = new Dict(
null,
"Normal",
"value" + i
);
dictMapper.insert(dict);
}
}
※【可能出现的问题】
出现这个问题的原因：我们既没有在 配置文件(application.properties) 中指定表名称，也没有在实体类上加注解标注 表名称。
而公共表，因采用广播模式，所有数据源参与CRUD操作，故无法确定数据源，因在实体类上指定标表名称。
解决方法：
在实体类上加上注解@TableName("dict_tab")
测试结果：
测试成功
数据库
② 删除操作测试方法：
// 删除操作
@Test
public void deleteDictByBroadcast() {
dictMapper.deleteById(1479833059674099714L);
}
测试结果：
测试成功
数据库
2.7 主从复制 - 读写分离 2.7.1 概述读写分离：
为了确保数据库产品的稳定性，很多数据库拥有双击热备功能。即，第一台数据库服务器，是对外提供增删改业务的生产服务器，第二胎数据库服务器，主要进行读操作。
原理：
让主数据库（master）处理事务性 增、删、改 操作，而从数据库（slave）处理 查 操作。
以MySQL 数据库服务器为例
原理图：
2.7.2 主从复制主从复制，需要准备至少 两台MySQL 服务器（一主一从），主服务器开启 Binary Log 功能，并进行相关配置；主服务器每次对数据操作都会更新 Binary Log 日志文件。从服务器通过实时监控主服务器 更新 Binary Log。
※ 参数详解MySQL主从配置 (一主一从)
2.7.3 读写分离Sharding-JDBC 通过语句语义分析，实现读写分离过程。
Sharding-JDBC 原理：
通过 路由 将不同操作 (CRUD) 指向 不同的MySQL服务器（Master：增删改、Slave：查）。 3. Sharding-Proxy
透明化的数据库代理端，提供封装了数据库二进制协议的服务端版本，用于完成对异构语言的支持。
目前支持 MySQL 和 PostgreSQL（兼容 openGauss 等基于 PostgreSQL 的数据库）版本。
向应用程序完全透明，可直接当做 MySQL/PostgreSQL 使用；适用于任何兼容 MySQL/PostgreSQL 协议的的客户端。
3.1 安装下载安装软件：
在Windows中直接两步解压 (7-zip)，可能会出现lib目录下jar包名称不全问题：
Windows 解决方案：安装tar for windows（GnuWin32），并将bin目录 配置Path环境变量：
下载地址：http://gnuwin32.sourceforge.net/packages/gtar.htm
Linux系统 tar -xvf直接解压，这里建议在Linux 系统解压后，使用FTP工具传回Windows 即可。
解压压缩文件，完成配置后 启动bin目录 start.bat (win)/start.sh (linux) 文件（JVM GC方式有变动，请使用 JER 1.8 版本）:
进入conf目录，修改server.yaml文件（去除注释 + 修改配置）：
rules:
- !AUTHORITY
users:
- root@%:root
- sharding@:sharding
provider:
type: ALL_PRIVILEGES_PERMITTED
- !TRANSACTION
defaultType: XA
providerType: Atomikos
props:
max-connections-size-per-query: 1
kernel-executor-size: 16 # Infinite by default.
proxy-frontend-flush-threshold: 128 # The default value is 128.
proxy-opentracing-enabled: false
proxy-hint-enabled: false
sql-show: false
check-table-metadata-enabled: false
show-process-list-enabled: false
# Proxy backend query fetch size. A larger value may increase the memory usage of ShardingSphere Proxy.
# The default value is -1, which means set the minimum value for different JDBC drivers.
proxy-backend-query-fetch-size: -1
check-duplicate-table-enabled: false
sql-comment-parse-enabled: false
proxy-frontend-executor-size: 0 # Proxy frontend executor size. The default value is 0, which means let Netty decide.
# Available options of proxy backend executor suitable: OLAP(default), OLTP. The OLTP option may reduce time cost of writing packets to client, but it may increase the latency of SQL execution
# if client connections are more than proxy-frontend-netty-executor-size, especially executing slow SQL.
proxy-backend-executor-suitable: OLAP
proxy-frontend-max-connections: 0 # Less than or equal to 0 means no limitation.
sql-federation-enabled: false
进入conf目录，修改conf-sharding.yaml文件（去除注释 + 修改配置），并将MySQL驱动jar包复制到 lib 目录。
######################################################################################################
#
# If you want to connect to MySQL, you should manually copy MySQL driver to lib directory.
#
######################################################################################################
schemaName: sharding_db
dataSources:
ds_0:
url: jdbc:mysql://127.0.0.1:3306/demo_ds_0?serverTimezone=UTC&useSSL=false
username: root
password:
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
ds_1:
url: jdbc:mysql://127.0.0.1:3306/demo_ds_1?serverTimezone=UTC&useSSL=false
username: root
password:
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
minPoolSize: 1
rules:
- !SHARDING
tables:
t_order:
actualDataNodes: ds_${0..1}.t_order_${0..1}
tableStrategy:
standard:
shardingColumn: order_id
shardingAlgorithmName: t_order_inline
keyGenerateStrategy:
column: order_id
keyGeneratorName: snowflake
t_order_item:
actualDataNodes: ds_${0..1}.t_order_item_${0..1}
tableStrategy:
standard:
shardingColumn: order_id
shardingAlgorithmName: t_order_item_inline
keyGenerateStrategy:
column: order_item_id
keyGeneratorName: snowflake
bindingTables:
- t_order,t_order_item
defaultDatabaseStrategy:
standard:
shardingColumn: user_id
shardingAlgorithmName: database_inline
defaultTableStrategy:
none:
shardingAlgorithms:
database_inline:
type: INLINE
props:
algorithm-expression: ds_${user_id % 2}
t_order_inline:
type: INLINE
props:
algorithm-expression: t_order_${order_id % 2}
t_order_item_inline:
type: INLINE
props:
algorithm-expression: t_order_item_${order_id % 2}
keyGenerators:
snowflake:
type: SNOWFLAKE
props:
worker-id: 123
以上配置文件的修改与 Sharding JDBC 相类似。
3.3 启动服务- 通过设定不同的配置，启动 Sharding-Proxy 操作 MySQL 数据库即可完成分库、分表操作。在 MySQL Cli 中连接，创建数据表，向表中添加记录即可。
