【源码】Sharding-JDBC源码分析之SQL路由及SingleSQLRouter单表路由

在【源码】Sharding-JDBC源码分析之ShardingSpherePreparedStatement的创建原理-CSDN博客文章中，介绍了在执行PreparedStatement的executeQuery()方法，进行数据库查询时，会执行createExecutionContext(queryContext)方法，创建执行上下文。代码如下：

/**
 * ShardingSphere的PreparedStatement
 */
public final class ShardingSpherePreparedStatement extends AbstractPreparedStatementAdapter {
    /**
     * 创建执行上下文
     * @param queryContext
     * @return
     */
    private ExecutionContext createExecutionContext(final QueryContext queryContext) {
        // 有效性校验
        SQLCheckEngine.check(queryContext.getSqlStatementContext(), queryContext.getParameters(),
                metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getRuleMetaData().getRules(),
                connection.getDatabaseName(), metaDataContexts.getMetaData().getDatabases(), null);
        // 创建执行上下文
        ExecutionContext result = kernelProcessor.generateExecutionContext(queryContext, metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()),
                metaDataContexts.getMetaData().getGlobalRuleMetaData(), metaDataContexts.getMetaData().getProps(), connection.getConnectionContext());
        // insert语句，查找并自动生成key
        findGeneratedKey(result).ifPresent(generatedKey -> generatedValues.addAll(generatedKey.getGeneratedValues()));
        return result;
    }
}

在改方法中，执行kernelProcessor.generateExecutionContext()方法，创建一个ExecutionContext对象。

KernelProcessor

KernelProcessor的源码如下：

package org.apache.shardingsphere.infra.context.kernel;

/**
 * 内核处理器
 */
public final class KernelProcessor {
    
    /**
     * 生成执行上下文
     */
    public ExecutionContext generateExecutionContext(final QueryContext queryContext, final ShardingSphereDatabase database, final ShardingSphereRuleMetaData globalRuleMetaData,
                                                     final ConfigurationProperties props, final ConnectionContext connectionContext) {
        // 创建路由上下文
        RouteContext routeContext = route(queryContext, database, props, connectionContext);
        // SQL 重写结果
        SQLRewriteResult rewriteResult = rewrite(queryContext, database, globalRuleMetaData, props, routeContext, connectionContext);
        // 创建执行上下文
        ExecutionContext result = createExecutionContext(queryContext, database, routeContext, rewriteResult);
        // 显示日志
        logSQL(queryContext, props, result);
        return result;
    }

    /**
     * 路由，创建路由上下文
     */
    private RouteContext route(final QueryContext queryContext, final ShardingSphereDatabase database, final ConfigurationProperties props, final ConnectionContext connectionContext) {
        // 创建SQL路由引擎，执行route()，获取路由上下文
        return new SQLRouteEngine(database.getRuleMetaData().getRules(), props).route(connectionContext, queryContext, database);
    }

}

在KernelProcessor的generateExecutionContext()方法，执行如下：

1）根据路由规则等信息，创建路由上下文对象 RouteContext；

1.1）创建一个SQLRouteEngine对象；

1.2）执行SQLRouteEngine的route()方法，创建一个RouteContext；

其中：路由上下文对象 RouteContext 中记录了数据源路由映射（逻辑数据源和实际数据源映射）以及表路由映射等信息。

2）根据路由上下文对象，配置的路由规则等，进行SQL重写，生成SQLRewriteResult对象；

3）创建执行单元，并保存到 ExecutionContext 执行上下文中；

4）SQL 日志处理；

SQLRouteEngine

SQLRouteEngine的源码如下：

package org.apache.shardingsphere.infra.route.engine;

/**
 * SQL 路由引擎
 */
@RequiredArgsConstructor
public final class SQLRouteEngine {
    
    // 配置的规则
    private final Collection<ShardingSphereRule> rules;
    
    // 配置的属性
    private final ConfigurationProperties props;

    /**
     * SQL 路由
     */
    public RouteContext route(final ConnectionContext connectionContext, final QueryContext queryContext, final ShardingSphereDatabase database) {
        SQLRouteExecutor executor = isNeedAllSchemas(queryContext.getSqlStatementContext().getSqlStatement()) ? new AllSQLRouteExecutor() : new PartialSQLRouteExecutor(rules, props);
        return executor.route(connectionContext, queryContext, database);
    }

    /**
     * 判断是否需要全部的schema
     */
    private boolean isNeedAllSchemas(final SQLStatement sqlStatement) {
// 针对MySQL数据库的显示表或表状态语句返回true；否则返回false
        return sqlStatement instanceof MySQLShowTablesStatement || sqlStatement instanceof MySQLShowTableStatusStatement;
    }
}

在route()方法中，执行如下：

1）先获取一个路由执行器；

路由执行器分为 AllSQLRouteExecutor（全路由执行器）和 PartialSQLRouteExecutor（部分路由执行器）。只有对于MySQL数据库的显示表或表状态的SQL语句才使用全路由执行器。

AllSQLRouteExecutor：全路由执行器即对配置的所有数据源执行操作的执行器。

2）执行路由执行器的route()方法，创建路由上下文对象；

PartialSQLRouteExecutor

PartialSQLRouteExecutor的源码如下：

package org.apache.shardingsphere.infra.route.engine.impl;

/**
 * 部分SQL路由执行器
 */
public final class PartialSQLRouteExecutor implements SQLRouteExecutor {

    // 配置的props
    private final ConfigurationProperties props;

    // SQL路由器，没有其他配置，默认有ShardingSQLRouter、SingleSQLRouter
    @SuppressWarnings("rawtypes")
    private final Map<ShardingSphereRule, SQLRouter> routers;
    
    public PartialSQLRouteExecutor(final Collection<ShardingSphereRule> rules, final ConfigurationProperties props) {
        this.props = props;
        routers = OrderedSPIRegistry.getRegisteredServices(SQLRouter.class, rules);
    }

    /**
     * SQL路由。根据配置的路由器，执行路由器的路由规则。
     * 可配置的路由器包括：数据库发现路由器、读写分离路由器、影子库路由器、分片路由器、单表路由器
     * @return
     */
    @Override
    @SuppressWarnings({"unchecked", "rawtypes"})
    public RouteContext route(final ConnectionContext connectionContext, final QueryContext queryContext, final ShardingSphereDatabase database) {
        RouteContext result = new RouteContext();
        // 从提示中获取数据源
        Optional<String> dataSourceName = findDataSourceByHint(queryContext.getSqlStatementContext(), database.getResourceMetaData().getDataSources());
        if (dataSourceName.isPresent()) {
            result.getRouteUnits().add(new RouteUnit(new RouteMapper(dataSourceName.get(), dataSourceName.get()), Collections.emptyList()));
            return result;
        }
        // 遍历路由器，创建路由上下文
        // 路由器包括：数据库发现路由器、读写分离路由器、影子库路由器、分片路由器、单表路由器
        for (Entry<ShardingSphereRule, SQLRouter> entry : routers.entrySet()) {
            if (result.getRouteUnits().isEmpty()) {
                // 创建路由上下文
                result = entry.getValue().createRouteContext(queryContext, database, entry.getKey(), props, connectionContext);
            } else {
                // 装饰路由上下文
                entry.getValue().decorateRouteContext(result, queryContext, database, entry.getKey(), props, connectionContext);
            }
        }
        // 如果没有路由单元，且数据源只有一个，创建一个路由单元，添加到路由上下文中
        if (result.getRouteUnits().isEmpty() && 1 == database.getResourceMetaData().getDataSources().size()) {
            String singleDataSourceName = database.getResourceMetaData().getDataSources().keySet().iterator().next();
            result.getRouteUnits().add(new RouteUnit(new RouteMapper(singleDataSourceName, singleDataSourceName), Collections.emptyList()));
        }
        return result;
    }

    /**
     * 获取提示指定的数据源
     */
    private Optional<String> findDataSourceByHint(final SQLStatementContext<?> sqlStatementContext, final Map<String, DataSource> dataSources) {
        Optional<String> result;
        // 通过HintManager指定，如指定了写库
        if (HintManager.isInstantiated() && HintManager.getDataSourceName().isPresent()) {
            result = HintManager.getDataSourceName();
        } else {
            // 或者通过sql语句中的提示语指定数据源
            result = ((CommonSQLStatementContext<?>) sqlStatementContext).findHintDataSourceName();
        }
        if (result.isPresent() && !dataSources.containsKey(result.get())) {
            throw new SQLHintDataSourceNotExistsException(result.get());
        }
        return result;
    }
}

核心route()方法执行如下：

1）执行findDataSourceByHint()，获取提示指定的数据源；

1.1）先从 HintManager 单例中获取（如通过HintManager.setDataSourceName()设置）；

1.2）如果没有设置，则解析 SQL 语句，查找 SQL 语句中的提示语中设置的数据源；

2）如果以上没有找到数据源，则遍历设置的路由器，执行路由器创建路由上下文或装饰路由上下文；

2.1）在构造方法中，通过配置的规则，使用 SPI 获取对应的路由器。可配置的路由器包括：数据库发现路由器（DatabaseDiscoverySQLRouter）、读写分离路由器（ReadwriteSplittingSQLRouter）、影子库路由器（ShadowSQLRouter）、分片路由器（ShardingSQLRouter）、单表路由器（SingleSQLRouter）；

2.2）每个路由器都有设置了顺序，所以通过SPI获取后，路由的顺序为ShardingSQLRouter、SingleSQLRouter、ReadwriteSplittingSQLRouter、DatabaseDiscoverySQLRouter、ShadowSQLRouter；

3）如果没有配置路由规则，且只配置了一个数据源，则创建一个路由单元，加入到路由上下文中；

4）返回路由上下文RouteContext；

ShardingSQLRouter

如果没有通过提示语指定路由的数据源，则从SPI获取路由器之后，优先执行ShardingSQLRouter分片路由器，即执行路由器的createRouteContext()方法。

详见：【源码】Sharding-JDBC源码分析之SQL中分片键路由ShardingSQLRouter的原理-CSDN博客

SingleSQLRouter

ShardingSQLRouter分片SQL路由器执行之后，接着执行SingleSQLRouter单表（此处的单表特指没有设置分片规则的表）SQL路由器，该路由器一定会执行，因为在解析配置规则生成规则对象时，默认会添加SingleRule。在此处进行SQL路由时，其中的routers包含了SingleSQLRouter。

详见：【源码】Sharding-JDBC源码分析之分片规则生成器DatabaseRuleBuilder实现规则配置到规则对象的生成原理-CSDN博客

SingleSQLRouter的源码如下：

package org.apache.shardingsphere.single.route;

/**
 * 单表SQL路由器
 */
public final class SingleSQLRouter implements SQLRouter<SingleRule> {

    /**
     * 创建路由上下文
     * @param queryContext 查询上下文
     * @param database 数据库信息
     * @param rule 单表规则
     * @param props 配置的属性
     * @param connectionContext 连接上下文
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Override
    public RouteContext createRouteContext(final QueryContext queryContext, final ShardingSphereDatabase database, final SingleRule rule,
                                           final ConfigurationProperties props, final ConnectionContext connectionContext) {
        // 如果只配置了一个数据源
        if (1 == database.getResourceMetaData().getDataSources().size()) {
            return createSingleDataSourceRouteContext(rule, database);
        }
        RouteContext result = new RouteContext();
        // 获取SQL语句上下文
        SQLStatementContext<?> sqlStatementContext = queryContext.getSqlStatementContext();
        // 有效性检验
        Optional<SingleMetaDataValidator> validator = SingleMetaDataValidatorFactory.newInstance(sqlStatementContext.getSqlStatement());
        validator.ifPresent(optional -> optional.validate(rule, sqlStatementContext, database));
        // 从SQL语句上下文中获取表，查找在单表规则中配置的表，创建QualifiedTable对象
        Collection<QualifiedTable> singleTableNames = getSingleTableNames(sqlStatementContext, database, rule, result);
        // 所有表在同一个数据源的校验
        if (!singleTableNames.isEmpty()) {
            validateSameDataSource(sqlStatementContext, rule, props, singleTableNames, result);
        }
        // 创建单表路由引擎实例，执行route()方法
        SingleRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(result, rule));
        return result;
    }

    /**
     * 装饰路由上下文呢
     * @param routeContext 路由上下文
     * @param queryContext 查询上下文
     * @param database database
     * @param rule rule
     * @param props configuration properties
     * @param connectionContext connection context
     */
    @Override
    public void decorateRouteContext(final RouteContext routeContext, final QueryContext queryContext, final ShardingSphereDatabase database,
                                     final SingleRule rule, final ConfigurationProperties props, final ConnectionContext connectionContext) {
        // SQL 语句上下文呢
        SQLStatementContext<?> sqlStatementContext = queryContext.getSqlStatementContext();
        // 从单表规则中查找当前sql语句中的表，返回sql语句中的单表
        Collection<QualifiedTable> singleTableNames = getSingleTableNames(sqlStatementContext, database, rule, routeContext);
        if (singleTableNames.isEmpty()) {
            return;
        }
        validateSameDataSource(sqlStatementContext, rule, props, singleTableNames, routeContext);
        // 创建单表路由引擎，执行路由
        SingleRouteEngineFactory.newInstance(singleTableNames, sqlStatementContext.getSqlStatement()).ifPresent(optional -> optional.route(routeContext, rule));
    }

    /**
     * 创建单数据源的路由上下文对象
     * @param rule
     * @param database
     * @return
     */
    private RouteContext createSingleDataSourceRouteContext(final SingleRule rule, final ShardingSphereDatabase database) {
        // 从配置中获取逻辑数据源
        String logicDataSource = rule.getDataSourceNames().iterator().next();
        // 从数据库信息中获取真实数据源
        String actualDataSource = database.getResourceMetaData().getDataSources().keySet().iterator().next();
        RouteContext result = new RouteContext();
        // 创建路由映射及路由单元
        result.getRouteUnits().add(new RouteUnit(new RouteMapper(logicDataSource, actualDataSource), Collections.emptyList()));
        return result;
    }

    /**
     * 获取单表名称
     * @param sqlStatementContext sql语句上下文
     * @param database 数据库
     * @param rule 单表规则
     * @param routeContext 当前的路由上下文
     * @return
     */
    private static Collection<QualifiedTable> getSingleTableNames(final SQLStatementContext<?> sqlStatementContext,
                                                                  final ShardingSphereDatabase database, final SingleRule rule, final RouteContext routeContext) {
        // 获取数据库类型
        DatabaseType databaseType = sqlStatementContext.getDatabaseType();
        // 获取合格表
        Collection<QualifiedTable> result = getQualifiedTables(database, databaseType, sqlStatementContext.getTablesContext().getTables());
        // 如果是索引操作
        if (result.isEmpty() && sqlStatementContext instanceof IndexAvailable) {
            result = IndexMetaDataUtil.getTableNames(database, databaseType, ((IndexAvailable) sqlStatementContext).getIndexes());
        }
        // 如果路由单元为空 && 是建表语句，则返回当前的合格表，否则从单表规则中匹配当前的合格表
        return routeContext.getRouteUnits().isEmpty() && sqlStatementContext.getSqlStatement() instanceof CreateTableStatement ? result : rule.getSingleTableNames(result);
    }

    /**
     * 获取满足条件的表。其中QualifiedTable中，schema为表的owner，如果不存在，默认为logic_db
     * @param database
     * @param databaseType
     * @param tableSegments sql语句中的表部分，记录sql语句涉及的表
     * @return
     */
    private static Collection<QualifiedTable> getQualifiedTables(final ShardingSphereDatabase database, final DatabaseType databaseType, final Collection<SimpleTableSegment> tableSegments) {
        Collection<QualifiedTable> result = new LinkedList<>();
        // 获取默认的schema名称。默认为databaseName，即logic_db
        String schemaName = DatabaseTypeEngine.getDefaultSchemaName(databaseType, database.getName());
        // 遍历表部分
        for (SimpleTableSegment each : tableSegments) {
            // 获取表中定义的schema
            String actualSchemaName = each.getOwner().map(optional -> optional.getIdentifier().getValue()).orElse(schemaName);
            // 创建合格表
            result.add(new QualifiedTable(actualSchemaName, each.getTableName().getIdentifier().getValue()));
        }
        return result;
    }

    /**
     * 同源校验。sql语句中的所有表是否在同一个数据源中
     * @param sqlStatementContext
     * @param rule
     * @param props
     * @param singleTableNames
     * @param routeContext
     */
    private static void validateSameDataSource(final SQLStatementContext<?> sqlStatementContext, final SingleRule rule,
                                               final ConfigurationProperties props, final Collection<QualifiedTable> singleTableNames, final RouteContext routeContext) {
        // 获取属性中配置的SQL联合类型
        String sqlFederationType = props.getValue(ConfigurationPropertyKey.SQL_FEDERATION_TYPE);
        boolean allTablesInSameDataSource = !"NONE".equals(sqlFederationType)
                // 如果配置不等于 NONE，则为查询语句 || 所有单表在同一个数据源中，则返回true；否则返回false
                ? sqlStatementContext instanceof SelectStatementContext || rule.isSingleTablesInSameDataSource(singleTableNames)
                // 如果配置为 NONE（默认值），则所有的表都需要是同一个数据源，包括设置了分片规则要执行的实际表
                : rule.isAllTablesInSameDataSource(routeContext, singleTableNames);
        Preconditions.checkState(allTablesInSameDataSource, "All tables must be in the same datasource.");
    }
    
    @Override
    public int getOrder() {
        return SingleOrder.ORDER;
    }
    
    @Override
    public Class<SingleRule> getTypeClass() {
        return SingleRule.class;
    }
}

在createRouteContext()和decorateRouteContext()方法中，功能类似。核心逻辑如下：

1）在createRouteContext()中，新添加一个判断。如果只配置了一个数据源，那么获取数据源名称，创建一个数据源的映射，然后创建一个路由单元，添加到新创建的RouteContext，结束方法；

2）从SQL语句中获取表部分，每个表创建一个QualifiedTable对象，其中schema默认为logic_db；

3）进行同一个数据源的有效性判断，如果校验不通过，抛出异常；

此处针对SQL联邦类型进行判断，如果设置了非NONE的值，对于查询语句或所有涉及的单表都在同一个数据源，满足这两个条件的任意一个验证结果都为有效；如果是NONE（默认值），本次SQL操作涉及的所有最终执行的真实表（包括分片后的真实表以及单表），必现在同一个数据源中，否则验证无效，抛出异常；

4）通过SingleRouteEngineFactory.newInstance()，创建一个路由引擎，执行route()方法，添加路由单表的路由信息；

对于存在QualifiedTable对象的操作，返回的是SingleStandardRouteEngine；如果是Schema的增删改操作，返回SingleDatabaseBroadcastRouteEngine；

SingleStandardRouteEngine

对于SQL语句中存在单表的操作，通过SingleStandardRouteEngine执行路由，创建或合并路由上下文对象。

SingleStandardRouteEngine的源码如下：

package org.apache.shardingsphere.single.route.engine;

/**
 * 标准单表的路由引擎
 */
@RequiredArgsConstructor
public final class SingleStandardRouteEngine implements SingleRouteEngine {
    
    private final Collection<QualifiedTable> singleTableNames;
    
    private final SQLStatement sqlStatement;
    
    /**
     * 单表的路由
     * @param routeContext 路由上下文
     * @param singleRule 单表规则
     */
    public void route(final RouteContext routeContext, final SingleRule singleRule) {
        // 如果路由单元为空 || 是查询语句
        if (routeContext.getRouteUnits().isEmpty() || sqlStatement instanceof SelectStatement) {
            route0(routeContext, singleRule);
        } else {
            // 重新创建一个路由单元
            RouteContext newRouteContext = new RouteContext();
            route0(newRouteContext, singleRule);
            // 路由单元合并
            combineRouteContext(routeContext, newRouteContext);
        }
    }

    /**
     * 合并路由上下文
     * @param routeContext
     * @param newRouteContext
     */
    private void combineRouteContext(final RouteContext routeContext, final RouteContext newRouteContext) {
        // 获取路由上下文的路由单元。key为数据源的逻辑名，value为路由单元
        Map<String, RouteUnit> dataSourceRouteUnits = getDataSourceRouteUnits(newRouteContext);
        // 移除不在newRouteContext中的路由单元
        routeContext.getRouteUnits().removeIf(each -> !dataSourceRouteUnits.containsKey(each.getDataSourceMapper().getLogicName()));
        // 遍历，进行表映射的合并
        for (Entry<String, RouteUnit> entry : dataSourceRouteUnits.entrySet()) {
            routeContext.putRouteUnit(entry.getValue().getDataSourceMapper(), entry.getValue().getTableMappers());
        }
    }

    /**
     * 获取路由上下文的路由单元。key为数据源的逻辑名，value为路由单元
     * @param newRouteContext
     * @return
     */
    private Map<String, RouteUnit> getDataSourceRouteUnits(final RouteContext newRouteContext) {
        return newRouteContext.getRouteUnits().stream().collect(Collectors.toMap(each -> each.getDataSourceMapper().getLogicName(), Function.identity()));
    }

    /**
     * 路由
     * @param routeContext 空的路由上下文
     * @param rule 单表规则
     */
    private void route0(final RouteContext routeContext, final SingleRule rule) {
        // 如果是建表语句
        if (sqlStatement instanceof CreateTableStatement) {
            // 获取第一个表
            QualifiedTable table = singleTableNames.iterator().next();
            // 从单表规则中获取匹配的schema和表的DataNode
            Optional<DataNode> dataNodeOptional = rule.findSingleTableDataNode(table.getSchemaName(), table.getTableName());
            // 没找到
            if (!dataNodeOptional.isPresent()) {
                // 指定新数据源名称。如果没有默认的数据源，从可用的数据源中随机获取一个数据源，否则为默认数据源
                String dataSourceName = rule.assignNewDataSourceName();
                // 创建路由映射及路由单元
                routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), Collections.singleton(new RouteMapper(table.getTableName(), table.getTableName()))));
            } else if (CreateTableStatementHandler.ifNotExists((CreateTableStatement) sqlStatement)) {
                // 从查找到的DataNode中获取数据源。如Postgre、OpenGauss没有数据源，只有schema
                String dataSourceName = dataNodeOptional.map(DataNode::getDataSourceName).orElse(null);
                // 创建路由映射及路由单元
                routeContext.getRouteUnits().add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), Collections.singleton(new RouteMapper(table.getTableName(), table.getTableName()))));
            } else {
                throw new TableExistsException(table.getTableName());
            }
        } else if (sqlStatement instanceof AlterTableStatement || sqlStatement instanceof DropTableStatement || rule.isAllTablesInSameDataSource(routeContext, singleTableNames)) {
            fillRouteContext(rule, routeContext, rule.getSingleTableNames(singleTableNames));
        }
    }

    /**
     * 填充路由上下文
     * @param singleRule 单表规则
     * @param routeContext 路由上下文
     * @param logicTables SQL中涉及的表
     */
    private void fillRouteContext(final SingleRule singleRule, final RouteContext routeContext, final Collection<QualifiedTable> logicTables) {
        // 遍历QualifiedTable
        for (QualifiedTable each : logicTables) {
            String tableName = each.getTableName();
            // 通过schema查找
            Optional<DataNode> dataNode = singleRule.findSingleTableDataNode(each.getSchemaName(), tableName);
            // 如果没找到，抛异常
            if (!dataNode.isPresent()) {
                throw new SingleTableNotFoundException(tableName);
            }
            String dataSource = dataNode.get().getDataSourceName();
            // put路由单元到路由单元集合中
            routeContext.putRouteUnit(new RouteMapper(dataSource, dataSource), Collections.singletonList(new RouteMapper(tableName, tableName)));
        }
    }
}

在route()方法中，执行如下：

1）如果路由单元为空 || 是查询语句，直接执行route0()方法；

在route0()中，执行如下：

1.1）如果是执行的SQL语句是建表语句；

1.1.1）如果表是一个新的表，即当前不存在的，则创建路由映射和路由单元，添加到路由上下文中；

1.1.2）否则判断对应的建表语句是否添加了 is not exists 的标注，如果有，则创建路由映射和路由单元，添加到路由上下文中；

1.1.3）否则抛异常，表明要创建的表已存在；

1.2）否则，如果是修改表 || 删除表 || 当前路由上下文以及单表都在同一个数据源中，则进行路由上下文的填充。通过遍历QualifiedTable，创建创建路由映射和路由单元，添加到路由上下文中；

如果是查询语句，且存在单表，那么SQL语句中涉及的所有表（包括分片后的实际表、单表）都必现在同一个数据源中，否则路由上下文内容没有变化。因为在单条查询语句中，所涉及的真实表必现在同一个数据源中，否则无法查询。单表的逻辑表名和真实表名是一致的，所以无需额外路由；

2）否则重新创建一个路由单元，执行route0()方法，然后进行路由合并；

2.1）此处新创建一个路由单元，然后执行route0()，和 1）中执行route1()的不同之处在于，在1.2）中判断所有表在同一个数据源中，只需要判断单表，因为此时的分片表为空，其他都一样；

2.2）路由上下文合并。将同一个数据源中的表进行合并；

小结

限于篇幅，本篇先分析到这里，以下做一个小结：

1）ShardingSpherePreparedStatement在开始真正执行SQL之前，会先通过KernelProcessor的generateExecutionContext()创建执行上下文ExecutionContext对象；

2）在创建ExecutionContext对象前，先通过SQLRouteEngine的route()方法进行路由，创建路由上下文RouteContext对象；

3）在SQLRouteEngine的route()方法中，先获取一个路由执行器，执行路由执行器的route()方法，创建路由上下文对象；

路由执行器分为 AllSQLRouteExecutor（全路由执行器，即在所有的配置的数据源中执行该SQL语句）和 PartialSQLRouteExecutor（部分路由执行器）。只有对于MySQL数据库的显示表或表状态的SQL语句才使用全路由执行器；

4）在 PartialSQLRouteExecutor 中通过route()进行路由时，执行如下：

4.1）执行findDataSourceByHint()，判断是否通过HintManager或SQL中的注释指定了数据源。如果有，则创建路由映射、路由单元，添加到新创建的RouteContext路由上下文中，返回路由上下文对象；

4.2）如果没有通过Hint指定数据源，则遍历设置的路由器，执行路由器创建路由上下文或装饰路由上下文；

可配置的路由器包括：分片路由器（ShardingSQLRouter）、单表路由器（SingleSQLRouter）、读写分离路由器（ReadwriteSplittingSQLRouter）、数据库发现路由器（DatabaseDiscoverySQLRouter）、影子库路由器（ShadowSQLRouter）。并按以上顺序执行；

4.3）分片路由器ShardingSQLRouter是根据设置的分片键，解析SQL语句中的Insert的values部分或SQL语句中的Where部分，最早执行分片算法中的doSharding()，获取路由的数据源和表。创建路由映射、路由单元，添加到新创建的RouteContext路由上下文中；

详见：【源码】Sharding-JDBC源码分析之SQL中分片键路由ShardingSQLRouter的原理-CSDN博客

4.4）单表（没有设置分片的表）路由器SingleSQLRouter是系统默认添加的路由器，解析SQL语句中的表，查找其中的单表，创建路由映射、路由单元，添加到RouteContext路由上下文中；

a）解析SQL语句中的表，每个表创建一个QualifiedTable对象，其中schema默认为logic_db；

b）同源有效性判断。如果校验不通过，抛出异常。针对SQL联邦类型进行判断，如果设置了非NONE的值，对于查询语句或所有涉及的单表都在同一个数据源，满足这两个条件的任意一个验证结果都为有效；如果是NONE（默认值），本次SQL操作涉及的所有最终执行的真实表（包括分片后的真实表以及单表）；

c）通过SingleStandardRouteEngine的route()方法进行最终路由，对单表创建路由映射、路由单元，添加或合并到RouteContext路由上下文中。对于查询语句，此处会进行全表的同源再次判断。（如果是Schema的增删改操作，在SingleDatabaseBroadcastRouteEngine中进行路由）；

关于本篇内容你有什么自己的想法或独到见解，欢迎在评论区一起交流探讨下吧。

原文地址：https://blog.csdn.net/JingAi_jia917/article/details/143235364

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：excel版数独游戏（已完成）
下一篇：【源码】Sharding-JDBC源码分析之SQL中分片键路由ShardingSQLRouter的原理

上海市计算机学会竞赛平台2022年8月月赛丙组屏幕比例
现实生活中，我们一般把屏幕的宽度和高度的比例，称为屏幕比例，或称为屏幕长宽比。其中第一个数字为屏幕分辨率的水平像素，第二个数字为屏幕分辨率的竖直像素。的形式输入，请你按给定格式输出该屏幕的长宽比。(我
阅读更多2024-11-22
Linux环境基础开发工具的使用（yum、vim、gcc、g++、gdb、make/Makefile）
本文介绍了yum 包管理工具、Vim 编辑器、gcc/g++ 编译器、gdb 调试器、编译原理及 Makefile 的使用，同时还配备了如何使用，以及图解。旨在帮助读者更好地理解和应用这些工具与技术。
阅读更多2024-11-22
H.264/H.265播放器EasyPlayer.js网页全终端安防视频流媒体播放器关于iOS不能系统全屏
EasyPlayer.js播放器不仅支持H.264与H.265视频编码格式，也能支持WebSocket-FLV、HTTP-FLV、HLS（m3u8）、WebRTC、ws-fmp4、http-fmp4等
阅读更多2024-11-22
xiaolin coding 图解网络笔记——基础篇
协议栈的内部分为几个部分，分别承担不同的工作。上下关系有一定的规则，上面的部分会向下面的部分委托工作，下面的部分收到委托的工作并执行。应用程序（浏览器）通过调用 Socket 库。来委托协议栈工作。协
阅读更多2024-11-22
OpenHarmony-2.DeviceInfo适配
ohos.boot.sn参数值的获取方式：首先从cmdline（由uboot生成）获取，如果获取到的是sn值则直接读取，若获取的是文件路径，则从文件中读取；当获取不到时从默认的Sn文件读取，默认文件为
阅读更多2024-11-22
C语言-指针作为函数返回值及二级指针
对于上面的两个例子，func() 运行结束后 n 的内存依然保持原样，值还是 100，如果使用及时也能够得到正确的数据，如果有其它函数被调用就会覆盖这块内存，得到的数据就失去了意义。第一个例子在调用其
阅读更多2024-11-22
【C语言】遗传算法matlab程序
适应度函数通常是根据所求解的问题定义的，其目的是评价每个解决方案（个体）的好坏。例如，如果你是在寻找一个函数的最大值，适应度可能是负值，因为MATLAB的排序函数默认会按升序排列，所以较小的数值会被认
阅读更多2024-11-22
【Vue3新工具】Pinia.js：提升开发效率，更轻量、更高效的状态管理方案！
Pinia.js是Vue3官方推荐的轻量级状态管理库，旨在替代Vuex。它提供了响应式状态管理，支持TypeScript，简化了模块化和插件系统。Pinia优化了开发体验，减少了样板代码，提高了性能。
阅读更多2024-11-22
python中的OS模块的基本使用
🎉🎉🎉欢迎来到我的博客,我是一名自学了2年半前端的大一学生,熟悉的技术是JavaScript与Vue.目前正在往全栈方向前进, 如果我的博客给您带来了帮助欢迎您关注我,我将会持续不断的更新文章!!!🙏
阅读更多2024-11-22
Parker派克防爆电机在实际应用中的安全性能如何保证？
Parker防爆电机通过防爆外壳、国际安全标准、专用防爆认证、低火花设计、定制化绕组、应用案例验证及温度管理，确保实际应用中的安全性能，防止爆炸风险，保障安全。
阅读更多2024-11-22