Sharding-JDBC系列
2、Sharding-JDBC分库分表之SpringBoot分片策略
3、Sharding-JDBC分库分表之SpringBoot主从配置
4、SpringBoot集成Sharding-JDBC-5.3.0分库分表
5、SpringBoot集成Sharding-JDBC-5.3.0实现按月动态建表分表
8、【源码】Sharding-JDBC源码分析之Yaml分片配置文件解析原理
9、【源码】Sharding-JDBC源码分析之Yaml分片配置原理(一)
10、【源码】Sharding-JDBC源码分析之Yaml分片配置原理(二)
11、【源码】Sharding-JDBC源码分析之Yaml分片配置转换原理
12、【源码】Sharding-JDBC源码分析之ShardingSphereDataSource的创建原理
13、【源码】Sharding-JDBC源码分析之ContextManager创建中mode分片配置信息的持久化存储的原理
14、【源码】Sharding-JDBC源码分析之ContextManager创建中ShardingSphereDatabase的创建原理
前言
在【源码】Sharding-JDBC源码分析之ShardingSphereDataSource的创建原理-CSDN博客博文的3.1.2中介绍了ContextManager的创建,本文从源码角度分享一下ContextManager的创建过程中获取配置的数据源的元数据的实现原理。
StandaloneContextManagerBuilder回顾
在【源码】Sharding-JDBC源码分析之ContextManager创建中mode分片配置信息的持久化存储的原理-CSDN博客博文中,介绍了ContextManager是通过StandaloneContextManagerBuilder的bulid()方法创建的。在创建ContextManager前,先结合mode的配置,通过JDBCRepository实现了配置信息的持久化存储。
StandaloneContextManagerBuilder的bulid()的源码如下:
java
package org.apache.shardingsphere.mode.manager.standalone;
/**
* 单机上下文管理创建者。持久化配置信息到H2或Mysql
*/
public final class StandaloneContextManagerBuilder implements ContextManagerBuilder {
@Override
public ContextManager build(final ContextManagerBuilderParameter param) throws SQLException {
// 获取配置的元数据持久化信息
PersistRepositoryConfiguration repositoryConfig = param.getModeConfiguration().getRepository();
// 获取持久化接口对象,默认为JDBCRepository对象
StandalonePersistRepository repository = null == repositoryConfig
? RequiredSPIRegistry.getRegisteredService(StandalonePersistRepository.class)
: TypedSPIRegistry.getRegisteredService(StandalonePersistRepository.class, repositoryConfig.getType(), repositoryConfig.getProps());
// 新建元数据持久化service类
MetaDataPersistService persistService = new MetaDataPersistService(repository);
// 持久化配置信息,默认保存到h2数据库中
persistConfigurations(persistService, param);
InstanceContext instanceContext = buildInstanceContext(param);
// 监听,处理Standalone的订阅者
new ProcessStandaloneSubscriber(instanceContext.getEventBusContext());
// 创建MetaDataContexts,创建ShardingSphereDatabase,保存到MetaDataContexts中
MetaDataContexts metaDataContexts = MetaDataContextsFactory.create(persistService, param, instanceContext);
ContextManager result = new ContextManager(metaDataContexts, instanceContext);
setContextManagerAware(result);
return result;
}
}
在build()方法中,持久化配置信息之后,继续执行如下:
1)执行buildInstanceContext(),创建InstanceContext;
2)实现Standalone模式的事件订阅,添加进程列表请求和终止进程列表的请求;
3)执行MetaDataContextsFactory.create()方法,创建MetadataContexts对象;
在创建MetadataContexts之前,先通过配置的数据源、分片规则及数据源默认的数据库类型,获取数据源中定义的元数据(如表、表的列、主键、索引等元数据信息),创建ShardingSphereDatabase对象;
4)创建ContextManager对象,保存了InstanceContext、MetadataContexts对象;
MetaDataContextsFactory
java
package org.apache.shardingsphere.mode.metadata;
/**
* 元数据上下文工厂
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class MetaDataContextsFactory {
public static MetaDataContexts create(final MetaDataPersistService persistService, final ContextManagerBuilderParameter param, final InstanceContext instanceContext) throws SQLException {
return create(persistService, param, instanceContext, Collections.emptyMap());
}
public static MetaDataContexts create(final MetaDataPersistService persistService, final ContextManagerBuilderParameter param,
final InstanceContext instanceContext, final Map<String, StorageNodeDataSource> storageNodes) throws SQLException {
// 获取数据库名称,默认为logic_db
Collection<String> databaseNames = instanceContext.getInstance().getMetaData() instanceof JDBCInstanceMetaData
? param.getDatabaseConfigs().keySet()
: persistService.getDatabaseMetaDataService().loadAllDatabaseNames();
// 创建有效的数据库配置。从数据库中获取配置的信息。key为数据库名称(默认为logic_db),value为DataSourceProvidedDatabaseConfiguration
Map<String, DatabaseConfiguration> effectiveDatabaseConfigs = createEffectiveDatabaseConfigurations(databaseNames, param.getDatabaseConfigs(), persistService);
checkDataSourceStates(effectiveDatabaseConfigs, storageNodes, param.isForce());
// 从数据库中获取全局规则配置信息
Collection<RuleConfiguration> globalRuleConfigs = persistService.getGlobalRuleService().load();
// 从数据库中获取配置的props信息
ConfigurationProperties props = new ConfigurationProperties(persistService.getPropsService().load());
// 创建ShardingSphereDatabase集合
Map<String, ShardingSphereDatabase> databases = ShardingSphereDatabasesFactory.create(effectiveDatabaseConfigs, props, instanceContext);
// 从repository表中重新加载对应数据库的信息
databases.putAll(reloadDatabases(databases, persistService));
// 创建规则元数据对象
ShardingSphereRuleMetaData globalMetaData = new ShardingSphereRuleMetaData(GlobalRulesBuilder.buildRules(globalRuleConfigs, databases, props));
return new MetaDataContexts(persistService, new ShardingSphereMetaData(databases, globalMetaData, props));
}
/**
* 创建有效的数据库配置。根据数据库逻辑名,从持久化库中获取有效的DataSource、配置规则,封装成DataSourceProvidedDatabaseConfiguration。
* key为逻辑名,value为DataSourceProvidedDatabaseConfiguration
*/
private static Map<String, DatabaseConfiguration> createEffectiveDatabaseConfigurations(final Collection<String> databaseNames,
final Map<String, DatabaseConfiguration> databaseConfigs, final MetaDataPersistService persistService) {
return databaseNames.stream().collect(
Collectors.toMap(each -> each, each -> createEffectiveDatabaseConfiguration(each, databaseConfigs, persistService), (a, b) -> b, () -> new HashMap<>(databaseNames.size(), 1)));
}
private static DatabaseConfiguration createEffectiveDatabaseConfiguration(final String databaseName,
final Map<String, DatabaseConfiguration> databaseConfigs, final MetaDataPersistService persistService) {
// 从持久化库中获取有效的DataSource
Map<String, DataSource> effectiveDataSources = persistService.getEffectiveDataSources(databaseName, databaseConfigs);
// 从持久化库中获取规则配置
Collection<RuleConfiguration> databaseRuleConfigs = persistService.getDatabaseRulePersistService().load(databaseName);
// 封装成DataSourceProvidedDatabaseConfiguration对象
return new DataSourceProvidedDatabaseConfiguration(effectiveDataSources, databaseRuleConfigs);
}
private static void checkDataSourceStates(final Map<String, DatabaseConfiguration> databaseConfigs, final Map<String, StorageNodeDataSource> storageNodes, final boolean force) {
Map<String, DataSourceState> storageDataSourceStates = getStorageDataSourceStates(storageNodes);
databaseConfigs.forEach((key, value) -> {
if (!value.getDataSources().isEmpty()) {
DataSourceStateManager.getInstance().initStates(key, value.getDataSources(), storageDataSourceStates, force);
}
});
}
private static Map<String, DataSourceState> getStorageDataSourceStates(final Map<String, StorageNodeDataSource> storageDataSourceStates) {
Map<String, DataSourceState> result = new HashMap<>(storageDataSourceStates.size(), 1);
storageDataSourceStates.forEach((key, value) -> {
List<String> values = Splitter.on(".").splitToList(key);
Preconditions.checkArgument(3 == values.size(), "Illegal data source of storage node.");
String databaseName = values.get(0);
String dataSourceName = values.get(2);
result.put(databaseName + "." + dataSourceName, DataSourceState.valueOf(value.getStatus().toUpperCase()));
});
return result;
}
/**
* 从repository中重新加载数据库信息。如果没有,则为原来的信息
*/
private static Map<String, ShardingSphereDatabase> reloadDatabases(final Map<String, ShardingSphereDatabase> databases, final MetaDataPersistService persistService) {
Map<String, ShardingSphereDatabase> result = new ConcurrentHashMap<>(databases.size(), 1);
databases.forEach((key, value) -> {
Map<String, ShardingSphereSchema> schemas = persistService.getDatabaseMetaDataService().loadSchemas(key);
result.put(key.toLowerCase(), new ShardingSphereDatabase(value.getName(),
value.getProtocolType(), value.getResourceMetaData(), value.getRuleMetaData(), schemas.isEmpty() ? value.getSchemas() : schemas));
});
return result;
}
}
在create()方法,主要执行如下:
1)获取数据库名称,默认为logic_db;
2)创建有效的数据库配置Map集合,key为数据库名称,value为DataSourceProvidedDatabaseConfiguration对象;
2.1)通过配置信息持久化MetaDataPersistService,从持久化存储库中获取对应数据库的配置信息。并通过YamlDataSourceConfigurationSwapper,转换为DataSourceProperties对象,然后通过DataSourcePoolCreator,采用反射,创建对应的DataSource对象;
详见:【源码】Sharding-JDBC源码分析之Yaml分片配置原理(一)-CSDN博客
2.2)通过配置信息持久化MetaDataPersistService,从持久化存储库中获取对应数据库的规则配置信息。并通过YamlRuleConfigurationSwapperEngine,转换为RuleConfiguration对象
2.3)创建DataSourceProvidedDatabaseConfiguration对象;
3)检测数据源的状态;
3.1)如果是分布式部署的,storageNodes为从分布式配置中心中间件中获取保存的数据源节点的状态信息;
3.2)遍历2)中创建的有效的数据库Map集合中的数据源,如果在storageNodes中,且定义为DISABLE,则记录当前的数据库的数据源的状态为DISABLE;否则,通过数据源的DataSource对象获取Connection对象,如果能够正常获取,则记录当前的数据源的状态为ENABLE,如果获取不了Connection,则抛异常;
4)从配置信息持久化存储库中获取全局规则配置RuleConfiguration集合;
5)从配置信息持久化存储库中获取props配置信息,封装为ConfigurationProperties对象;
6)执行ShardingSphereDatabasesFactory.create(),创建ShardingSphereDatabase集合;
7)创建ShardingSphereRuleMetaData对象,保存全局规则的副本;
8)创建MetaDataContexts对象,保存MetaDataPersistService、ShardingSphereMetaData对象,其中ShardingSphereMetaData保存了规则、ShardingSphereDatabase及其他信息;
ShardingSphereDatabasesFactory
ShardingSphereDatabasesFactory的源码如下:
java
package org.apache.shardingsphere.infra.metadata.database;
public final class ShardingSphereDatabasesFactory {
public static ShardingSphereDatabase create(final String databaseName, final DatabaseConfiguration databaseConfig,
final ConfigurationProperties props, final InstanceContext instanceContext) throws SQLException {
DatabaseType protocolType = DatabaseTypeEngine.getProtocolType(databaseName, databaseConfig, props);
Map<String, DatabaseType> storageTypes = DatabaseTypeEngine.getStorageTypes(databaseName, databaseConfig);
return ShardingSphereDatabase.create(databaseName, protocolType, storageTypes, databaseConfig, props, instanceContext);
}
/**
* 创建ShardingSphereDatabase集合
* @param databaseConfigMap 从持久化存储库中获取的数据库的配置信息对象
* @param props 从持久化存储库中获取的props配置信息
* @param instanceContext 实例上下文
*/
public static Map<String, ShardingSphereDatabase> create(final Map<String, DatabaseConfiguration> databaseConfigMap,
final ConfigurationProperties props, final InstanceContext instanceContext) throws SQLException {
// 获取数据库类型,默认为MYSQLDatabaseType
DatabaseType protocolType = DatabaseTypeEngine.getProtocolType(databaseConfigMap, props);
// 定义一个Map,长度为配置的数据库个数加上对应数据源类型的系统库。如MySQL数据库,系统库有information_schema、mysql、sys等
Map<String, ShardingSphereDatabase> result = new ConcurrentHashMap<>(databaseConfigMap.size() + protocolType.getSystemDatabaseSchemaMap().size(), 1);
// 创建通用数据库
result.putAll(createGenericDatabases(databaseConfigMap, protocolType, props, instanceContext));
// 创建系统默认的数据库。如MySQL数据库,创建information_schema、performance_schema、mysql、sys、shardingsphere
result.putAll(createSystemDatabases(databaseConfigMap, protocolType));
return result;
}
/**
* 创建通用数据库
*/
private static Map<String, ShardingSphereDatabase> createGenericDatabases(final Map<String, DatabaseConfiguration> databaseConfigMap, final DatabaseType protocolType,
final ConfigurationProperties props, final InstanceContext instanceContext) throws SQLException {
Map<String, ShardingSphereDatabase> result = new HashMap<>(databaseConfigMap.size(), 1);
for (Entry<String, DatabaseConfiguration> entry : databaseConfigMap.entrySet()) {
// 默认为logic_db
String databaseName = entry.getKey();
if (!entry.getValue().getDataSources().isEmpty() || !protocolType.getSystemSchemas().contains(databaseName)) {
// 获取存储类型。通过DataSource获取Connection,再通过Connection的url判断哪种存储类型。如MysqlDatabaseType、H2DatabaseType等
// key为对应的逻辑数据库名,value为对应的数据类型。如order_ds:MYSQLDatabaseType
Map<String, DatabaseType> storageTypes = DatabaseTypeEngine.getStorageTypes(entry.getKey(), entry.getValue());
result.put(databaseName.toLowerCase(), ShardingSphereDatabase.create(databaseName, protocolType, storageTypes, entry.getValue(), props, instanceContext));
}
}
return result;
}
private static Map<String, ShardingSphereDatabase> createSystemDatabases(final Map<String, DatabaseConfiguration> databaseConfigMap, final DatabaseType protocolType) {
Map<String, ShardingSphereDatabase> result = new HashMap<>(protocolType.getSystemDatabaseSchemaMap().size(), 1);
for (String each : protocolType.getSystemDatabaseSchemaMap().keySet()) {
if (!databaseConfigMap.containsKey(each) || databaseConfigMap.get(each).getDataSources().isEmpty()) {
result.put(each.toLowerCase(), ShardingSphereDatabase.create(each, protocolType));
}
}
return result;
}
}
create()方法执行如下:
1)根据配置的props或数据库信息,获取数据库的类型;
1.1)通过props的proxy-frontend-database-protocol-type配置数据库类型(如配置为mysql,则数据库类型为MySQLDatabaseType);
1.2)如果没有通过props配置,从配置的数据库中,查找第一个ENABLE的数据源,通过数据源的url信息,确定数据库类型(如jdbc:mysql,则数据库类型为MySQLDatabaseType,jdbc:oracle,则数据库类型为OracleDatabaseType);
1.3)如果以上都没有,则默认返回MySQLDatabaseType;
2)定义一个Map,长度为配置的数据库个数加上对应数据源类型的系统库;
如MySQL数据库,系统库有information_schema、performance_schema、mysql、sys和shardingsphere,长度要加上5;
3)执行createGenericDatabases(),创建通用的数据库ShardingSphereDatabase对象,返回Map集合,其中key为数据库名称(默认为logic_db),value为ShardingSphereDatabase对象;
遍历配置的database配置信息,如果对应的数据库有配置数据源,且该数据库不属于数据库默认的数据库,则执行如下:
3.1)获取当前数据库配置的数据源对应的数据库类型;
3.2)执行ShardingSphereDatabase.create(),创建ShardingSphereDatabase对象;
3.3)将创建的ShardingSphereDatabase对象放入到Map中;
4)创建系统默认的数据库对应的ShardingSphereDatabase对象;
也是通过ShardingSphereDatabase.create()进行创建。
5)返回创建的所有ShardingSphereDatabase对象;
ShardingSphereDatabase
ShardingSphereDatabase的源码如下:
java
package org.apache.shardingsphere.infra.metadata.database;
/**
* 数据库信息
*/
@Getter
public final class ShardingSphereDatabase {
// 默认logic_db
private final String name;
// 数据库类型。如MySQLDatabaseType
private final DatabaseType protocolType;
// 资源元数据。数据源、数据库类型、数据源的元数据(hostname、port等)
private final ShardingSphereResourceMetaData resourceMetaData;
// 配置的规则的元数据集合,线程安全
private final ShardingSphereRuleMetaData ruleMetaData;
// schema中定义的表和视图的信息。key默认为logic_db
private final Map<String, ShardingSphereSchema> schemas;
public ShardingSphereDatabase(final String name, final DatabaseType protocolType, final ShardingSphereResourceMetaData resourceMetaData,
final ShardingSphereRuleMetaData ruleMetaData, final Map<String, ShardingSphereSchema> schemas) {
this.name = name;
this.protocolType = protocolType;
this.resourceMetaData = resourceMetaData;
this.ruleMetaData = ruleMetaData;
this.schemas = new ConcurrentHashMap<>(schemas.size(), 1);
schemas.forEach((key, value) -> this.schemas.put(key.toLowerCase(), value));
}
/**
* 创建一个ShardingSphereDatabase
* @param name 默认为logic_db
* @param protocolType 默认为MySQLDatabaseType
* @param storageTypes 对应逻辑数据源及协议类型。如:order_ds: MySQLDatabaseType
* @param databaseConfig 数据源配置。默认为DataSourceProvidedDatabaseConfiguration对象,数据源提供数据库配置。从数据库中获取的数据库配置信息
* @param props 配置的props
* @param instanceContext
* @return
* @throws SQLException
*/
public static ShardingSphereDatabase create(final String name, final DatabaseType protocolType, final Map<String, DatabaseType> storageTypes,
final DatabaseConfiguration databaseConfig, final ConfigurationProperties props, final InstanceContext instanceContext) throws SQLException {
// 获取配置的数据源规则,如ShardingRule(分片的规则。将ShardingRuleConfiguration中的规则配置项转化成对应规则的对象)等
// 创建数据源的规则。根据配置的规则对象(xxxConfiguration)转化成对应规则对象(xxxRule)
Collection<ShardingSphereRule> databaseRules = DatabaseRulesBuilder.build(name, databaseConfig, instanceContext);
Map<String, ShardingSphereSchema> schemas = new ConcurrentHashMap<>();
// 从数据源中组装数据库元数据(表元数据、表中列元数据)
schemas.putAll(GenericSchemaBuilder.build(new GenericSchemaBuilderMaterial(protocolType, storageTypes,
// 获取可用的DataSource的Map
DataSourceStateManager.getInstance().getEnabledDataSourceMap(name, databaseConfig.getDataSources()), databaseRules, props,
DatabaseTypeEngine.getDefaultSchemaName(protocolType, name))));
schemas.putAll(SystemSchemaBuilder.build(name, protocolType));
return create(name, protocolType, databaseConfig, databaseRules, schemas);
}
public static ShardingSphereDatabase create(final String name, final DatabaseType protocolType) {
DatabaseConfiguration databaseConfig = new DataSourceProvidedDatabaseConfiguration(new LinkedHashMap<>(), new LinkedList<>());
return create(name, protocolType, databaseConfig, new LinkedList<>(), SystemSchemaBuilder.build(name, protocolType));
}
/**
* 创建ShardingSphereDatabase
* @param name 默认logic_name
* @param protocolType MySQLDatabaseType
*/
private static ShardingSphereDatabase create(final String name, final DatabaseType protocolType, final DatabaseConfiguration databaseConfig,
final Collection<ShardingSphereRule> rules, final Map<String, ShardingSphereSchema> schemas) {
// 资源元数据。数据源、数据库类型、数据源的元数据(hostname、port等)
ShardingSphereResourceMetaData resourceMetaData = createResourceMetaData(name, databaseConfig.getDataSources());
// 配置的规则的元数据集合,线程安全
ShardingSphereRuleMetaData ruleMetaData = new ShardingSphereRuleMetaData(rules);
return new ShardingSphereDatabase(name, protocolType, resourceMetaData, ruleMetaData, schemas);
}
private static ShardingSphereResourceMetaData createResourceMetaData(final String databaseName, final Map<String, DataSource> dataSourceMap) {
return new ShardingSphereResourceMetaData(databaseName, dataSourceMap);
}
public ShardingSphereSchema getSchema(final String schemaName) {
return schemas.get(schemaName.toLowerCase());
}
public void putSchema(final String schemaName, final ShardingSphereSchema schema) {
schemas.put(schemaName.toLowerCase(), schema);
}
public void removeSchema(final String schemaName) {
schemas.remove(schemaName.toLowerCase());
}
public boolean containsSchema(final String schemaName) {
return schemas.containsKey(schemaName.toLowerCase());
}
public boolean isComplete() {
return !ruleMetaData.getRules().isEmpty() && !resourceMetaData.getDataSources().isEmpty();
}
public boolean containsDataSource() {
return !resourceMetaData.getDataSources().isEmpty();
}
public synchronized void reloadRules(final Class<? extends ShardingSphereRule> ruleClass) {
Collection<? extends ShardingSphereRule> toBeReloadedRules = ruleMetaData.findRules(ruleClass);
RuleConfiguration ruleConfig = toBeReloadedRules.stream().map(ShardingSphereRule::getConfiguration).findFirst().orElse(null);
Collection<ShardingSphereRule> databaseRules = new LinkedList<>(ruleMetaData.getRules());
toBeReloadedRules.stream().findFirst().ifPresent(optional -> {
databaseRules.removeAll(toBeReloadedRules);
databaseRules.add(((MutableDataNodeRule) optional).reloadRule(ruleConfig, name, resourceMetaData.getDataSources(), databaseRules));
});
ruleMetaData.getRules().clear();
ruleMetaData.getRules().addAll(databaseRules);
}
}
5.1 通用ShardingSphereDatabase的创建
通过create(final String name, final DatabaseType protocolType, final Map<String, DatabaseType> storageTypes,final DatabaseConfiguration databaseConfig, final ConfigurationProperties props, final InstanceContext instanceContext)创建通用的ShardingSphereDatabase对象。该方法执行如下:
1)执行DatabaseRulesBuilder.build()方法,将配置的数据库规则转换为ShardingSphereRule集合对象;
1.1)根据配置的规则,获取能够创建该配置规则的DatabaseRuleBuilder生成器;
1.2)如果没有配置Single,则默认添加Single的生成器;
1.3)通过DatabaseRuleBuilder生成器的build()方法,将RuleConfiguration,转换为ShardingSphereRule对象;
说明:分片规则信息在Yaml中配置,解析成对应YamlXxxRuleConfiguration。通过对用的YamlXxxRuleConfigurationSwapper,和XxxRuleConfiguration互转。通过对应的DatabaseRuleBuilder生成器,将XxxRuleConfiguration转换为对应的ShardingSphereRule对象;
2)添加配置的数据源的数据库元数据ShardingSphereSchema对象;
2.1)获取配置的分片表名;
2.2)通过配置的数据源,获取Connection连接,查找对应表的元数据信息。如字段、字段类型、主键、外键等,封装成SchemaMetaData对象;
2.3)将SchemaMetaData对象转换为ShardingSphereTable对象,封装到ShardingSphereSchema对象;
3)生成系统的schema。获取databaseType定义的databaseName的默认表集合,从包中获取对应表的yaml文件,解析成ShardingSphereSchema;
3.1)通过databaseType,获取对应DatabaseType定义的系统数据库及默认表信息;
3.2)从包的schema目录下找到对应表的yaml定义。yaml文件中定义了对应表的字段等信息,将信息解析为YamlShardingSpehreTable对象;
3.3)通过YamlTableSwapper转换器,将YamlShardingSpehreTable对象转换为ShardingSphereTable对象;
3.4)将ShardingSphereTable对象封装到ShardingSphereSchema对象;
4)执行同名的create()方法,创建ShardingSphereDatabase对象;
即如下的5.2的create()方法。
5.2 系统ShardingSphereDatabase的创建
通过create(final String name, final DatabaseType protocolType, final DatabaseConfiguration databaseConfig, final Collection<ShardingSphereRule> rules, final Map<String, ShardingSphereSchema> schemas)创建ShardingSphereDatabase对象。方法执行如下:
1)创建ShardingSphereResouceMetaData对象,用于保存配置的数据源信息;
2)创建ShardingSphereRuleMetaData对象,用于保存配置的规则信息;
3)创建ShardingSphereDatabase对象,传入上面的两个对象;
小结
限于篇幅,本篇先分享到这里。结合上一篇,以下做一个小结:
ShardingSphere通过ContextManagerBuilder的build()方法创建ContextManager对象。ContextManagerBuilder是一个接口类,只有build()一个接口方法。有两个实现类,分别为ClusterContextManagerBuilder和StandaloneContextManagerBuilder,分别对应集群和单机两种模式。
本篇以Standalone为例,在StandaloneContextManagerBuilder的build()方法中,执行流程如下:
1)通过mode的配置信息,获取对应的持久化配置对象。对于Standalone,此处为StandalonePersistRepositoryConfiguration对象;
本篇以Standalone为例,对于Cluster,实现思路类似,只是对应的持久化存储由MySQL、H2换为分布式配置中心中间件,如Nacos、Zookeeper、Etc、Consul等。
2)创建持久化StandalonePersistRepository对象,此处为JDBCRepository对象;
2.1)JDBCRepository根据mode配置中的props的provider(默认为H2),获取对应的JDBCRepositoryProvider。如MySQL的MySQLJDBCRepositoryProvider,其提供了repository表的创建、删除,以及repository表的增删改查操作的SQL语句;
2.2)根据mode配置中的props中的jdbc_url、username、password,创建HikariDataSource对象;
2.3)获取JDBCRepositoryProvider中创建repository表的SQL语句,通过HikariDataSource对象获取连接,执行SQL语句,实现持久化存储库的表的创建;
2.4)提供了repository表的插入、修改、删除方法;
3)创建元数据持久化service类,MetaDataPersistService对象;
3.1)该对象保存了数据库、数据库规则、全局规则、属性等对应的持久化存储Service对象,对应的Service持久化存储对象提供了保存对应配置信息的接口;
3.2)Service类中对应的持久化方法是通过 2)中的JDBCRepository对象,实现了对应配置信息持久化;
3.3)配置项以多路径的方式作为key存储在repository表中;
4)执行persistConfigurations()方法,调用MetaDataPersistService的持久化方法,持久化存储配置信息;
5)创建InstanceContext对象;
创建StandaloneModeContextManager、GlobalLockContext,传入InstanceContext构造器。
6)添加监听,处理Standalone模式的订阅者;
7)创建MetaDataContexts,创建ShardingSphereDatabase,保存到MetaDataContexts中;
7.1)通过配置信息持久化MetaDataPersistService,从持久化存储库中获取对应数据库的配置信息。并通过YamlDataSourceConfigurationSwapper,转换为DataSourceProperties对象,然后通过DataSourcePoolCreator,采用反射,创建对应的DataSource对象;
详见:【源码】Sharding-JDBC源码分析之Yaml分片配置原理(一)-CSDN博客
7.2)通过配置信息持久化MetaDataPersistService,从持久化存储库中获取对应数据库的规则配置信息。并通过YamlRuleConfigurationSwapperEngine,转换为RuleConfiguration对象
7.3)创建DataSourceProvidedDatabaseConfiguration对象,每个数据库一个,包含多个数据源;
7.4)遍历DataSourceProvidedDatabaseConfiguration对象,执行如下:
7.4.1)获取能够创建该配置规则的DatabaseRuleBuilder生成器。如果没有配置Single,则默认添加Single的生成器。通过DatabaseRuleBuilder生成器的build()方法,将RuleConfiguration,转换为ShardingSphereRule对象;
说明:分片规则信息在Yaml中配置,解析成对应YamlXxxRuleConfiguration。通过对用的YamlXxxRuleConfigurationSwapper,和XxxRuleConfiguration互转。通过对应的DatabaseRuleBuilder生成器,将XxxRuleConfiguration转换为对应的ShardingSphereRule对象;
详见:【源码】Sharding-JDBC源码分析之Yaml分片配置转换原理-CSDN博客
7.4.2)获取配置的分片表、数据源中其他单表(没有设置分片的表)的元数据(如表名、表的列、主键、外键等),封装成ShardingSphereSchema对象;
7.4.3)通过DatabaseType,获取其定义的系统默认的数据库及库表名称,从包中获取对应表的yaml文件(文件中定义了对应表的表名、表的列等),解析成ShardingSphereSchema对象;
7.4.4)创建ShardingSphereDatabase对象;
8)创建ContextManager对象;
9)将ContextManager对象赋值给StandaloneModeContextManager;
10)返回创建的ContextManager对象;
关于本篇内容你有什么自己的想法或独到见解,欢迎在评论区一起交流探讨下吧。