目录
前言
一、ShardingSphere4.1.1的spring boot配置
二、ShardingSphere的分片策略
三、SpringBoot 整合 ShardingSphere4.1.1
四、ShardingSphere实现分布式事务控制
前言
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。
一、ShardingSphere4.1.1的spring boot配置
引入Maven依赖
<!-- for spring boot -->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
<version>4.1.1</version>
</dependency>Spring boot的yaml规则配置
spring:
shardingsphere:
enabled: true #是否开启sharding
props:
sql:
show: true #是否显示sql语句日志
#多数据源配置
datasource:
names: master,slave1,slave2 #自定义真实的数据源名字，多个数据源逗号隔开
master: #主数据源，master来自上方真实数据源取的名字
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/master
username: demo
password: 123456
#xxx:xx #数据库连接池的其它属性
salve1: #从数据源，salve1来自上方真实数据源取的名字
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/salve1
username: demo
password: 123456
salve2: #从数据源，salve2来自上方真实数据源取的名字
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/salve1
username: demo
password: 123456
#主从节点，读写分离配置 (在不使用数据分片功能，只需要读写分离功能情况下的配置)
masterslave:
name: ms #自定义一个虚拟数据源名字，用于自动路由下方主从数据源
master-data-source-name: master # 指定主数据源
slave-data-source-names: # 指定从数据源
- slave1
- slave2
load-balance-algorithm-type: round_robin #从库负载均衡算法类型，可选值：ROUND_ROBIN，RANDOM
#数据分片 + 读写分离
sharding:
master-slave-rules: #在使用数据分片功能情况下，配置读写分离功能
ds0: #自定义一个虚拟数据源名字，用于自动路由下方主从数据源
masterDataSourceName: master # 指定主数据源
slaveDataSourceNames: # 指定从数据源
- slave1
- slave2
loadBalanceAlgorithmType: round_robin
binding-tables:
- t_user #指明了分库分表要处理的虚拟表名字
tables:
t_user: #自定义一个虚拟表名字，后续sql语句中就使用这个表名字，会自动路由到真实的表名
actualDataNodes: master$->{1..2}.t_user$->{1..10} #指定真实的数据源.表名，这里表示两个master数据源，10张表t_user
keyGenerator: #主键自动生成策略
column: uid #指定表字段名
type: SNOWFLAKE #指定雪花算法
props:
worker: #指定雪花算法的工作中心
id: 1
#分表策略, 可选项有 inline, standard, ***plex, hint, none
tableStrategy:
inline: #inline（行表达式分片策略）- 根据单一分片键进行精确分片
shardingColumn: uid #指定分片键（表字段）
algorithmExpression: t_user$->{uid%2+1} #指定分片算法，这里是取模算法
standard: #standard（标准分片策略） - 根据单一分片键进行精确或者范围分片
shardingColumn: uid
#指定精确分片算法的实现类, 必选项
preciseAlgorithmClassName: ***.demo.strategy.TablePreciseAlgorithm
#指定范围分片算法的实现类
rangeAlgorithmClassName: ***.demo.strategy.TableRangeAlgorithm
***plex: #***plex（复合分片策略） - 根据多个分片键进行精确或者范围分片
shardingColumn: uid
#指定复合分片算法实现类
algorithmClassName: ***.demo.strategy.Table***plexAlgorithm
hint: #hint策略 - 使用与sql无关的方式进行分片
#指定hint分片算法实现类
algorithmClassName: ***.demo.strategy.DbHintAlgorithm
none: #不使用分片策略
#分库策略, 可选项有 inline, standard, ***plex, hint, none
databaseStrategy:
inline: #配置跟上方表策略相同
standard:
hint:
none:
二、ShardingSphere的分片策略
- inline（行表达式分片策略） - 根据单一分片键进行精确分片
- standard（标准分片策略） - 根据单一分片键进行精确或者范围分片
- ***plex（复合分片策略） - 根据多个分片键进行精确或者范围分片
- hint策略 - 使用与sql无关的方式进行分片
1. inline（行表达式分片策略） - 根据单一分片键进行精确分片
对应InlineShardingStrategy。使用Groovy的表达式，提供对SQL语句中的=和IN的分片操作支持，只支持单分片键。对于简单的分片算法，可以通过简单的配置使用，从而避免繁琐的Java代码开发，如: user_$->{u_id % 8} 表示t_user表根据u_id模8，而分成8张表，表名称为user_0到user_7。
#inline 单分片键策略， sql不支持 >, <, between and
#分表策略配置
table-strategy:
inline:
sharding-column: cid #分片字段
algorithm-expression: course_$->{cid%2+1} #分片算法，取模
#分库策略配置
database-strategy:
inline:
sharding-column: cid #分片字段
algorithm-expression: db_$->{cid%2+1} #分片算法，取模2. standard（标准分片策略） - 根据单一分片键进行精确或者范围分片
对应StandardShardingStrategy，支持精确和范围分片，提供对SQL语句中的=，IN，BETWEEN AND、>、<、>=、<=的分片操作支持。
精确分片算法接口： PreciseShardingAlgorithm， 必选的，用于处理=和IN的分片
范围分片算法接口： RangeShardingAlgorithm，用于处理BETWEEN AND, >, <, >=, <=分片
#standard 单分片键策略， 支持精确和范围分片
#分表策略配置
table-strategy:
standard:
sharding-column: cid #分片字段
#指定精确分片算法的实现类, 必选项
precise-algorithm-class-name: ***.demo.strategy.TablePreciseAlgorithm
#指定范围分片算法的实现类
range-algorithm-class-name: ***.demo.strategy.TableRangeAlgorithm
#分库策略配置
database-strategy:
standard:
sharding-column: cid
precise-algorithm-class-name: ***.demo.strategy.DbPreciseAlgorithm
range-algorithm-class-name: ***.demo.strategy.DbRangeAlgorithm自定义类实现精确或范围分片算法
注意：集合参数Collection<String> availableTargetNames 表示数据源或者实际表的名字集合，
如果是分表策略就是实际表的名字集合， 如果是分库策略就是数据源名字集合
- table分表策略
/**
* standard分片策略的表精确分片算法实现类
* 实现接口 PreciseShardingAlgorithm<T>， 泛型类T是分片键的字段类型
*/
public class TablePreciseAlgorithm implements PreciseShardingAlgorithm<Long> {
/**
* 精确分片算法：用于处理=和IN的分片
* @param availableTargetNames - 数据源或者实际表的名字集合
* @param preciseShardingValue - 包含逻辑表名、分片列和分片列的值
* @return 返回分片后的实际表名
*/
@Override
public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> preciseShardingValue) {
//获取分片列的值
Long value = preciseShardingValue.getValue();
//获得虚拟表名
String logicTableName = preciseShardingValue.getLogicTableName();
//实现course_$->{cid%2+1} 取模分片算法
long index = value % 2 + 1;
//拼接获得实际表名
String actualTableName = logicTableName + "_" + index;
//判断配置的实际表集合中是否有该实际表名
if(availableTargetNames.contains(actualTableName)) {
return actualTableName;
}
return null;
}
}/**
* standard分片策略的范围分片算法实现类
* 实现接口 PreciseShardingAlgorithm<T>， 泛型类T是分片键的字段类型
*/
public class TableRangeAlgorithm implements RangeShardingAlgorithm<Long> {
/**
* 范围分片算法：用于处理BETWEEN AND, >, <, >=, <=分片
* @param availableTargetNames - 数据源或者实际表的名字集合
* @param shardingValue - 分片值
* @return 返回分片后的实际表名
*/
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames, RangeShardingValue<Long> shardingValue) {
//实现范围查询 cid between 200 and 300 中的上限和下限值
Range<Long> valueRange = shardingValue.getValueRange();
Long lower = valueRange.lowerEndpoint(); //下限值200
Long upper = valueRange.upperEndpoint(); //上限值200
//下面自行实现逻辑判断分片后的实际表名，这里就不具体实现了
return availableTargetNames;
}
}- DB分库策略
/**
* standard分片策略的表精确分片算法实现类
* 实现接口 PreciseShardingAlgorithm<T>， 泛型类T是分片键的字段类型
*/
public class DbPreciseAlgorithm implements PreciseShardingAlgorithm<Long> {
/**
* 精确分片算法：用于处理=和IN的分片
* @param availableTargetNames - 数据源或者实际表的名字集合
* @param preciseShardingValue - 包含逻辑表名、分片列和分片列的值
* @return 返回数据源名字
*/
@Override
public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> preciseShardingValue) {
//获取配置的所有数据源名字集合
System.out.println("===> names: "+availableTargetNames);
return null;
}
}3. ***plex（复合分片策略） - 根据多个分片键进行精确或者范围分片
对应***plexKeysShardingAlgorithm，用于处理使用多键作为分片键进行分片的场景，包含多个分片键的逻辑较复杂，需要应用开发者自行处理其中的逻辑，需要配合***plexShardingStrategy使用。
复合分片算法接口： ***plexKeysShardingAlgorithm
#***plex 多个分片键策略， 支持精确和范围分片
#分表策略配置
table-strategy:
***plex:
sharding-column: cid, user_id #分片字段, 可以指定多个
algorithm-class-name: ***.demo.strategy.Table***plexAlgorithm
#分库策略配置
database-strategy:
***plex:
sharding-column: cid, user_id #分片字段, 可以指定多个
algorithm-class-name: ***.demo.strategy.Db***plexAlgorithm/**
* ***plex 多个分片键的分片策略
* 实现接口 PreciseShardingAlgorithm<T>， 泛型类T是分片键的字段类型
*/
public class Table***plexAlgorithm implements ***plexKeysShardingAlgorithm<Long> {
/**
* ***plex 多个分片键的分片算法
*
* @param availableTargetNames - 数据源或者实际表的名字集合
* @param shardingValue - 含逻辑表名、分片列和分片列的值
* @return 返回实际表名集合
*/
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames, ***plexKeysShardingValue<Long> shardingValue) {
Collection<String> result = new ArrayList<>();
String logicTableName = shardingValue.getLogicTableName();
//shardingValue.getColumnNameAndShardingValuesMap
//获得分片列名和分片值的对应map
Map<String, Collection<Long>> mp1 = shardingValue.getColumnNameAndShardingValuesMap();
//shardingValue.getColumnNameAndRangeValuesMap
//获得分片列名和分片范围值的对应map
Map<String, Range<Long>> mp2 = shardingValue.getColumnNameAndRangeValuesMap();
return availableTargetNames;
}
}对于两个分片键的场景，可以采用基因法
在电商场景中，使用订单 ID 和买家 ID 查询数据的问题。在这个场景中，我们选择使用订单 ID 作为分片键是一个没有异议的选择。那么此时，我们通过 APP 来查询自己的订单时，查询条件变为了分片键之外的买家 ID，默认情况下，查询语句中不带有分片键会导致全路由情况。面对这样的情况，应如何设计一个高效的分片策略？
大厂常常使用的方案是基因法，即将买家 ID 融入到订单 ID 中，作为订单 ID 后缀。这样，指定买家的所有订单就会与其订单在同一分片内了，如下图所示
4. hint策略 - 使用与sql无关的方式进行分片
对应HintShardingStrategy。通过Hint指定分片值而非从SQL中提取分片值的方式进行分片的策略
hint分片算法接口： HintShardingAlgorithm
#hint 片键策略
#分表策略配置
table-strategy:
hint:
algorithm-class-name: ***.demo.strategy.TableHintAlgorithm
#分库策略配置
database-strategy:
hint:
algorithm-class-name: ***.demo.strategy.DbHintAlgorithmpublic class TableHintAlgorithm implements HintShardingAlgorithm<Long> {
/**
* Sharding.
*
* <p>sharding value injected by hint, not in SQL.</p>
*
* @param availableTargetNames available data sources or tables's names
* @param shardingValue sharding value，来自hintManager设置的值
* @return sharding result for data sources or tables's names
*/
@Override
public Collection<String> doSharding(Collection<String> availableTargetNames, HintShardingValue<Long> shardingValue) {
return null;
}
}ShardingSphere使用ThreadLocal管理分片键值进行Hint强制路由。可以通过编程的方式向HintManager中添加分片值，该分片值仅在当前线程内生效。 Hint方式主要使用场景：
1.分片字段不存在SQL中、数据库表结构中，而存在于外部业务逻辑。
2.强制在主库进行某些数据操作。
Hint分片算法需要用户实现HintShardingAlgorithm接口，ShardingSphere在进行Routing时，将会从HintManager中获取分片值进行路由操作。
获取HintManager
HintManager hintManager = HintManager.getInstance();添加分片键值
- 使用hintManager.addDatabaseShardingValue来添加数据源分片键值。
- 使用hintManager.addTableShardingValue来添加表分片键值。
分库不分表情况下，强制路由至某一个分库时，可使用hintManager.setDatabaseShardingValue方式添加分片。通过此方式添加分片键值后，将跳过SQL解析和改写阶段，从而提高整体执行效率。
清除分片键值
分片键值保存在ThreadLocal中，所以需要在操作结束时调用hintManager.close()来清除ThreadLocal中的内容。
代码示例
// Sharding database and table with using hintManager.
String sql = "SELECT * FROM t_order";
try (HintManager hintManager = HintManager.getInstance();
Connection conn = dataSource.getConnection();
PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
hintManager.addDatabaseShardingValue("t_order", 1);
hintManager.addTableShardingValue("t_order", 2);
try (ResultSet rs = preparedStatement.executeQuery()) {
while (rs.next()) {
// ...
}
}
}
// Sharding database without sharding table and routing to only one database with using hintManger.
String sql = "SELECT * FROM t_order";
try (HintManager hintManager = HintManager.getInstance();
Connection conn = dataSource.getConnection();
PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
hintManager.setDatabaseShardingValue(3);
try (ResultSet rs = preparedStatement.executeQuery()) {
while (rs.next()) {
// ...
}
}
}三、SpringBoot 整合 ShardingSphere4.1.1
1. POM文件引入shardingSphere相关依赖
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- mybatis框架 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
<!-- druid数据源 -->
<dependency>
<groupId>***.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
</dependency>
<!-- sharding-jdbc分库分表 -->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
<version>4.1.1</version>
</dependency>
<!-- sharding-transaction分布式事务 -->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-transaction-xa-core</artifactId>
<version>4.1.1</version>
</dependency>2. 分表的建表语句
在course数据库下创建两张表course_1, course_2
-- course.course_1 definition
CREATE TABLE `course_1` (
`cid` bigint(20) NOT NULL ***MENT 'ID',
`***ame` varchar(100) NOT NULL,
`user_id` varchar(64) NOT NULL,
`cstatus` tinyint(4) NOT NULL,
PRIMARY KEY (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
-- course.course_2 definition
CREATE TABLE `course_2` (
`cid` bigint(20) NOT NULL ***MENT 'ID',
`***ame` varchar(100) NOT NULL,
`user_id` varchar(64) NOT NULL,
`cstatus` tinyint(4) NOT NULL,
PRIMARY KEY (`cid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;3. yaml配置文件配置sharding分库分表的配置
-
分表yaml配置
#配置分库分表策略
#配置数据源
spring:
shardingsphere:
props:
sql:
show: true #显示sql语句日志
datasource:
names: m1 #指定一个虚拟数据库名称
m1:
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/course?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true
username: test
password: 123456
#分表配置, 这里使用主键cid 作为分表字段
sharding:
tables:
course: #指定一个虚拟表名称
actual-data-nodes: m1.course_$->{1..2} #实际使用的表节点, 数据库.表名
key-generator: #主键自动生成策略
column: cid
type: SNOWFLAKE #使用雪花ID
props:
worker:
id: 1
table-strategy: #分表策略
inline: #inline策略
sharding-column: cid #分表字段
algorithm-expression: course_$->{cid%2+1} #分表算法，求模取余算法-
分库yaml配置
#配置分库分表策略
#配置多个数据源
spring:
shardingsphere:
datasource:
names: m1,m2 #指定多个虚拟数据库名称
m1:
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/course1?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true
username: test
password: 123456
m2:
type: ***.alibaba.druid.pool.DruidDataSource
driver-class-name: ***.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/course2?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true
username: test
password: 123456
#分库分表配置
sharding:
tables:
course: #指定一个虚拟表名称
actual-data-nodes: m$->{1..2}.course_$->{1..2} #m1.course 数据库.表名
key-generator: #主键自动生成策略
column: cid
type: SNOWFLAKE #使用雪花ID
props:
worker:
id: 1
table-strategy: #分表策略
inline: #inline策略
sharding-column: cid #分表字段
algorithm-expression: course_$->{cid%2+1} #分表算法，求模取余算法
database-strategy: #分库策略
inline: #inline策略
sharding-column: user_id #分库字段
algorithm-expression: m$->{user_id % 2 + 1} #分库算法，求模取余算法
4. 启动类上移除Druid数据源的自动配置
@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class )
public class ShardingsphereApplication {
public static void main(String[] args) {
SpringApplication.run(ShardingsphereApplication.class, args);
}
}5. 插入测试数据
正常使用mapper接口进行数据插入即可
@Service
public class CourseService {
@Autowired
private CourseMapper courseMapper;
@PostConstruct
private void init() {
this.insert();
}
public void insert() {
for (int i=1;i<=10;i++) {
Course c = new Course(null, "汤姆"+i, "tom"+i, 1);
courseMapper.insert(c);
}
}
}插入结果：
course_1表
course_2表
四、ShardingSphere实现分布式事务控制
引入Maven依赖
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
<version>${shardingsphere.version}</version>
</dependency>
<!-- 使用XA事务时，需要引入此模块 -->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-transaction-xa-core</artifactId>
<version>${shardingsphere.version}</version>
</dependency>
<!-- 使用BASE事务时，需要引入此模块 -->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding-transaction-base-seata-at</artifactId>
<version>${sharding-sphere.version}</version>
</dependency>ShardingSphere要实现事务控制需要手动声明一个PlatformTransactionManager事务管理器Bean，否则事务不会生效。还要将ShardingDataSource 数据源注入到事务管理器中。
/**
* 事务管理器中注入Sharding数据源 ShardingDataSource
*/
@Bean
@Primary
public PlatformTransactionManager platformTransactionManager(ShardingDataSource shardingDataSource) {
PlatformTransactionManager manager = new DataSourceTransactionManager(shardingDataSource);
return manager;
}后续使用注解@EnableTransactionManagement开启事务，注解@Transactional标注在需要事务控制的方法上。
@Transactional
@ShardingTransactionType(TransactionType.XA) // 支持TransactionType.LOCAL, TransactionType.XA, TransactionType.BASE
public void insert() {
jdbcTemplate.execute("INSERT INTO t_order (user_id, status) VALUES (?, ?)", (PreparedStatementCallback<Object>) preparedStatement -> {
preparedStatement.setObject(1, i);
preparedStatement.setObject(2, "init");
preparedStatement.executeUpdate();
});
}Sharding支持事务类型TransactionType.LOCAL, TransactionType.XA, TransactionType.BASE
本文参考shardingsphere官网网站文档
使用手册 :: ShardingSphere
