private RoutingResult route(final List<Object> parameters, final SQLStatement sqlStatement) {    Collection<String> tableNames = sqlStatement.getTables().getTableNames();    RoutingEngine routingEngine;    if (1 == tableNames.size()            || shardingRule.isAllBindingTables(tableNames)            || shardingRule.isAllInDefaultDataSource(tableNames)) {        routingEngine = new SimpleRoutingEngine(shardingRule, parameters, tableNames.iterator().next(), sqlStatement);    } else {        // TODO config for cartesian set        routingEngine = new ComplexRoutingEngine(shardingRule, parameters, tableNames, sqlStatement);    }    return routingEngine.route();}

ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(Arrays.asList(orderTableRule, userTableRule)).databaseShardingStrategy(*** ***).tableShardingStrategy(*** ***) .build();

ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(Arrays.asList(orderTableRule, orderItemTableRule, userTableRule)).bindingTableRules(Collections.singletonList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule)))). *** ***;

public boolean isAllInDefaultDataSource(final Collection<String> logicTables) {    for (String each : logicTables) {        if (tryFindTableRule(each).isPresent()) {            return false;        }    }    return !logicTables.isEmpty();}public Optional<TableRule> tryFindTableRule(final String logicTableName) {    for (TableRule each : tableRules) {        if (each.getLogicTable().equalsIgnoreCase(logicTableName)) {            return Optional.of(each);        }    }    return Optional.absent();}

ShardingRule shardingRule = ShardingRule.builder()        .dataSourceRule(dataSourceRule)        .tableRules(Arrays.asList(orderTableRule, orderItemTableRule, userTableRule))        .bindingTableRules(Collections.singletonList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))))        .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))        .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))        .build();

SELECT od.user_id, od.order_id, oi.item_id, od.status FROM `t_user` tu join t_order od on tu.user_id=od.user_id join t_order_item oi on od.order_id=oi.order_id where tu.`status`='VALID' and tu.user_id=?

@RequiredArgsConstructor@Slf4jpublic final class ComplexRoutingEngine implements RoutingEngine {    // 分库分表规则    private final ShardingRule shardingRule;    // SQL请求参数，猪油一个user_id的值为10    private final List<Object> parameters;    // 逻辑表集合：t_order，t_order_item，t_user，三个逻辑表    private final Collection<String> logicTables;    // SQL解析结果    private final SQLStatement sqlStatement;    // 复杂路由的核心逻辑    @Override    public RoutingResult route() {        Collection<RoutingResult> result = new ArrayList<>(logicTables.size());        Collection<String> bindingTableNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);        // 遍历逻辑表集合        for (String each : logicTables) {            Optional<TableRule> tableRule = shardingRule.tryFindTableRule(each);            // 如果遍历的表配置了分库分表规则            if (tableRule.isPresent()) {                // 如果绑定关系表已经处理过，那么不需要再处理，例如t_order处理过，由于t_order_item与其是绑定关系，那么不需要再处理                if (!bindingTableNames.contains(each)) {                    // 根据当前遍历的逻辑表构造一个简单路由规则                    result.add(new SimpleRoutingEngine(shardingRule, parameters, tableRule.get().getLogicTable(), sqlStatement).route());                }                // 根据当前逻辑表，查找其对应的所有绑定表，例如根据t_order就能够查询出t_order和t_order_item；假如配置了.bindingTableRules(***t_point, t_point_detail***)，那么，根据t_point能查询出t_point和t_point_detail，其目的是N个绑定表只需要路由一个绑定表即可，因为绑定表之间的路由关系完全一致。                Optional<BindingTableRule> bindingTableRule = shardingRule.findBindingTableRule(each);                if (bindingTableRule.isPresent()) {                    bindingTableNames.addAll(Lists.transform(bindingTableRule.get().getTableRules(), new Function<TableRule, String>() {                        @Override                        public String apply(final TableRule input) {                            return input.getLogicTable();                        }                    }));                }            }        }        log.trace("mixed tables sharding result: {}", result);        // 如果是复杂路由，但是路由结果为空，那么抛出异常        if (result.isEmpty()) {            throw new ShardingJdbcException("Cannot find table rule and default data source with logic tables: '%s'", logicTables);        }        // 如果结果的size为1，那么直接返回即可        if (1 == result.size()) {            return result.iterator().next();        }        // 对刚刚的路由结果集合计算笛卡尔积，就是最终复杂的路由结果        return new CartesianRoutingEngine(result).route();    }}

@RequiredArgsConstructor@Slf4jpublic final class CartesianRoutingEngine implements RoutingEngine {    private final Collection<RoutingResult> routingResults;    @Override    public CartesianRoutingResult route() {        CartesianRoutingResult result = new CartesianRoutingResult();        // getDataSourceLogicTablesMap()的分析参考下面的分析        for (Entry<String, Set<String>> entry : getDataSourceLogicTablesMap().entrySet()) {            // 根据数据源&逻辑表，得到实际表集合，即[["t_user"],["t_order_0","t_order_1"]]            List<Set<String>> actualTableGroups = getActualTableGroups(entry.getKey(), entry.getValue());            // 把逻辑表名封装，TableUnit的属性有：数据源名称，逻辑表名，实际表名（这三个属性才能确定最终访问的表）            List<Set<TableUnit>> tableUnitGroups = toTableUnitGroups(entry.getKey(), actualTableGroups);            // 计算所有实际表的笛卡尔积            result.merge(entry.getKey(), getCartesianTableReferences(Sets.cartesianProduct(tableUnitGroups)));        }        log.trace("cartesian tables sharding result: {}", result);        return result;    }    // 得到数据源-逻辑表集合组成的Map    private Map<String, Set<String>> getDataSourceLogicTablesMap() {        // 这里很关键，是得到数据源的交集（上面分析时t_user逻辑表路由到数据源ds_jdbc_0，而t_order表路由到数据源ds_jdbc_0和ds_jdbc_1，数据源交集就是ds_jdbc_0）        Collection<String> intersectionDataSources = getIntersectionDataSources();        Map<String, Set<String>> result = new HashMap<>(routingResults.size());        for (RoutingResult each : routingResults) {            for (Entry<String, Set<String>> entry : each.getTableUnits().getDataSourceLogicTablesMap(intersectionDataSources).entrySet()) {                if (result.containsKey(entry.getKey())) {                    result.get(entry.getKey()).addAll(entry.getValue());                } else {                    result.put(entry.getKey(), entry.getValue());                }            }        }        // 得到的最终结果为数据源-逻辑表集合组成的Map，这里就是{"ds_jdbc_0":["t_order", "t_user"]}        return result;    }    ... ...}

[INFO ] 2018-05-08 11:13:02,044 --main-- [Sharding-JDBC-SQL] Logic SQL: SELECT od.user_id, od.order_id, oi.item_id, od.status FROM `t_user` tu join t_order od on tu.user_id=od.user_id join t_order_item oi on od.order_id=oi.order_id where tu.`status`='VALID' and tu.user_id=? ... ...[INFO ] 2018-05-08 11:13:02,059 --main-- [Sharding-JDBC-SQL] Actual SQL: ds_jdbc_0 ::: SELECT od.user_id, od.order_id, oi.item_id, od.status FROM t_user tu join t_order_0 od on tu.user_id=od.user_id join t_order_item_0 oi on od.order_id=oi.order_id where tu.`status`='VALID' and tu.user_id=? ::: [10] [INFO ] 2018-05-08 11:13:02,059 --main-- [Sharding-JDBC-SQL] Actual SQL: ds_jdbc_0 ::: SELECT od.user_id, od.order_id, oi.item_id, od.status FROM t_user tu join t_order_1 od on tu.user_id=od.user_id join t_order_item_1 oi on od.order_id=oi.order_id where tu.`status`='VALID' and tu.user_id=? ::: [10]