ShardingSphere分库分表

向右看齐 2022-09-03 13:11 212阅读 0赞

ShardingSphere官方文档：[https://shardingsphere.apache.org/document/current/cn/overview/][https_shardingsphere.apache.org_document_current_cn_overview]

*  [ShardingSphere-JDBC][]：客户端代理
 *  [ShardingSphere-Proxy][]：服务端代理

# ShardingSphere-JDBC #

增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架，客户端代理。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70][]

Sharding-JDBC数据分片工作流程

![20210816181848188.png][]

## ShardingSphere实现思想 ##

>>配置数据源集合

>>配置分片规则

>>针对数据库分片

>>针对表分片

>>配置分片键

>>配置分片算法

>>全局唯一id问题

## 分布式序列算法（全局唯一id） ##

### UUID ###

简单，但是一般不会使用，因为生成的是String类型的无序的字符串，查询效率低

UUID.randomUUID().toString();

### 雪花算法（SNOWFLAKE） ###

64位长度的long类型的整数

![20210814094151308.png][]

第一位是符号位，0表示正数，1表示负数

41位是存储时间戳：当前系统时间毫秒数-开始时间毫秒数

10位工作机器id：可以记录哪个机房哪个机器生成的

12位存储序列号：当前时间当前机器上的递增序列

可配置属性：

<table> 
 <thead> 
  <tr> 
   <th><em>属性名称</em></th> 
   <th><em>数据类型</em></th> 
   <th><em>说明</em></th> 
   <th><em>默认值</em></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>worker-id (?)</td> 
   <td>long</td> 
   <td>工作机器唯一标识</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>max-vibration-offset (?)</td> 
   <td>int</td> 
   <td>最大抖动上限值，范围[0, 4096)。注：若使用此算法生成值作分片值，建议配置此属性。此算法在不同毫秒内所生成的 key 取模 2^n (2^n一般为分库或分表数) 之后结果总为 0 或 1。为防止上述分片问题，建议将此属性值配置为 (2^n)-1</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>max-tolerate-time-difference-milliseconds (?)</td> 
   <td>long</td> 
   <td>最大容忍时钟回退时间，单位：毫秒</td> 
   <td>10 毫秒</td> 
  </tr> 
 </tbody> 
</table>

## 数据分片实现 ##

### 使用Java API ###

引入maven依赖

<dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-core</artifactId>
        <version>${latest.release.version}</version>
    </dependency>

数据源工具类

public class DataSourceUtil {
        private static final String HOST = "192.168.2.101";
        private static final int POST =3306;
        private static final String USER_NAME = "root";
        private static final String PWD = "root";
        public static DataSource createDatasource(String dataSourceName) {
            HikariDataSource hikariDataSource = new HikariDataSource();
            hikariDataSource.setDriverClassName("com.mysql.jdbc.Driver");
            hikariDataSource.setJdbcUrl(String.format("jdbc:mysql://%s:%s/%s?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8", HOST, POST, dataSourceName));
            hikariDataSource.setUsername(USER_NAME);
            hikariDataSource.setPassword(PWD);
            return hikariDataSource;
        }
    }

数据库分库分表配置

public class ShardingDbAndTableConfiguration {
        private static Map<String, DataSource> createDataSourceMap() {
            Map<String, DataSource> dataSourceMap = new HashedMap<>();
            dataSourceMap.put("ds0", DataSourceUtil.createDatasource("shard01"));
            dataSourceMap.put("ds1", DataSourceUtil.createDatasource("shard02"));
            return dataSourceMap;
        }
    
        private static ShardingRuleConfiguration createShardingRuleConfiguration() {
            ShardingTableRuleConfiguration tableRuleConfiguration = new ShardingTableRuleConfiguration("t_order", "ds${0..1}.t_order${0..1}");
    
            ShardingRuleConfiguration ruleConfiguration = new ShardingRuleConfiguration();
            ruleConfiguration.getTables().add(tableRuleConfiguration);
    
            // 配置分库策略:设置分片键，分片算法
            ruleConfiguration.setDefaultDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("user_id", "dbShardingAlgorithm"));
            // 配置分库算法
            Properties dbShardingAlgorithmProps = new Properties();
            dbShardingAlgorithmProps.setProperty("algorithm-expression", "ds${user_id % 2}");
            ruleConfiguration.getShardingAlgorithms().put("dbShardingAlgorithm", new ShardingSphereAlgorithmConfiguration("INLINE", dbShardingAlgorithmProps));
    
            // 配置分表策略
            ruleConfiguration.setDefaultTableShardingStrategy(new StandardShardingStrategyConfiguration("order_id", "tableShardingAlgorithm"));
            // 配置分表算法
            Properties tableShardingAlgorithmProps = new Properties();
            tableShardingAlgorithmProps.setProperty("algorithm-expression", "t_order${order_id % 2}");
            ruleConfiguration.getShardingAlgorithms().put("tableShardingAlgorithm", new ShardingSphereAlgorithmConfiguration("INLINE", tableShardingAlgorithmProps));
    
            // 设置分布式全局唯一键规则
            ruleConfiguration.setDefaultKeyGenerateStrategy(new KeyGenerateStrategyConfiguration("order_id", "snowflake"));
            Properties keyGeneratorAlgorithmProps = new Properties();
            keyGeneratorAlgorithmProps.setProperty("worker-id", "123");
            ruleConfiguration.getKeyGenerators().put("snowflake", new ShardingSphereAlgorithmConfiguration("SNOWFLAKE", keyGeneratorAlgorithmProps));
            return ruleConfiguration;
        }
    
        public static DataSource getDatasource() throws SQLException {
            return ShardingSphereDataSourceFactory.createDataSource(createDataSourceMap(), Collections.singleton(createShardingRuleConfiguration()), new Properties());
        }
    }

### 使用SpringBoot方式配置 ###

# 配置真实数据源
    spring.shardingsphere.datasource.names=ds0,ds1
    spring.shardingsphere.datasource.common.type=com.zaxxer.hikari.HikariDataSource
    spring.shardingsphere.datasource.common.driver-class-name=com.mysql.jdbc.Driver
    
    # 配置第 1 个数据源
    spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://localhost:3306/ds0
    spring.shardingsphere.datasource.ds0.username=root
    spring.shardingsphere.datasource.ds0.password=root
    
    # 配置第 2 个数据源
    spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://localhost:3306/ds1
    spring.shardingsphere.datasource.ds1.username=root
    spring.shardingsphere.datasource.ds1.password=root
    
    # 配置 t_order 表规则
    spring.shardingsphere.rules.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order$->{0..1}
    
    # 配置分库策略
    spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id
    spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name=database_inline
    
    # 配置分表策略
    spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-column=order_id
    spring.shardingsphere.rules.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=table_inline
    
    # 配置全局唯一id生成策略：雪花算法
    spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.column=order_id
    spring.shardingsphere.rules.sharding.tables.t_order.key-generate-strategy.key-generator-name=snowflake
    
    # 配置 分片算法
    spring.shardingsphere.rules.sharding.sharding-algorithms.database_inline.type=INLINE
    spring.shardingsphere.rules.sharding.sharding-algorithms.database_inline.props.algorithm-expression=ds${user_id % 2}
    spring.shardingsphere.rules.sharding.sharding-algorithms.table_inline.type=INLINE
    spring.shardingsphere.rules.sharding.sharding-algorithms.table_inline.props.algorithm-expression=t_order${order_id % 2}
    
    spring.shardingsphere.rules.sharding.key-generators.snowflake.type=SNOWFLAKE
    spring.shardingsphere.rules.sharding.key-generators.snowflake.props.worker-id=123

通过@Resource注解使用ShardingSphereDataSource

@Resource
    private DataSource dataSource;

## 不同表概念 ##

上面代码示例应用的是逻辑表，还有广播表，绑定表

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 1][]

**逻辑表**：sql语句中使用的是逻辑表（如t\_order），不是真实表名，Sharding-JDBC会解析sql语句，拿到逻辑表名，然后根据设置的分片策略，拿到真实表名（如ds0.t\_order1）

**广播表**：一个表在每个数据库都存在，在数据更新时需要通过广播的方式对每个库的表都更新，一般用于字典数据表

**绑定表**：两个表绑定在一起，当一个表的一条数据更新到某个库中，关联绑定的另一个表的级联数据也需要更新到相同的数据库中

# 配置绑定表
    spring.shardingsphere.rules.sharding.binding-tables=t_order,t_order_detail
    
    # 如果有多个绑定表
    spring.shardingsphere.rules.sharding.binding-tables[0]=t_order,t_order_detail
    spring.shardingsphere.rules.sharding.binding-tables[1]=t_user,t_user_info

## 算法 ##

分片算法：针对数据库分库分表配置的一些算法

分布式序列算法：生成全局唯一id；有UUID、雪花算法snowflake

负载均衡算法：读写分离时，如果有多个写节点库，需要采用负载均衡算法去选择一个库做写数据操作；提供有轮询算法、随机访问算法

加密算法：对表的敏感字段进行数据加密；提供的有MD5、AES、RC4加密算法

# SPI（动态扩展机制） #

很多常用应用都用到了SPI

*  JDBC Driver（Java原生SPI）
 *  Dubbo（Dubbo自己实现的一个SPI）
 *  Spring（Spring自己实现的一个SPI）
 *  Sentinel
 *  ShardingSphere

### 如何实现SPI ###

*  必须有个META-INF/services的目录
 *  扩展类全路径名作为文件名
 *  文件内容填写自定义类全路径名
 *  自定义扩展类必须实现扩展接口

![2021081418362428.png][]

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
        public Driver() throws SQLException {}
        // ......
    }

## 读写分离 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 2][]

### 作用 ###

1.  可对数据库读节点水平扩容，降低数据库节点压力，提升查询效率
2.  减少排他锁和共享锁的竞争
3.  可根据不同功能选择不同数据库引擎；针对写操作节点，需要用到事务，可以选择InnoDB引擎；针对于读操作节点，查询不需要事务，可以使用MyISAM引擎

### 主从模式 ###

一主多从、级联同步、双主热备、多主一从，具体可参照Redis文档中相关内容

### Mysql读写分离 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 3][]

客户端写入数据到master节点时，会记录修改到bin log中；slave节点向master发起同步请求，master返回bin log文件，slave节点有一个I/O线程将bin log写入到relay log中，然后读取log中的sql语句，在本地通过一个SQL线程执行sql语句完成数据更新

### Mysql读写分离配置 ###

master节点开启binlog日志，mysql默认不开启binlog，修改/etc/my.cnf，修改完重启systemctl restart mysqld

# 指定binlog目录，就会自动在此目录下生成bin log文件
    log-bin=/var/lib/mysql/mysql-bin
    # slave读master节点时需要设置master的server-id，唯一标识
    server-id=1001

还可以在mysql客户端通过sql命令查看binlog开启情况

show variables like 'log_bin%';
    show BINARY logs; // 查看所有的binlog文件
    show binlog events in 'mysql-bin.000005'; // 查看某个binlog文件的具体内容

![20210814191506283.png][]

在master节点数据库user表中，添加可访问的slave节点的IP，以及可访问的用户

![20210814191907488.png][]

slave节点通过下面命令指定binlog文件，以及同步数据的offset；指定master的IP和端口，用户名和密码：

![20210814192920186.png][]

change master to master_host='192.168.211.128' master_user='repl',master_password='123456',master_port=3306,master_log_file='mysql-bin.000005',master_log_pos=20047812;

master节点的binlog文件以及同步的offset值可以通过sql命令在mysql客户端查询：

show master status;

![20210814192641543.png][]

slave节点设置完后，通过start slave;命令启动slave节点，并可以通过show slave status \\G;命令查看slave节点状态；

配置application.properties

# db0是随意定义的逻辑库名字
    spring.shardingsphere.rules.replica-query.data-sources.db0.primary-data-source-name=write-ds
    spring.shardingsphere.rules.replica-query.data-sources.db0.replica-data-source-names=read-ds0,read-ds1
    spring.shardingsphere.rules.replica-query.load-balancers.db0.type=ROUND_ROBIN
    # 无任何意义，但是不配置报错
    spring.shardingsphere.rules.replica-query.load-balancers.db0.props.test=test

### Mysql读写分离高可用方案 ###

mysql读写分离，如果采用一主多从模式，只有一个写节点来实现写入操作，多个从节点负责读操作，那么写节点万一出现故障，数据就会丢失。为了保证高可用，针对写节点，可采用双机热备（Master-Master），然后通过keepalived来实现自由切换。两个节点同时运行，但是只有一个节点是负责工作的，另一个节点是backup，两个节点IP都配置在keepalived中，keepalived通过心跳机制监听两个节点，万一负责工作的master节点出现故障，keepalived会自动路由到backup节点，把backup节点作为新的master节点。

--------------------

## 分布式事务 ##

一个事务分布在多个数据库中，针对一个业务操作，如果需要操作多个数据库，其中一个数据库执行出错，同一个事务中其他数据库操作应该回滚，其实就是保证操作的原子性，实现分布式数据一致性问题。为了保证同一个业务对不同数据库操作的原子性，所以需要一个全局事务，来决定最终每个数据库操作是需要commit还是rollback。

### CAP ###

*  C：Consistency一致性，同一个数据在多个节点中保持实时一致性
 *  A：Availablity可用性，客户端请求在一定时间内要收到明确的返回结果
 *  P：Partition分区容错性，上面两个问题都是由于分区容错性导致的，不同分区之间数据同步，需要依赖网络通信，所以可能出现网络抖动等情况，从而引起不同节点数据无法保持实时的强一致性，一旦保证了实时强一致性，必然会造成客户端等待时间变长，导致不可用。所以一般要么选择CP，要么选择AP

### 全局事务Global Transaction ###

全局事务是一个DTP模型的事务，DTP模型指的是X/Open DTP(X / Open Distributed Transaction Processing Reference Model)，是X/Open组织定义的一套分布式事务标准，简称XA协议，也就是所谓的两阶段提交。所以想要应用全局事务的数据库必须也实现/遵守XA协议

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 4][]

1.  application发起请求，类似是一个事务操作请求
2.  TM接收请求后针对每个请求生成一个全局唯一xid
3.  XA协议开始xid开始全局事务
4.  当前事务中涉及的所有数据库开始资源操作，将数据操作记录到事务日志中；并返回一个状态给TM
5.  根据事务中的所有数据库回执状态，判断当前事务commit / rollback

### ShardingSphere-JDBC引入的分布式事务 ###

*  Atomikos：默认的XA事务管理器
 *  Narayana：实现了XA协议
 *  Bitronix：实现了XA协议
 *  Seata：独立的中间件，所以可以跨进程，需下载安装

### TransactionType事务类型 ###

*  XA：强一致性事务
 *  BASE：Basic Availability Soft state Eventual consistency基本可用柔性状态最终一致性，BASE必须基于Seata实现

### 如何实现最终一致性？ ###

异步补偿机制：如果某个数据库操作因为网络情况失败，先返回成功结果，然后使用MQ发起异步重试机制，如果重试一定次数后仍然失败，通过对账可以保证数据一致性

--------------------

## 分布式治理（Zookeeper / etcd） ##

注册中心：对服务地址统一管理

配置中心：对配置文件统一管理

多节点集群的分布式已成趋势，多个节点都有配置，比较繁琐，所以提供了分布式治理来集中配置，实现分布式不同节点配置一致性

引入Maven依赖

<dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-governance-spring-boot-starter</artifactId>
        <version>${shardingsphere.version}</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-governance-repository-zookeeper-curator</artifactId>
        <version>${shardingsphere.version}</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-governance-repository-etcd</artifactId>
        <version>${shardingsphere.version}</version>
    </dependency>

配置规则

# 是否覆盖远程配置中心上的配置
    spring.shardingsphere.governance.overwrite=false
    # 注册中心配置
    spring.shardingsphere.governance.registry-center.type=Zookeeper
    spring.shardingsphere.governance.registry-center.server-lists=192.168.221.128:2181,192.168.221.129:2181
    spring.shardingsphere.governance.registry-center.props.maxRetries=4
    spring.shardingsphere.governance.registry-center.props.retryIntervalMilliseconds=6000

直接通过注入的方式即可使用 GovernanceShardingSphereDataSource

@Resource
    private DataSource dataSource;

--------------------

# ShardingSphere-Proxy #

JDBC服务端代理，实现了数据库协议，目前支持MySQL 和 PostgreSQL，对应用程序而言完全透明，直接当做MySQL / PostgreSQL使用，应用程序不再直接访问数据库，而是访问服务代理Sharding-Proxy，proxy将请求转交给对应的数据库。

[https_shardingsphere.apache.org_document_current_cn_overview]: https://shardingsphere.apache.org/document/current/cn/overview/
[ShardingSphere-JDBC]: https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-jdbc
[ShardingSphere-Proxy]: https://shardingsphere.apache.org/document/current/en/overview/#shardingsphere-proxy
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70]: /images/20220829/ae4f0c67203842eaae97699cf9ddd4e8.png
[20210816181848188.png]: /images/20220829/c13b83aa643e4cf0bafc8fa652d6edbc.png
[20210814094151308.png]: /images/20220829/24170d18457b4294ab7af0da3c2717cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 1]: /images/20220829/96628b85e87747d79b395dbe2a941e0b.png
[2021081418362428.png]: /images/20220829/032aa0b2e4a94deda771cb059b33aa1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 2]: /images/20220829/61f9b53f7a3c49e285e2040734f75178.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 3]: /images/20220829/13ff8640ed244511a6a0e596264647e0.png
[20210814191506283.png]: /images/20220829/02b2920574f141bfba7869ffce1b2876.png
[20210814191907488.png]: /images/20220829/c701c2dd6c09425991859463333f2552.png
[20210814192920186.png]: /images/20220829/f73ab17275de49389fe9da709f2ef1d2.png
[20210814192641543.png]: /images/20220829/d84d472a50f94c0f90a513383bd67105.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1Y2lmZXJsb25neHU_size_16_color_FFFFFF_t_70 4]: /images/20220829/c78881be9eab4ed8b4dd73dbd37ba4e7.png