mysql源码解析 初始化,sharding-jdbc 执行流程源码分析-初始化

和其他应对高并发，数据量大的方案比，分库分表通常是最实用，最朴素的一个方案，既简单又有效。但是分库分表后怎么可以对业务层代码影响降到最小，是程序员们需要解决的问题，下边看一下一个开源组件 sharding-jdbc，应用程序只需引入jar然后通过编写分片策略方法、和相关的配置，即可实现分库分表。

本篇文章主要解释以下内容，基于 4.0.1 版本

研究源码前，首先思考几个问题

1、sharding-jdbc 为什么可以和 Mybatis\ibaits\hibernate\jpa\spring data template 结合使用，换句话说：为什么不依赖orm

2、内部运行流程分别是怎么实现的

(1)初始化过程

(2)sql 解析

(3)sql 提取

(4)sql 路由

(5)sql 替换

(6)sql 执行

1、sharding-jdbc 为什么不依赖orm

sharding-jdbc 的执行入口是 ShardingDataSource 此类实现了 javax.sql.DataSource ，javax 的 x 是extension 的意思，也就是扩展包，为了使 java 基础包更加通用，在上边加了一层扩展。javax.sql.DataSource 接口只有一个方法 getConnection ， 几乎所有的 orm 框架都是用 DataSource 接口获取数据库连接的。 所以才使得 sharding-jdbc 不依赖具体的 orm 层框架成为可能。

其中 ShardingDataSource 构造函数就是，初始化的入口。

其中 getConnection 方法，是执行阶段的入口。

public class ShardingDataSource extends AbstractDataSourceAdapter {

private final ShardingRuntimeContext runtimeContext;

//初始化阶段

public ShardingDataSource(final Map dataSourceMap, final ShardingRule shardingRule, final Properties props) throws SQLException {

//匹配数据库类型

super(dataSourceMap);

checkDataSourceType(dataSourceMap);

runtimeContext = new ShardingRuntimeContext(dataSourceMap, shardingRule, props, getDatabaseType());

}

private void checkDataSourceType(final Map dataSourceMap) {

for (DataSource each : dataSourceMap.values()) {

Preconditions.checkArgument(!(each instanceof MasterSlaveDataSource), "Initialized data sources can not be master-slave data sources.");

}

}

//执行阶段

@Override

public final ShardingConnection getConnection() {

return new ShardingConnection(getDataSourceMap(), runtimeContext, TransactionTypeHolder.get());

}

}

2、内部运行流程分别是怎么实现的

(1)初始化阶段

涉及的相关类 uml 图

image.png

初始化分为3个步骤：

根据配置信息 shardingRuleConfiguration 创建分片规则 ShardingRule

匹配数据库类型 databaseType

创建 sql 解析引擎 SQLParseEngine 、sql 执行引擎 ShardingExecuteEngine

保存数据库、数据表信息。

下边我们一个一个分析，以 spring namespace 方法创建为例。

1、根据配置信息 shardingRuleConfiguration 创建分片规则 ShardingRule

public class SpringShardingDataSource extends ShardingDataSource {

public SpringShardingDataSource(final Map dataSourceMap, final ShardingRuleConfiguration shardingRuleConfiguration, final Properties props) throws SQLException {

//new ShardingRule 创建分片规则

super(dataSourceMap, new ShardingRule(shardingRuleConfiguration, dataSourceMap.keySet()), props);

}

}

spring namespace 会根据 xml 的配置创建好用户配置信息类ShardingRuleConfiguration 包括：

TableRuleConfiguration:逻辑表名 + 可路由到的数据数据节点名(数据源名+表名)支持表达式

bindingTableGroups 绑定表组：例如order + order_item 表

broadcastTables 广播表：例如配置信息需要每个数据库都有一张这样的表，需要修改的时候，那么需要广播对吧!

defaultDataSourceName 默认数据源名称

defaultDatabaseShardingStrategyConfig 默认分库策略

defaultTableShardingStrategyConfig 默认分表策略

其中分片策略配置包括：暗示策略Hint基于ThraedLocal

表达式分片策略Inline基于groovy 的 Inline 表达式

复合分片策略 Complex 基于多列 、不分库策略None，标准策略Standard基于单列。

然后根据 shardingRuleConfiguration和数据源集合，创建分片规则 ShardingRule

public ShardingRule(final ShardingRuleConfiguration shardingRuleConfig, final Collection dataSourceNames) {

Preconditions.checkArgument(null != shardingRuleConfig, "ShardingRuleConfig cannot be null.");

Preconditions.checkArgument(null != dataSourceNames && !dataSourceNames.isEmpty(), "Data sources cannot be empty.");

this.ruleConfiguration = shardingRuleConfig;

//根据配置创建所有数据源集合，主从复制需要特殊处理(只是保留一个主从公共数据源)

shardingDataSourceNames = new ShardingDataSourceNames(shardingRuleConfig, dataSourceNames);

//根据分片配置，创建分片规则

tableRules = createTableRules(shardingRuleConfig);

broadcastTables = shardingRuleConfig.getBroadcastTables();

//创建 表分片key与分片规则完全一致 的规则

bindingTableRules = createBindingTableRules(shardingRuleConfig.getBindingTableGroups());

//创建默认的分库策略

defaultDatabaseShardingStrategy = createDefaultShardingStrategy(shardingRuleConfig.getDefaultDatabaseShardingStrategyConfig());

defaultTableShardingStrategy = createDefaultShardingStrategy(shardingRuleConfig.getDefaultTableShardingStrategyConfig());

defaultShardingKeyGenerator = createDefaultKeyGenerator(shardingRuleConfig.getDefaultKeyGeneratorConfig());

//主从规则

masterSlaveRules = createMasterSlaveRules(shardingRuleConfig.getMasterSlaveRuleConfigs());

encryptRule = createEncryptRule(shardingRuleConfig.getEncryptRuleConfig());

}

其中最重要的方法 createTableRules 根据分片配置以逻辑表为单位创建数据节点，通常一个TableRule(一个逻辑表规则) 对应多个分表，分库。

//以每个表为单位创建分片规则

private Collection createTableRules(final ShardingRuleConfiguration shardingRuleConfig) {

Collection tableRuleConfigurations = shardingRuleConfig.getTableRuleConfigs();

Collection result = new ArrayList<>(tableRuleConfigurations.size());

for (TableRuleConfiguration each : tableRuleConfigurations) {

//创建分片规则

result.add(new TableRule(each, shardingDataSourceNames, getDefaultGenerateKeyColumn(shardingRuleConfig)));

}

return result;

}

然后创建初始化 TableRule

1、将逻辑表名转成小写

2、获取用户配置的真实表名，因为可以配置表达式所以这里需要计算一下。

3、将真实 datasource + 表名 (逗号分隔) 封装成 DataNode

如果用户没有配置真实表，那么默认使用逻辑表名充当真实表名

4、根据分库策略配置项，创建分库策略。根据分表策略配置项，创建分表策略

5、非默认策略必须配置一个想要路由到的真实表

//tableRuleConfig 为分片规则配置项

public TableRule(final TableRuleConfiguration tableRuleConfig, final ShardingDataSourceNames shardingDataSourceNames, final String defaultGenerateKeyColumn) {

//将逻辑表名转成小写

logicTable = tableRuleConfig.getLogicTable().toLowerCase();

//将真实表名表达式，转换为多个 datasource +表名

List dataNodes = new InlineExpressionParser(tableRuleConfig.getActualDataNodes()).splitAndEvaluate();

//按照顺序存储 DataNode (datasource +表名)

dataNodeIndexMap = new HashMap<>(dataNodes.size(), 1);

//将真实 datasource + 表名 封装成 DataNode

actualDataNodes = isEmptyDataNodes(dataNodes)

? generateDataNodes(tableRuleConfig.getLogicTable(), shardingDataSourceNames.getDataSourceNames()) : generateDataNodes(dataNodes, shardingDataSourceNames.getDataSourceNames());

//单纯存放真实表名，去重

actualTables = getActualTables();

//根据分库策略配置项，创建分库策略

databaseShardingStrategy = null == tableRuleConfig.getDatabaseShardingStrategyConfig() ? null : ShardingStrategyFactory.newInstance(tableRuleConfig.getDatabaseShardingStrategyConfig());

//根据分表策略配置项，创建分表策略

tableShardingStrategy = null == tableRuleConfig.getTableShardingStrategyConfig() ? null : ShardingStrategyFactory.newInstance(tableRuleConfig.getTableShardingStrategyConfig());

generateKeyColumn = getGenerateKeyColumn(tableRuleConfig.getKeyGeneratorConfig(), defaultGenerateKeyColumn);

shardingKeyGenerator = containsKeyGeneratorConfiguration(tableRuleConfig)

? new ShardingKeyGeneratorServiceLoader().newService(tableRuleConfig.getKeyGeneratorConfig().getType(), tableRuleConfig.getKeyGeneratorConfig().getProperties()) : null;

//非默认策略必须配置一个想要路由到的真实表

checkRule(dataNodes);

}

将真实 datasource + 表名 (逗号分隔) 封装成 DataNode

private List generateDataNodes(final String logicTable, final Collection dataSourceNames) {

List result = new LinkedList<>();

int index = 0;

//为每个数据源创建一套

for (String each : dataSourceNames) {

DataNode dataNode = new DataNode(each, logicTable);

result.add(dataNode);

//保存数据节点的顺序

dataNodeIndexMap.put(dataNode, index);

actualDatasourceNames.add(each);

//按照数据源维度，存放真实数据表

addActualTable(dataNode.getDataSourceName(), dataNode.getTableName());

index++;

}

return result;

}

public DataNode(final String dataNode) {

if (!isValidDataNode(dataNode)) {

throw new ShardingConfigurationException("Invalid format for actual data nodes: '%s'", dataNode);

}

//根据.分隔 前半部分为数据源，后边为真实表

List segments = Splitter.on(DELIMITER).splitToList(dataNode);

dataSourceName = segments.get(0);

tableName = segments.get(1);

}

根据分库策略配置项，创建分库策略。根据分表策略配置项，创建分表策略，这里分表策略和分库策略的创建逻辑都是一样的。包括默认的分库分表策略。

1、标准分片策略

2、Inline表达式分片策略

3、复合分片策略

4、threadLocal 分片策略

public static ShardingStrategy newInstance(final ShardingStrategyConfiguration shardingStrategyConfig) {

//标准分片策略

if (shardingStrategyConfig instanceof StandardShardingStrategyConfiguration) {

return new StandardShardingStrategy((StandardShardingStrategyConfiguration) shardingStrategyConfig);

}

//Inline表达式分片策略

if (shardingStrategyConfig instanceof InlineShardingStrategyConfiguration) {

return new InlineShardingStrategy((InlineShardingStrategyConfiguration) shardingStrategyConfig);

}

//复合分片策略

if (shardingStrategyConfig instanceof ComplexShardingStrategyConfiguration) {

return new ComplexShardingStrategy((ComplexShardingStrategyConfiguration) shardingStrategyConfig);

}

//threadLocal 分片策略

if (shardingStrategyConfig instanceof HintShardingStrategyConfiguration) {

return new HintShardingStrategy((HintShardingStrategyConfiguration) shardingStrategyConfig);

}

return new NoneShardingStrategy();

}

//标准分片策略

public StandardShardingStrategy(final StandardShardingStrategyConfiguration standardShardingStrategyConfig) {

Preconditions.checkNotNull(standardShardingStrategyConfig.getShardingColumn(), "Sharding column cannot be null.");

Preconditions.checkNotNull(standardShardingStrategyConfig.getPreciseShardingAlgorithm(), "precise sharding algorithm cannot be null.");

//用于分片的列

shardingColumn = standardShardingStrategyConfig.getShardingColumn();

//是必选的 用于处理=和IN的分片

preciseShardingAlgorithm = standardShardingStrategyConfig.getPreciseShardingAlgorithm();

//是可选的 用于处理BETWEEN AND分片，如果不配置 RangeShardingAlgorithm，SQL中的 BETWEEN AND 将按照全库路由处理

rangeShardingAlgorithm = standardShardingStrategyConfig.getRangeShardingAlgorithm();

}

/**

* Inline表达式分片策略。使用Groovy的Inline表达式，提供对SQL语句中的=和IN的分片操作支持。

* InlineShardingStrategy只支持单分片键，对于简单的分片算法，可以通过简单的配置使用，从而避免繁琐的Java代码开发，

* 如: tuser${user_id % 8} 表示t_user表按照user_id按8取模分成8个表，表名称为t_user_0 到 t_user_7。

*/

public InlineShardingStrategy(final InlineShardingStrategyConfiguration inlineShardingStrategyConfig) {

Preconditions.checkNotNull(inlineShardingStrategyConfig.getShardingColumn(), "Sharding column cannot be null.");

Preconditions.checkNotNull(inlineShardingStrategyConfig.getAlgorithmExpression(), "Sharding algorithm expression cannot be null.");

shardingColumn = inlineShardingStrategyConfig.getShardingColumn();

String algorithmExpression = InlineExpressionParser.handlePlaceHolder(inlineShardingStrategyConfig.getAlgorithmExpression().trim());

closure = new InlineExpressionParser(algorithmExpression).evaluateClosure();

}

//复合分片策略。提供对SQL语句中的 =, IN 和 BETWEEN AND 的分片操作支持。

public ComplexShardingStrategy(final ComplexShardingStrategyConfiguration complexShardingStrategyConfig) {

Preconditions.checkNotNull(complexShardingStrategyConfig.getShardingColumns(), "Sharding columns cannot be null.");

Preconditions.checkNotNull(complexShardingStrategyConfig.getShardingAlgorithm(), "Sharding algorithm cannot be null.");

shardingColumns = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

shardingColumns.addAll(Splitter.on(",").trimResults().splitToList(complexShardingStrategyConfig.getShardingColumns()));

shardingAlgorithm = complexShardingStrategyConfig.getShardingAlgorithm();

}

//通过Hint而非SQL解析的方式分片的策略

public HintShardingStrategy(final HintShardingStrategyConfiguration hintShardingStrategyConfig) {

Preconditions.checkNotNull(hintShardingStrategyConfig.getShardingAlgorithm(), "Sharding algorithm cannot be null.");

shardingColumns = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

shardingAlgorithm = hintShardingStrategyConfig.getShardingAlgorithm();

}

这里可能有个误区，分片策略不是自定义的吗？怎么会出现在源码中。sharding jdbc 分片策略不能自定义，分片算法是自定义的，上边代码中，getShardingAlgorithm() 就是在获取用户自定义的算法。

2、匹配数据库类型 databaseType

在初始化 ShardingDataSource 时候会调用父类AbstractDataSourceAdapter 构造方法，根据数据库连接的url进行匹配数据库类型

public AbstractDataSourceAdapter(final Map dataSourceMap) throws SQLException {

this.dataSourceMap = dataSourceMap;

databaseType = createDatabaseType();

}

//根据数据数据库连接 url 匹配找到数据库类型

private DatabaseType createDatabaseType(final DataSource dataSource) throws SQLException {

if (dataSource instanceof AbstractDataSourceAdapter) {

return ((AbstractDataSourceAdapter) dataSource).databaseType;

}

try (Connection connection = dataSource.getConnection()) {

return DatabaseTypes.getDatabaseTypeByURL(connection.getMetaData().getURL());

}

}

private static boolean matchStandardURL(final String url, final DatabaseType databaseType) {

return url.startsWith(String.format("jdbc:%s:", databaseType.getName().toLowerCase()));

}

3、创建 sql 解析引擎 SQLParseEngine 、sql 执行引擎 ShardingExecuteEngine

1、创建 ShardingRuntimeContext 调用父类 AbstractRuntimeContext 的构造方法

2、创建运行时候需要的一些配置信息，包括是否打印sql,单次执行消耗的数据库连接数、并行执行线程池大小等等

3、创建 sql 执行引擎

4、创建 sql 解析引擎

protected AbstractRuntimeContext(final T rule, final Properties props, final DatabaseType databaseType) {

this.rule = rule;

//运行时候的一些配置信息

this.props = new ShardingProperties(null == props ? new Properties() : props);

this.databaseType = databaseType;

//创建 sql 执行

executeEngine = new ShardingExecuteEngine(this.props.getValue(ShardingPropertiesConstant.EXECUTOR_SIZE));

//根据数据库类型初始化，sql 解析引擎

parseEngine = SQLParseEngineFactory.getSQLParseEngine(DatabaseTypes.getTrunkDatabaseTypeName(databaseType));

ConfigurationLogger.log(rule.getRuleConfiguration());

ConfigurationLogger.log(props);

}

创建 sql 执行引擎

sql 执行引擎 ShardingExecuteEngine 复合了sql 执行服务ShardingExecutorService，在创建ShardingExecuteEngine 时同时创建了 ShardingExecutorService 一对一的关系,这里涉及到了guava 的 MoreExecutors 对jdk Executor 的增强

public ShardingExecutorService(final int executorSize, final String nameFormat) {

executorService = MoreExecutors.listeningDecorator(getExecutorService(executorSize, nameFormat));

//java 系统默认创建的线程都是用户线程，也就是说如果 用户线程不结束，main 方法不会结束的。

//在线程 start 之前当调用 setDaemon 时，此线程就是守护线程了，main 方法不会等待此线程运行结束

//非主动结束进程 或调用 System.exit 时无论什么线程都会结束

//MoreExecutors 是 gava 对 jdk 线程池的增强

//加 60 秒的 jvm 关闭钩子, 在 jvm 中已经没有用户线程在运行了,那么 等待 60 秒后关闭线程池

MoreExecutors.addDelayedShutdownHook(executorService, 60, TimeUnit.SECONDS);

}

//创建线程池，如果配置参数 executorSize 为0那么创建 CachedThreadPool 核心线程数量为0 最大线程数量为 Integer.MAX_VALUE

private ExecutorService getExecutorService(final int executorSize, final String nameFormat) {

//线程名字为 ShardingSphere 开头

ThreadFactory shardingThreadFactory = ShardingThreadFactoryBuilder.build(nameFormat);

return 0 == executorSize ? Executors.newCachedThreadPool(shardingThreadFactory) : Executors.newFixedThreadPool(executorSize, shardingThreadFactory);

}

sql 解析引擎

1、根据数据库名称创建 SQLParseEngine

这里还有一个误区，不是每个数据都应该有对应的 SQLParseEngine 吗？其实类都是同一个 SQLParseEngine 只是其中 String databaseTypeName 不同而已，虽然调用了构造函数但是此处的初始化还没有完成，真正完成在第一次解析sql的时候。

2、第一次解析sql。SQLParseEngine.parse0

(1)是否用缓存中已解析好的结果

(2)创建 SQLParseKernel 并且调用了 ParseRuleRegistry.getInstance() 完整初始化过程。

public static SQLParseEngine getSQLParseEngine(final String databaseTypeName) {

if (ENGINES.containsKey(databaseTypeName)) {

return ENGINES.get(databaseTypeName);

}

//这里同步保证每个数据库只有一个 SQLParseEngine 实例

synchronized (ENGINES) {

if (ENGINES.containsKey(databaseTypeName)) {

return ENGINES.get(databaseTypeName);

}

SQLParseEngine result = new SQLParseEngine(databaseTypeName);

ENGINES.put(databaseTypeName, result);

return result;

}

}

第一次解析sql。SQLParseEngine.parse0

因为第一次执行解析 sql 所以虚拟机会加载 ParseRuleRegistry 到内存，并且调用 ParseRuleRegistry 中的静态代码块。

1、利用 java spi 机制加载 SQLParserEntry 的实现类到内存，SQLParserEntry 的实现类包括MySQLParserEntry,OracleParserEntry ，分别在不同的模块中，所以可以按需引入。

2、加载 sql 解析规范例如 sql-statement-rule-definition.xml 文件并且解析存放在Map sqlStatementRuleDefinitions 中。

private SQLStatement parse0(final String sql, final boolean useCache) {

//是否用缓存中已解析好的结果

if (useCache) {

Optional cachedSQLStatement = cache.getSQLStatement(sql);

if (cachedSQLStatement.isPresent()) {

return cachedSQLStatement.get();

}

}

// ParseRuleRegistry.getInstance() 获取定的一些规范，和配置信息

SQLStatement result = new SQLParseKernel(ParseRuleRegistry.getInstance(), databaseTypeName, sql).parse();

if (useCache) {

cache.put(sql, result);

}

return result;

}

ParseRuleRegistry.getInstance()

static {

//spi 机制加载注册的 sql 语法解析类型，例如 oracl mysql

NewInstanceServiceLoader.register(SQLParserEntry.class);

instance = new ParseRuleRegistry();

}

//key 接口类型， value 实现类集合

private static final Map>> SERVICE_MAP = new HashMap<>();

/**

* 根据 ServiceLoader java util spi 机制获取相应的 service 目录默认在 META-INF/services/

*/

public static void register(final Class service) {

for (T each : ServiceLoader.load(service)) {

registerServiceClass(service, each);

}

}

加载 sql 解析规范例如 sql-statement-rule-definition.xml 文件并且解析存放在Map sqlStatementRuleDefinitions 中，key 为数据库名称，value 为规则类。

/**

* load sql 解析规范 例如sql-statement-rule-definition.xml

*/

private void initParseRuleDefinition() {

ExtractorRuleDefinitionEntity generalExtractorRuleEntity = extractorRuleLoader.load(RuleDefinitionFileConstant.getExtractorRuleDefinitionFile());

FillerRuleDefinitionEntity generalFillerRuleEntity = fillerRuleLoader.load(RuleDefinitionFileConstant.getFillerRuleDefinitionFile());

for (SQLParserEntry each : NewInstanceServiceLoader.newServiceInstances(SQLParserEntry.class)) {

String databaseTypeName = each.getDatabaseTypeName();

fillerRuleDefinitions.put(databaseTypeName, createFillerRuleDefinition(generalFillerRuleEntity, databaseTypeName));

sqlStatementRuleDefinitions.put(databaseTypeName, createSQLStatementRuleDefinition(generalExtractorRuleEntity, databaseTypeName));

}

}

那随后的执行阶段就可以根据数据库名取到对应的解析方法了。

public SQLAST parse() {

//根据数据库名获取，对应的解析类

SQLParser sqlParser = SQLParserFactory.newInstance(databaseTypeName, sql);

....略

//根据数据库名获取，对应的解析规则类

SQLStatementRule rule = parseRuleRegistry.getSQLStatementRule(databaseTypeName, parseTree.getClass().getSimpleName());

if (null == rule) {

throw new SQLParsingException(String.format("Unsupported SQL of `%s`", sql));

}

return new SQLAST((ParserRuleContext) parseTree, getParameterMarkerIndexes((ParserRuleContext) parseTree), rule);

}

至此 sharding jdbc 4.0.1 初始化阶段已经完成，关于

2、内部运行流程分别是怎么实现的

(1)初始化过程

(2)sql 解析

(3)sql 提取

(4)sql 路由

(5)sql 替换

(6)sql 执行

中的 2、3、4、5、6 下次分析。