sharding-jdbc源码分析（一）之分片配置

分片配置的目的显而易见：就是将数据库分片规则和策略告诉sharding-jdbc

sharding-jdbc需要知道如下信息：

（1）哪些表需要分片

（2）需要分成哪些库？哪些表？名字分别是什么

（3）通过哪个字段（或哪些字段）进行分库分表

（4）具体的分库或分表算法什么怎样的

（5）分片规则和策略相关的一组表怎么处理

 

刚开始看官方的小例子，分片配置的代码有些懵逼，梳理了一下，需要如下类进行实现

 

DataSourceRule

TableRule

BindingTableRule

ShardingRule

 

这些对象的创建次序轴是这样的：

 

 

 

先看DataSourceRule

这个类可以理解为：存放所有被拆分的数据库对象和默认数据源的名称

这个类一共有两个属性：

（1）defaultDataSourceName：默认数据源的名字，那些不需要分片的数据表放到这个数据源中

（2）dataSourceMap：全部的数据源对象（DataSource），这是一个map结构，key：数据库的名字，value：数据源对象（DataSource）

 

 

 public DataSourceRule(final Map<String, DataSource> dataSourceMap, final String defaultDataSourceName) {
        Preconditions.checkState(!dataSourceMap.isEmpty(), "Must have one data source at least.");
        this.dataSourceMap = dataSourceMap;
        if (1 == dataSourceMap.size()) {
            this.defaultDataSourceName = dataSourceMap.entrySet().iterator().next().getKey();
            return;
        }
        if (Strings.isNullOrEmpty(defaultDataSourceName)) {
            this.defaultDataSourceName = null;
            return;
        }
        Preconditions.checkState(dataSourceMap.containsKey(defaultDataSourceName), "Data source rule must include default data source.");
        this.defaultDataSourceName = defaultDataSourceName;
    }

 

 

 上面是构造函数，比较简单，做下面几件事情：

（1）数据源map不能为空，否则抛异常

（2）如果map的大小为1，默认数据源的名字就是这个唯一的数据源，可以理解为不分库只分表，或不分库分表

（3）如果存在默认数据源，则要判断这个数据源是否存在于map中

这个类的其它方法比较简单，通过注释就能明白什么意思

 

TableRule

这个对象用来存放逻辑表、所有的分片最小单位（DataNode）、分库策略、分表策略、是否动态表，下面分表解释含义：

（1）逻辑表：这个简单不解释

（2）分片最小单位：比如db_0.order_1，这个最小单位是通过计算来生成的，后面会讲到

（3）分库策略：定义分库算法的类

（4）分表策略：定义分表算法的类

（5）是否为动态表：表示实际表的名字和个数无法确认，是动态变化的，无法在程序中静态配置。比如：真实表的名称随着时间的推移会产生变化。

 

 

/**
     * 全属性构造器.
     *
     * <p>用于Spring非命名空间的配置.</p>
     *
     * <p>未来将改为private权限, 不在对外公开, 不建议使用非Spring命名空间的配置.</p>
     *
     * @deprecated 未来将改为private权限, 不在对外公开, 不建议使用非Spring命名空间的配置.
     */
    @Deprecated
    public TableRule(final String logicTable, final boolean dynamic, final List<String> actualTables, final DataSourceRule dataSourceRule, final Collection<String> dataSourceNames,
                     final DatabaseShardingStrategy databaseShardingStrategy, final TableShardingStrategy tableShardingStrategy) {
        Preconditions.checkNotNull(logicTable);
        this.logicTable = logicTable;
        this.dynamic = dynamic;
        this.databaseShardingStrategy = databaseShardingStrategy;
        this.tableShardingStrategy = tableShardingStrategy;
        if (dynamic) {
            Preconditions.checkNotNull(dataSourceRule);
            this.actualTables = generateDataNodes(dataSourceRule);
        } else if (null == actualTables || actualTables.isEmpty()) {
            Preconditions.checkNotNull(dataSourceRule);
            this.actualTables = generateDataNodes(Collections.singletonList(logicTable), dataSourceRule, dataSourceNames);
        } else {
            this.actualTables = generateDataNodes(actualTables, dataSourceRule, dataSourceNames);
        }
    }

 

 

这个是构造函数的代码：

（1）前几行比较简单，就是根据入参设置属性值

（2）紧接着是生成DataNode的代码

（3）如果是动态表，生成的DataNode只有数据源，表的名字没有

（4）如果真实表为空，则把逻辑表名作为真实表名（只分库不分表或不分库分表）

（5）其它情况，就会根据所有的数据源和真实表，通过笛卡尔积计算生成最小分片单元（DataNode）

 

/**
     * 根据数据源名称过滤获取真实数据单元.
     *
     * @param targetDataSources 数据源名称集合
     * @param targetTables 真实表名称集合
     * @return 真实数据单元
     */
    public Collection<DataNode> getActualDataNodes(final Collection<String> targetDataSources, final Collection<String> targetTables) {
        return dynamic ? getDynamicDataNodes(targetDataSources, targetTables) : getStaticDataNodes(targetDataSources, targetTables);
    }

 

上面这个方法是根据数据源列表和真实表列表获取最小分片单元。

这个方法会在分库和分表策略计算完毕后，得到路由到的数据库列表和数据表列表，但是不知道数据表和数据库的对应关系（这边表属于哪个数据库），通过这个方法来获取最小分片单元

这个方法会分两种情况

（1）如果是动态分表，则会拿这些需要路由的表和所有的分库做笛卡尔积计算（也就是说动态表这种场景，分多少个库一定是确定的，并且表要在每个库都动态新增）

（2）不是动态分表，会计算出这些数据库和数据表的真实对应关系

这个地方不太好理解，举个例子：

比如分了两个库，db0和db1，这个两个库中分别有下面这些表：

db0：order0，order1，order2

db1：order3，order4，order5

经过分库分表计算后，得到的结果是：需要查询两个库：db0和db1，两张表：order1和order5，我怎么知道order1是属于db0的，二order5是属于db1的呢？就是通过这个方法来计算

 

 /**
     * 根据数据源名称过滤获取真实表名称.
     *
     * @param targetDataSources 数据源名称
     * @return 真实表名称
     */
    public Collection<String> getActualTableNames(final Collection<String> targetDataSources) {
        Collection<String> result = new LinkedHashSet<>(actualTables.size());
        for (DataNode each : actualTables) {
            if (targetDataSources.contains(each.getDataSourceName())) {
                result.add(each.getTableName());
            }
        }
        return result;
    }

 

这个方法比较好理解，根据数据源名字获取这些数据源下面的所有真实表的名字

当进行了分库计算，再进行分表计算时，我只需要获取这些数据源下面的真实表，缩小了范围

 

  int findActualTableIndex(final String dataSourceName, final String actualTableName) {
        int result = 0;
        for (DataNode each : actualTables) {
            if (each.getDataSourceName().equals(dataSourceName) && each.getTableName().equals(actualTableName)) {
                return result;
            }
            result++;
        }
        return -1;
    }

 这个方法是根据数据源名字和表名字获取这个分片单元在actualTables中的索引，这个用于确定绑定表，讲绑定表时会详细讲解

 

 BindingTableRule

如果两张表在任何场景下，分片规则完全一样，我们可以对这两张表进行绑定，这两张表互为绑定表，例如订单表和子订单表。关联表查询时，可以显著的提高查询效率，避免笛卡尔积查询。

这个对象只有一个属性：tableRules，这个列表中的表互为绑定表

 

 /**
     * 根据其他Binding表真实表名称获取相应的真实Binding表名称.
     * 
     * @param dataSource 数据源名称
     * @param logicTable 逻辑表名称
     * @param otherActualTable 其他真实Binding表名称
     * @return 真实Binding表名称
     */
    public String getBindingActualTable(final String dataSource, final String logicTable, final String otherActualTable) {
        int index = -1;
        for (TableRule each : tableRules) {
            if (each.isDynamic()) {
                throw new UnsupportedOperationException("Dynamic table cannot support Binding table.");
            }
            index = each.findActualTableIndex(dataSource, otherActualTable);
            if (-1 != index) {
                break;
            }
        }
        Preconditions.checkState(-1 != index, String.format("Actual table [%s].[%s] is not in table config", dataSource, otherActualTable));
        for (TableRule each : tableRules) {
            if (each.getLogicTable().equals(logicTable)) {
                return each.getActualTables().get(index).getTableName();
            }
        }
        throw new IllegalStateException(String.format("Cannot find binding actual table, data source: %s, logic table: %s, other actual table: %s", dataSource, logicTable, otherActualTable));
    }

 

一个sql语句中，如果几个表关联查询，并且这几个表互为绑定表，其中一个表进行了分片计算，其它表就不需要再次进行分片计算（绑定表的分片规则一样），就需要根据主表计算出其它表的真实名字，上面的方法就实现这个功能

（1）获取绑定表主表（已经进行了分片计算的表）位于actualTables中的索引

（2）根据索引和逻辑表名字获取绑定表子表名

 

绑定表的一个坑（版本1.3.1）：

 

order和sub_order是绑定表，都以order_id进行分表。
写法一（正确的写法）：SELECT * FROM order,sub_order WHERE order.order_id = sub_order.order_id and order.order_id = ?
写法二（错误的写法）：SELECT * FROM sub_order,order WHERE order.order_id = sub_order.order_id and order.order_id = ?
写法二会导致不进行分表计算，很容易造成陷阱，可能是因为选主的算法，FROM后面的第一个表认为是主表，所用的绑定表的分库分别规则都以主表为准。所以写法二认为主表是sub_order，但是where条件中却是order.order_id，所以就不进行分表计算。

 

ShardingRule

这个对象会汇总DataSourceRule、TableRule、BindingTableRule、分表策略、分库策略

这个对象的构造方法中会传入DataSourceRule，TableRule对象中的构造方法中也有这个参数，

（1）在ShardingRule中，数据源对象会被存放起来，供后面使用。

（2）在TableRule中数据源对象是用来计算最小分片单元的。

 

这个对象中会设置分库和分表策略，TableRule中同样也有，优先级TableRule更高