sharding-sphere主要的配置有四类，一个是数据库读写分离，主备数据源配置，一个是数据表配置，一个是分片规则配置。分别如下：
| 类名 | 介绍 |
|---|---|
| MasterSlaveRuleConfiguration | 主备数据源配置 |
| ShardingRuleConfiguration | 分片规则配置 |
| TableRuleConfiguration | 表配置 |
主备数据源配置：MasterSlaveRuleConfiguration
public final class MasterSlaveRuleConfiguration {
//名称
private final String name;
//主数据源
private final String masterDataSourceName;
//从数据源
private final Collection<String> slaveDataSourceNames;
//负载均衡算法
private MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm;
}
MasterSlaveLoadBalanceAlgorithm算法有两种实现,根据名称，主数据源名称，从数据源列表选择一个数据源。但默认算法实现过程中并未使用前两个字段，用户自定义使用的过程中可以使用。
public interface MasterSlaveLoadBalanceAlgorithm {
String getDataSource(String name, String masterDataSourceName, List<String> slaveDataSourceNames);
}
//随机算法
public final class RandomMasterSlaveLoadBalanceAlgorithm implements MasterSlaveLoadBalanceAlgorithm {
@Override
public String getDataSource(final String name, final String masterDataSourceName, final List<String> slaveDataSourceNames) {
return slaveDataSourceNames.get(new Random().nextInt(slaveDataSourceNames.size()));
}
}
//轮询算法
public final class RoundRobinMasterSlaveLoadBalanceAlgorithm implements MasterSlaveLoadBalanceAlgorithm {
private static final ConcurrentHashMap<String, AtomicInteger> COUNT_MAP = new ConcurrentHashMap<>();
@Override
public String getDataSource(final String name, final String masterDataSourceName, final List<String> slaveDataSourceNames) {
AtomicInteger count = COUNT_MAP.containsKey(name) ? COUNT_MAP.get(name) : new AtomicInteger(0);
COUNT_MAP.putIfAbsent(name, count);
count.compareAndSet(slaveDataSourceNames.size(), 0);
return slaveDataSourceNames.get(count.getAndIncrement() % slaveDataSourceNames.size());
}
}
从配置上看，符合一主多从的结构，主数据源只有一个，从数据源有多个。官方文档也证实了这一点。官方地址请点击我
一主多从
分片规则配置：
public final class ShardingRuleConfiguration {
//默认数据源名称
private String defaultDataSourceName;
//表规则配置
private Collection<TableRuleConfiguration> tableRuleConfigs = new LinkedList<>();
//相同表分片规则的组，如果表分片规则相同，则可以放在一个组里。
private Collection<String> bindingTableGroups = new LinkedList<>();
//默认数据库的分片算法配置
private ShardingStrategyConfiguration defaultDatabaseShardingStrategyConfig;
//默认表的分片算法配置
private ShardingStrategyConfiguration defaultTableShardingStrategyConfig;
//默认键的生成工具类
private KeyGenerator defaultKeyGenerator;
//主备配置信息
private Collection<MasterSlaveRuleConfiguration> masterSlaveRuleConfigs = new LinkedList<>();
}
能够看到，所有的配置信息其实都是配在分片配置中。
表配置信息TableRuleConfiguration
public final class TableRuleConfiguration {
//逻辑表名
private String logicTable;
//真实的数据节点名称
private String actualDataNodes;
//数据库分片算法配置
private ShardingStrategyConfiguration databaseShardingStrategyConfig;
//表分片算法配置
private ShardingStrategyConfiguration tableShardingStrategyConfig;
//自动生成键的名称
private String keyGeneratorColumnName;
//自动生成键的工具类
private KeyGenerator keyGenerator;
private String logicIndex;
}
看完了分片规则配置，再来看看分片规则，毕竟分片规则的信息都是由分片配置中来的。
ShardingRule
public final class ShardingRule {
//分片规则配置
private final ShardingRuleConfiguration shardingRuleConfig;
//数据源信息
private final ShardingDataSourceNames shardingDataSourceNames;
//表规则
private final Collection<TableRule> tableRules = new LinkedList<>();
//相同分片规则的表规则
private final Collection<BindingTableRule> bindingTableRules = new LinkedList<>();
//数据库配置
private final ShardingStrategy defaultDatabaseShardingStrategy;
//默认表分片规则
private final ShardingStrategy defaultTableShardingStrategy;
//默认字段生成器
private final KeyGenerator defaultKeyGenerator;
//主备配置信息
private final Collection<MasterSlaveRule> masterSlaveRules = new LinkedList<>();
}
这些信息怎么来的？看构造方法:
public ShardingRule(final ShardingRuleConfiguration shardingRuleConfig, final Collection<String> dataSourceNames) {
this.shardingRuleConfig = shardingRuleConfig;
shardingDataSourceNames = new ShardingDataSourceNames(shardingRuleConfig, dataSourceNames);
//初始化表配置规则
for (TableRuleConfiguration each : shardingRuleConfig.getTableRuleConfigs()) {
tableRules.add(new TableRule(each, shardingDataSourceNames));
}
//分片规则相同组的放在一起
for (String group : shardingRuleConfig.getBindingTableGroups()) {
List<TableRule> tableRulesForBinding = new LinkedList<>();
for (String logicTableNameForBindingTable : StringUtil.splitWithComma(group)) {
tableRulesForBinding.add(getTableRule(logicTableNameForBindingTable));
}
bindingTableRules.add(new BindingTableRule(tableRulesForBinding));
}
//默认数据库分片规则
defaultDatabaseShardingStrategy = null == shardingRuleConfig.getDefaultDatabaseShardingStrategyConfig()
? new NoneShardingStrategy() : ShardingStrategyFactory.newInstance(shardingRuleConfig.getDefaultDatabaseShardingStrategyConfig());
//默认表分片算法
defaultTableShardingStrategy = null == shardingRuleConfig.getDefaultTableShardingStrategyConfig()
? new NoneShardingStrategy() : ShardingStrategyFactory.newInstance(shardingRuleConfig.getDefaultTableShardingStrategyConfig());
//初始化默认字段生成方式
defaultKeyGenerator = null == shardingRuleConfig.getDefaultKeyGenerator() ? new DefaultKeyGenerator() : shardingRuleConfig.getDefaultKeyGenerator();
//主备规则配置
for (MasterSlaveRuleConfiguration each : shardingRuleConfig.getMasterSlaveRuleConfigs()) {
masterSlaveRules.add(new MasterSlaveRule(each));
}
}
表分片规则TableRule
public final class TableRule {
//逻辑实体表
private final String logicTable;
//实际存储的表节点数据
private final List<DataNode> actualDataNodes;
private final ShardingStrategy databaseShardingStrategy;
private final ShardingStrategy tableShardingStrategy;
//默认生成值的表字段名称
private final String generateKeyColumn;
//生成器
private final KeyGenerator keyGenerator;
private final String logicIndex;
}
DataNode为实际存储的节点表的信息，logicTable为逻辑实体表的表名，官方文档是这样介绍的:
屏幕快照 2018-06-11 下午5.22.44.png
在这里，t_order为logicTable属性，t_order_0~t_order_9为actualDataNodes的信息。
DataNode节点数据结构为:
public final class DataNode {
private static final String DELIMITER = ".";
//数据源名称
private final String dataSourceName;
//表名称
private final String tableName;
}
BindingTableRule
public final class BindingTableRule {
private final List<TableRule> tableRules;
}
BindingTableRule很简单，就是有相同分片规则的一些表的集合，由一个表就能获取到其他的表的分片规则。
MasterSlaveRule
public final class MasterSlaveRule {
//name
private final String name;
//主数据源节点名称
private final String masterDataSourceName;
//从数据源节点名称
private final Collection<String> slaveDataSourceNames;
//负载均衡算法
private final MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm;
}
ShardingRule分片规则的API如下:
| 方法名 | 说明 |
|---|---|
| Optional<TableRule> tryFindTableRuleByLogicTable(final String logicTableName) | 根据逻辑表名获取实体表名 |
| tryFindTableRuleByActualTable(final String actualTableName) | 根据真实表名获取表规则，遍历DataNode节点 |
| TableRule getTableRule(final String logicTableName) | 获取表规则 |
| getTableRule(final String logicTableName) | 根据逻辑表名称获取表规则信息和tryFindTableRuleByLogicTable的区别在于，找不到的时候，会初始化一个 |
| ShardingStrategy getDatabaseShardingStrategy(final TableRule tableRule) | 获取数据库分片算法 |
| ShardingStrategy getTableShardingStrategy(final TableRule tableRule) | 获取表分片算法 |
| isAllBindingTables(final Collection<String> logicTables) | 是否所有表都有相同的分片规则 |
| isAllInDefaultDataSource(final Collection<String> logicTables) | 是否所有的表都属于同一个默认的数据源 |
| findBindingTableRule(final String logicTable) | 查找逻辑表名为logicTable的实体表规则 |
| isShardingColumn(final Column column) | 是否是分片项的键 |
| getGenerateKeyColumn(final String logicTableName) | 获取自动生成的键的项 |
| generateKey(final String logicTableName) | 生成默认列信息 |
| getLogicTableName(final String logicIndexName) | 根据logicIndexName获取逻辑表名 |
| findDataNode(final String logicTableName) | 获取数据节点，如果有多个，则取第一个 |
| DataNode findDataNode(final String dataSourceName, final String logicTableName) | 根据逻辑实体名获取数据节点 |
| isLogicIndex(final String logicIndexName, final String logicTableName) | 是否是逻辑表索引，逻辑索引名，逻辑表名称 |
| getMasterDataSourceName(final String masterSlaveRuleName) | 获取主数据源名称 |
网友评论