You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2025/01/19 04:18:13 UTC
(shardingsphere) branch master updated: Refactor MetaDataContextsFactory (#34396)
This is an automated email from the ASF dual-hosted git repository.
zhangliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 1d89663060f Refactor MetaDataContextsFactory (#34396)
1d89663060f is described below
commit 1d89663060ff3fd7850521d69e9f8f4e48a11edb
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sun Jan 19 12:18:06 2025 +0800
Refactor MetaDataContextsFactory (#34396)
---
.../mode/metadata/MetaDataContextManager.java | 4 +-
.../mode/metadata/MetaDataContextsFactory.java | 113 +++++++++------------
.../manager/DatabaseRuleConfigurationManager.java | 2 +-
.../mode/metadata/manager/StorageUnitManager.java | 4 +-
.../mode/metadata/MetaDataContextsFactoryTest.java | 4 +-
.../cluster/ClusterContextManagerBuilder.java | 3 +-
.../ClusterMetaDataManagerPersistService.java | 12 +--
.../StandaloneContextManagerBuilder.java | 5 +-
.../StandaloneMetaDataManagerPersistService.java | 12 +--
9 files changed, 72 insertions(+), 87 deletions(-)
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
index 081c6aba5ab..38a4942e969 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
@@ -145,8 +145,8 @@ public class MetaDataContextManager {
Map<String, DataSourcePoolProperties> dataSourcePoolPropsFromRegCenter = metaDataPersistService.getDataSourceUnitService().load(database.getName());
SwitchingResource switchingResource = resourceSwitchManager.switchByAlterStorageUnit(database.getResourceMetaData(), dataSourcePoolPropsFromRegCenter);
Collection<RuleConfiguration> ruleConfigs = metaDataPersistService.getDatabaseRulePersistService().load(database.getName());
- ShardingSphereDatabase changedDatabase = MetaDataContextsFactory
- .createChangedDatabase(database.getName(), false, switchingResource, ruleConfigs, metaDataContexts, metaDataPersistService, computeNodeInstanceContext);
+ ShardingSphereDatabase changedDatabase = new MetaDataContextsFactory(metaDataPersistService)
+ .createChangedDatabase(database.getName(), false, switchingResource, ruleConfigs, metaDataContexts, computeNodeInstanceContext);
metaDataContexts.getMetaData().putDatabase(changedDatabase);
ConfigurationProperties props = new ConfigurationProperties(metaDataPersistService.getPropsService().load());
Collection<RuleConfiguration> globalRuleConfigs = metaDataPersistService.getGlobalRuleService().load();
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
index 7f804c71251..2fb10a2090e 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
@@ -17,8 +17,7 @@
package org.apache.shardingsphere.mode.metadata;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import org.apache.shardingsphere.infra.config.database.impl.DataSourceGeneratedDatabaseConfiguration;
import org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
@@ -60,59 +59,57 @@ import java.util.stream.Collectors;
/**
* Meta data contexts factory.
*/
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@RequiredArgsConstructor
public final class MetaDataContextsFactory {
+ private final MetaDataPersistService persistService;
+
/**
* Create meta data contexts.
*
- * @param persistService persist service
* @param param context manager builder parameter
* @param instanceContext compute node instance context
* @return meta data contexts
* @throws SQLException SQL exception
*/
- public static MetaDataContexts create(final MetaDataPersistService persistService,
- final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) throws SQLException {
- return isCreateByLocal(persistService) ? createByLocal(persistService, param, instanceContext) : createByRepository(persistService, param, instanceContext);
- }
-
- private static boolean isCreateByLocal(final MetaDataPersistService persistService) {
- return persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames().isEmpty();
+ public MetaDataContexts create(final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ return containsRegisteredDatabases() ? createFromRegisterCenter(param, instanceContext) : createFromLocalConfiguration(param, instanceContext);
}
- private static MetaDataContexts createByLocal(final MetaDataPersistService persistService,
- final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) throws SQLException {
- ConfigurationProperties props = new ConfigurationProperties(param.getProps());
- Collection<ShardingSphereDatabase> databases = ShardingSphereDatabasesFactory.create(param.getDatabaseConfigs(), props, instanceContext);
- MetaDataContexts result = createMetaDataContexts(persistService, param.getGlobalRuleConfigs(), param.getGlobalDataSources(), databases, props);
- persistDatabaseConfigurations(result, param, persistService);
- persistMetaData(result, persistService);
- return result;
+ private boolean containsRegisteredDatabases() {
+ return !persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames().isEmpty();
}
- private static MetaDataContexts createByRepository(final MetaDataPersistService persistService, final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) {
+ private MetaDataContexts createFromRegisterCenter(final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) {
Map<String, DatabaseConfiguration> effectiveDatabaseConfigs = createEffectiveDatabaseConfigurations(
- getDatabaseNames(persistService, param.getDatabaseConfigs(), instanceContext), param.getDatabaseConfigs(), persistService);
+ getDatabaseNames(param.getDatabaseConfigs(), instanceContext), param.getDatabaseConfigs());
Collection<RuleConfiguration> globalRuleConfigs = persistService.getGlobalRuleService().load();
// TODO load global data sources from persist service
Map<String, DataSource> globalDataSources = param.getGlobalDataSources();
ConfigurationProperties props = new ConfigurationProperties(persistService.getPropsService().load());
Collection<ShardingSphereDatabase> databases = ShardingSphereDatabasesFactory.create(
- effectiveDatabaseConfigs, loadSchemas(persistService, effectiveDatabaseConfigs.keySet()), props, instanceContext);
- return createMetaDataContexts(persistService, globalRuleConfigs, globalDataSources, databases, props);
+ effectiveDatabaseConfigs, loadSchemas(effectiveDatabaseConfigs.keySet()), props, instanceContext);
+ return createMetaDataContexts(globalRuleConfigs, globalDataSources, databases, props);
+ }
+
+ private MetaDataContexts createFromLocalConfiguration(final ContextManagerBuilderParameter param, final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ ConfigurationProperties props = new ConfigurationProperties(param.getProps());
+ Collection<ShardingSphereDatabase> databases = ShardingSphereDatabasesFactory.create(param.getDatabaseConfigs(), props, instanceContext);
+ MetaDataContexts result = createMetaDataContexts(param.getGlobalRuleConfigs(), param.getGlobalDataSources(), databases, props);
+ persistDatabaseConfigurations(result, param);
+ persistMetaData(result);
+ return result;
}
- private static MetaDataContexts createMetaDataContexts(final MetaDataPersistService persistService,
- final Collection<RuleConfiguration> globalRuleConfigs, final Map<String, DataSource> globalDataSources,
- final Collection<ShardingSphereDatabase> databases, final ConfigurationProperties props) {
+ private MetaDataContexts createMetaDataContexts(final Collection<RuleConfiguration> globalRuleConfigs, final Map<String, DataSource> globalDataSources,
+ final Collection<ShardingSphereDatabase> databases, final ConfigurationProperties props) {
Collection<ShardingSphereRule> globalRules = GlobalRulesBuilder.buildRules(globalRuleConfigs, databases, props);
ShardingSphereMetaData metaData = new ShardingSphereMetaData(databases, new ResourceMetaData(globalDataSources), new RuleMetaData(globalRules), props);
ShardingSphereStatistics statistics = ShardingSphereStatisticsFactory.create(metaData, persistService.getShardingSphereDataPersistService().load(metaData));
return new MetaDataContexts(metaData, statistics);
}
- private static void persistDatabaseConfigurations(final MetaDataContexts metadataContexts, final ContextManagerBuilderParameter param, final MetaDataPersistService persistService) {
+ private void persistDatabaseConfigurations(final MetaDataContexts metadataContexts, final ContextManagerBuilderParameter param) {
Collection<RuleConfiguration> globalRuleConfigs = metadataContexts.getMetaData().getGlobalRuleMetaData().getConfigurations();
persistService.persistGlobalRuleConfiguration(globalRuleConfigs, param.getProps());
for (Entry<String, ? extends DatabaseConfiguration> entry : param.getDatabaseConfigs().entrySet()) {
@@ -124,7 +121,7 @@ public final class MetaDataContextsFactory {
}
}
- private static void persistMetaData(final MetaDataContexts metaDataContexts, final MetaDataPersistService persistService) {
+ private void persistMetaData(final MetaDataContexts metaDataContexts) {
metaDataContexts.getMetaData().getAllDatabases().forEach(each -> each.getAllSchemas().forEach(schema -> {
if (schema.isEmpty()) {
persistService.getDatabaseMetaDataFacade().getSchema().add(each.getName(), schema.getName());
@@ -139,33 +136,30 @@ public final class MetaDataContextsFactory {
}
}
- private static Collection<String> getDatabaseNames(final MetaDataPersistService persistService, final Map<String, DatabaseConfiguration> databaseConfigs,
- final ComputeNodeInstanceContext instanceContext) {
+ private Collection<String> getDatabaseNames(final Map<String, DatabaseConfiguration> databaseConfigs, final ComputeNodeInstanceContext instanceContext) {
return instanceContext.getInstance().getMetaData() instanceof JDBCInstanceMetaData
? databaseConfigs.keySet()
: persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames();
}
- 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)));
+ private Map<String, DatabaseConfiguration> createEffectiveDatabaseConfigurations(final Collection<String> databaseNames, final Map<String, DatabaseConfiguration> databaseConfigs) {
+ return databaseNames.stream().collect(Collectors.toMap(each -> each, each -> createEffectiveDatabaseConfiguration(each, databaseConfigs)));
}
- private static DatabaseConfiguration createEffectiveDatabaseConfiguration(final String databaseName,
- final Map<String, DatabaseConfiguration> databaseConfigs, final MetaDataPersistService persistService) {
+ private DatabaseConfiguration createEffectiveDatabaseConfiguration(final String databaseName, final Map<String, DatabaseConfiguration> databaseConfigs) {
closeGeneratedDataSources(databaseName, databaseConfigs);
Map<String, DataSourceConfiguration> dataSources = persistService.loadDataSourceConfigurations(databaseName);
Collection<RuleConfiguration> databaseRuleConfigs = persistService.getDatabaseRulePersistService().load(databaseName);
return new DataSourceGeneratedDatabaseConfiguration(dataSources, databaseRuleConfigs);
}
- private static void closeGeneratedDataSources(final String databaseName, final Map<String, ? extends DatabaseConfiguration> databaseConfigs) {
+ private void closeGeneratedDataSources(final String databaseName, final Map<String, ? extends DatabaseConfiguration> databaseConfigs) {
if (databaseConfigs.containsKey(databaseName) && !databaseConfigs.get(databaseName).getStorageUnits().isEmpty()) {
databaseConfigs.get(databaseName).getDataSources().values().forEach(each -> new DataSourcePoolDestroyer(each).asyncDestroy());
}
}
- private static Map<String, Collection<ShardingSphereSchema>> loadSchemas(final MetaDataPersistService persistService, final Collection<String> databaseNames) {
+ private Map<String, Collection<ShardingSphereSchema>> loadSchemas(final Collection<String> databaseNames) {
return databaseNames.stream().collect(Collectors.toMap(each -> each, each -> persistService.getDatabaseMetaDataFacade().getSchema().load(each)));
}
@@ -176,16 +170,14 @@ public final class MetaDataContextsFactory {
* @param internalLoadMetaData internal load meta data
* @param switchingResource switching resource
* @param originalMetaDataContexts original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext compute node instance context
* @return meta data contexts
* @throws SQLException SQL exception
*/
- public static MetaDataContexts createBySwitchResource(final String databaseName, final boolean internalLoadMetaData, final SwitchingResource switchingResource,
- final MetaDataContexts originalMetaDataContexts, final MetaDataPersistService persistService,
- final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public MetaDataContexts createBySwitchResource(final String databaseName, final boolean internalLoadMetaData, final SwitchingResource switchingResource,
+ final MetaDataContexts originalMetaDataContexts, final ComputeNodeInstanceContext instanceContext) throws SQLException {
ShardingSphereDatabase changedDatabase = createChangedDatabase(
- databaseName, internalLoadMetaData, switchingResource, null, originalMetaDataContexts, persistService, instanceContext);
+ databaseName, internalLoadMetaData, switchingResource, null, originalMetaDataContexts, instanceContext);
ConfigurationProperties props = originalMetaDataContexts.getMetaData().getProps();
ShardingSphereMetaData clonedMetaData = cloneMetaData(originalMetaDataContexts.getMetaData(), changedDatabase);
RuleMetaData changedGlobalMetaData = new RuleMetaData(
@@ -202,16 +194,14 @@ public final class MetaDataContextsFactory {
* @param internalLoadMetaData internal load meta data
* @param ruleConfigs rule configs
* @param originalMetaDataContexts original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext compute node instance context
* @return meta data contexts
* @throws SQLException SQL exception
*/
- public static MetaDataContexts createByAlterRule(final String databaseName, final boolean internalLoadMetaData, final Collection<RuleConfiguration> ruleConfigs,
- final MetaDataContexts originalMetaDataContexts, final MetaDataPersistService persistService,
- final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public MetaDataContexts createByAlterRule(final String databaseName, final boolean internalLoadMetaData, final Collection<RuleConfiguration> ruleConfigs,
+ final MetaDataContexts originalMetaDataContexts, final ComputeNodeInstanceContext instanceContext) throws SQLException {
ShardingSphereDatabase changedDatabase = createChangedDatabase(
- databaseName, internalLoadMetaData, null, ruleConfigs, originalMetaDataContexts, persistService, instanceContext);
+ databaseName, internalLoadMetaData, null, ruleConfigs, originalMetaDataContexts, instanceContext);
ShardingSphereMetaData clonedMetaData = cloneMetaData(originalMetaDataContexts.getMetaData(), changedDatabase);
ConfigurationProperties props = originalMetaDataContexts.getMetaData().getProps();
RuleMetaData changedGlobalMetaData = new RuleMetaData(
@@ -221,7 +211,7 @@ public final class MetaDataContextsFactory {
return new MetaDataContexts(metaData, ShardingSphereStatisticsFactory.create(metaData, persistService.getShardingSphereDataPersistService().load(metaData)));
}
- private static ShardingSphereMetaData cloneMetaData(final ShardingSphereMetaData originalMetaData, final ShardingSphereDatabase changedDatabase) {
+ private ShardingSphereMetaData cloneMetaData(final ShardingSphereMetaData originalMetaData, final ShardingSphereDatabase changedDatabase) {
ShardingSphereMetaData result = new ShardingSphereMetaData(
originalMetaData.getAllDatabases(), originalMetaData.getGlobalResourceMetaData(), originalMetaData.getGlobalRuleMetaData(), originalMetaData.getProps());
result.putDatabase(changedDatabase);
@@ -236,40 +226,37 @@ public final class MetaDataContextsFactory {
* @param switchingResource switching resource
* @param ruleConfigs rule configurations
* @param originalMetaDataContext original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext compute node instance context
* @return changed database
* @throws SQLException SQL exception
*/
- public static ShardingSphereDatabase createChangedDatabase(final String databaseName, final boolean internalLoadMetaData,
- final SwitchingResource switchingResource, final Collection<RuleConfiguration> ruleConfigs,
- final MetaDataContexts originalMetaDataContext, final MetaDataPersistService persistService,
- final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public ShardingSphereDatabase createChangedDatabase(final String databaseName, final boolean internalLoadMetaData,
+ final SwitchingResource switchingResource, final Collection<RuleConfiguration> ruleConfigs,
+ final MetaDataContexts originalMetaDataContext, final ComputeNodeInstanceContext instanceContext) throws SQLException {
ResourceMetaData effectiveResourceMetaData = getEffectiveResourceMetaData(originalMetaDataContext.getMetaData().getDatabase(databaseName), switchingResource);
Collection<RuleConfiguration> toBeCreatedRuleConfigs = null == ruleConfigs
? originalMetaDataContext.getMetaData().getDatabase(databaseName).getRuleMetaData().getConfigurations()
: ruleConfigs;
DatabaseConfiguration toBeCreatedDatabaseConfig = getDatabaseConfiguration(effectiveResourceMetaData, switchingResource, toBeCreatedRuleConfigs);
return createChangedDatabase(originalMetaDataContext.getMetaData().getDatabase(databaseName).getName(), internalLoadMetaData,
- persistService, toBeCreatedDatabaseConfig, originalMetaDataContext.getMetaData().getProps(), instanceContext);
+ toBeCreatedDatabaseConfig, originalMetaDataContext.getMetaData().getProps(), instanceContext);
}
- private static ShardingSphereDatabase createChangedDatabase(final String databaseName, final boolean internalLoadMetaData, final MetaDataPersistService persistService,
- final DatabaseConfiguration databaseConfig, final ConfigurationProperties props,
- final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ private ShardingSphereDatabase createChangedDatabase(final String databaseName, final boolean internalLoadMetaData, final DatabaseConfiguration databaseConfig,
+ final ConfigurationProperties props, final ComputeNodeInstanceContext instanceContext) throws SQLException {
DatabaseType protocolType = DatabaseTypeEngine.getProtocolType(databaseConfig, props);
return internalLoadMetaData
? ShardingSphereDatabase.create(databaseName, protocolType, databaseConfig, instanceContext, persistService.getDatabaseMetaDataFacade().getSchema().load(databaseName))
: ShardingSphereDatabase.create(databaseName, protocolType, databaseConfig, props, instanceContext);
}
- private static ResourceMetaData getEffectiveResourceMetaData(final ShardingSphereDatabase database, final SwitchingResource resource) {
+ private ResourceMetaData getEffectiveResourceMetaData(final ShardingSphereDatabase database, final SwitchingResource resource) {
Map<StorageNode, DataSource> storageNodes = getStorageNodes(database.getResourceMetaData().getDataSources(), resource);
Map<String, StorageUnit> storageUnits = getStorageUnits(database.getResourceMetaData().getStorageUnits(), resource);
return new ResourceMetaData(storageNodes, storageUnits);
}
- private static Map<StorageNode, DataSource> getStorageNodes(final Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource resource) {
+ private Map<StorageNode, DataSource> getStorageNodes(final Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource resource) {
Map<StorageNode, DataSource> result = new LinkedHashMap<>(currentStorageNodes.size(), 1F);
for (Entry<StorageNode, DataSource> entry : currentStorageNodes.entrySet()) {
if (null == resource || !resource.getStaleDataSources().containsKey(entry.getKey())) {
@@ -279,7 +266,7 @@ public final class MetaDataContextsFactory {
return result;
}
- private static Map<String, StorageUnit> getStorageUnits(final Map<String, StorageUnit> currentStorageUnits, final SwitchingResource resource) {
+ private Map<String, StorageUnit> getStorageUnits(final Map<String, StorageUnit> currentStorageUnits, final SwitchingResource resource) {
Map<String, StorageUnit> result = new LinkedHashMap<>(currentStorageUnits.size(), 1F);
for (Entry<String, StorageUnit> entry : currentStorageUnits.entrySet()) {
if (null == resource || !resource.getStaleStorageUnitNames().contains(entry.getKey())) {
@@ -289,15 +276,15 @@ public final class MetaDataContextsFactory {
return result;
}
- private static DatabaseConfiguration getDatabaseConfiguration(final ResourceMetaData resourceMetaData, final SwitchingResource switchingResource,
- final Collection<RuleConfiguration> toBeCreatedRuleConfigs) {
+ private DatabaseConfiguration getDatabaseConfiguration(final ResourceMetaData resourceMetaData,
+ final SwitchingResource switchingResource, final Collection<RuleConfiguration> toBeCreatedRuleConfigs) {
Map<String, DataSourcePoolProperties> propsMap = null == switchingResource ? resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) -> oldValue, LinkedHashMap::new))
: switchingResource.getMergedDataSourcePoolPropertiesMap();
return new DataSourceProvidedDatabaseConfiguration(getMergedStorageNodeDataSources(resourceMetaData, switchingResource), toBeCreatedRuleConfigs, propsMap);
}
- private static Map<StorageNode, DataSource> getMergedStorageNodeDataSources(final ResourceMetaData currentResourceMetaData, final SwitchingResource switchingResource) {
+ private Map<StorageNode, DataSource> getMergedStorageNodeDataSources(final ResourceMetaData currentResourceMetaData, final SwitchingResource switchingResource) {
Map<StorageNode, DataSource> result = currentResourceMetaData.getDataSources();
if (null != switchingResource && !switchingResource.getNewDataSources().isEmpty()) {
result.putAll(switchingResource.getNewDataSources());
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
index d8baeb451c6..08387674c4e 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
@@ -102,7 +102,7 @@ public final class DatabaseRuleConfigurationManager {
}
private void refreshMetadata(final String databaseName, final Collection<RuleConfiguration> ruleConfigurations) throws SQLException {
- metaDataContexts.update(MetaDataContextsFactory.createByAlterRule(databaseName, false, ruleConfigurations, metaDataContexts, metaDataPersistService, computeNodeInstanceContext));
+ metaDataContexts.update(new MetaDataContextsFactory(metaDataPersistService).createByAlterRule(databaseName, false, ruleConfigurations, metaDataContexts, computeNodeInstanceContext));
}
private Collection<RuleConfiguration> getRuleConfigurations(final Collection<ShardingSphereRule> rules) {
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
index 9d2240a9e64..3079015c6f6 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
@@ -107,8 +107,8 @@ public final class StorageUnitManager {
}
private void buildNewMetaDataContext(final String databaseName, final SwitchingResource switchingResource) throws SQLException {
- MetaDataContexts reloadMetaDataContexts = MetaDataContextsFactory.createBySwitchResource(
- databaseName, true, switchingResource, metaDataContexts, metaDataPersistService, computeNodeInstanceContext);
+ MetaDataContexts reloadMetaDataContexts = new MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, true, switchingResource, metaDataContexts, computeNodeInstanceContext);
metaDataContexts.update(reloadMetaDataContexts);
metaDataContexts.getMetaData().putDatabase(buildDatabase(reloadMetaDataContexts.getMetaData().getDatabase(databaseName)));
switchingResource.closeStaleDataSources();
diff --git a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
index 0df9edbaf47..f88f1a4fabe 100644
--- a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
+++ b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
@@ -109,7 +109,7 @@ class MetaDataContextsFactoryTest {
void assertCreateWithJDBCInstanceMetaData() throws SQLException {
ComputeNodeInstanceContext computeNodeInstanceContext = mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS);
when(computeNodeInstanceContext.getInstance().getMetaData()).thenReturn(mock(JDBCInstanceMetaData.class));
- MetaDataContexts actual = MetaDataContextsFactory.create(metaDataPersistService, createContextManagerBuilderParameter(), computeNodeInstanceContext);
+ MetaDataContexts actual = new MetaDataContextsFactory(metaDataPersistService).create(createContextManagerBuilderParameter(), computeNodeInstanceContext);
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().size(), is(1));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().iterator().next(), instanceOf(MockedRule.class));
assertTrue(actual.getMetaData().containsDatabase("foo_db"));
@@ -120,7 +120,7 @@ class MetaDataContextsFactoryTest {
void assertCreateWithProxyInstanceMetaData() throws SQLException {
when(databaseMetaDataPersistFacade.getDatabase().loadAllDatabaseNames()).thenReturn(Collections.singletonList("foo_db"));
when(metaDataPersistService.getDatabaseMetaDataFacade()).thenReturn(databaseMetaDataPersistFacade);
- MetaDataContexts actual = MetaDataContextsFactory.create(metaDataPersistService, createContextManagerBuilderParameter(), mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS));
+ MetaDataContexts actual = new MetaDataContextsFactory(metaDataPersistService).create(createContextManagerBuilderParameter(), mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().size(), is(1));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().iterator().next(), instanceOf(MockedRule.class));
assertTrue(actual.getMetaData().containsDatabase("foo_db"));
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
index 2e997abe9d2..de6545ebea9 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
@@ -60,8 +60,7 @@ public final class ClusterContextManagerBuilder implements ContextManagerBuilder
ClusterPersistRepository repository = getClusterPersistRepository(config, computeNodeInstanceContext);
LockContext lockContext = new ClusterLockContext(new GlobalLockPersistService(repository));
computeNodeInstanceContext.init(new ClusterWorkerIdGenerator(repository, param.getInstanceMetaData().getId()), lockContext);
- MetaDataPersistService metaDataPersistService = new MetaDataPersistService(repository);
- MetaDataContexts metaDataContexts = MetaDataContextsFactory.create(metaDataPersistService, param, computeNodeInstanceContext);
+ MetaDataContexts metaDataContexts = new MetaDataContextsFactory(new MetaDataPersistService(repository)).create(param, computeNodeInstanceContext);
ContextManager result = new ContextManager(metaDataContexts, computeNodeInstanceContext, repository);
registerOnline(computeNodeInstanceContext, param, result, repository);
return result;
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
index 5d73de6ee14..b8bc61de563 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
@@ -125,8 +125,8 @@ public final class ClusterMetaDataManagerPersistService implements MetaDataManag
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager()
.switchByRegisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(), toBeRegisteredProps);
newDataSources.putAll(switchingResource.getNewDataSources());
- MetaDataContexts reloadMetaDataContexts = MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts, metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource, originalMetaDataContexts, metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.getDataSourceUnitService().persist(databaseName, toBeRegisteredProps);
afterStorageUnitsAltered(databaseName, originalMetaDataContexts, reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
@@ -143,8 +143,8 @@ public final class ClusterMetaDataManagerPersistService implements MetaDataManag
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager()
.switchByAlterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(), toBeUpdatedProps);
newDataSources.putAll(switchingResource.getNewDataSources());
- MetaDataContexts reloadMetaDataContexts = MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts, metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource, originalMetaDataContexts, metaDataContextManager.getComputeNodeInstanceContext());
DataSourceUnitPersistService dataSourceService = metaDataPersistService.getDataSourceUnitService();
metaDataPersistService.getMetaDataVersionPersistService()
.switchActiveVersion(dataSourceService.persist(databaseName, toBeUpdatedProps));
@@ -161,8 +161,8 @@ public final class ClusterMetaDataManagerPersistService implements MetaDataManag
MetaDataContexts originalMetaDataContexts = buildOriginalMetaDataContexts();
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager()
.createByUnregisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(), Collections.singletonList(each));
- MetaDataContexts reloadMetaDataContexts = MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts, metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource, originalMetaDataContexts, metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.getDataSourceUnitService().delete(databaseName, each);
afterStorageUnitsDropped(databaseName, originalMetaDataContexts, reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
diff --git a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
index 824887b9feb..03d10bf61a1 100644
--- a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
+++ b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
@@ -22,7 +22,6 @@ import org.apache.shardingsphere.infra.instance.ComputeNodeInstance;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.infra.util.eventbus.EventBusContext;
-import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilder;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilderParameter;
@@ -30,6 +29,7 @@ import org.apache.shardingsphere.mode.manager.standalone.lock.StandaloneLockCont
import org.apache.shardingsphere.mode.manager.standalone.workerid.StandaloneWorkerIdGenerator;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
+import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepository;
import java.sql.SQLException;
@@ -45,10 +45,9 @@ public final class StandaloneContextManagerBuilder implements ContextManagerBuil
PersistRepositoryConfiguration repositoryConfig = param.getModeConfiguration().getRepository();
StandalonePersistRepository repository = TypedSPILoader.getService(
StandalonePersistRepository.class, null == repositoryConfig ? null : repositoryConfig.getType(), null == repositoryConfig ? new Properties() : repositoryConfig.getProps());
- MetaDataPersistService persistService = new MetaDataPersistService(repository);
ComputeNodeInstanceContext computeNodeInstanceContext = new ComputeNodeInstanceContext(new ComputeNodeInstance(param.getInstanceMetaData()), param.getModeConfiguration(), eventBusContext);
computeNodeInstanceContext.init(new StandaloneWorkerIdGenerator(), new StandaloneLockContext());
- MetaDataContexts metaDataContexts = MetaDataContextsFactory.create(persistService, param, computeNodeInstanceContext);
+ MetaDataContexts metaDataContexts = new MetaDataContextsFactory(new MetaDataPersistService(repository)).create(param, computeNodeInstanceContext);
return new ContextManager(metaDataContexts, computeNodeInstanceContext, repository);
}
diff --git a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
index a5fbf412c1e..71354d17bd1 100644
--- a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
+++ b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
@@ -224,8 +224,8 @@ public final class StandaloneMetaDataManagerPersistService implements MetaDataMa
public void registerStorageUnits(final String databaseName, final Map<String, DataSourcePoolProperties> toBeRegisteredProps) throws SQLException {
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager().switchByRegisterStorageUnit(metaDataContextManager.getMetaDataContexts()
.getMetaData().getDatabase(databaseName).getResourceMetaData(), toBeRegisteredProps);
- ShardingSphereDatabase changedDatabase = MetaDataContextsFactory.createChangedDatabase(databaseName, false, switchingResource, null,
- metaDataContextManager.getMetaDataContexts(), metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ ShardingSphereDatabase changedDatabase = new MetaDataContextsFactory(metaDataPersistService).createChangedDatabase(databaseName, false, switchingResource, null,
+ metaDataContextManager.getMetaDataContexts(), metaDataContextManager.getComputeNodeInstanceContext());
metaDataContextManager.getMetaDataContexts().getMetaData().putDatabase(changedDatabase);
metaDataContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule) each).refresh(metaDataContextManager.getMetaDataContexts().getMetaData().getAllDatabases(), GlobalRuleChangedType.DATABASE_CHANGED));
@@ -246,8 +246,8 @@ public final class StandaloneMetaDataManagerPersistService implements MetaDataMa
public void alterStorageUnits(final String databaseName, final Map<String, DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
.getDatabase(databaseName).getResourceMetaData(), toBeUpdatedProps);
- ShardingSphereDatabase changedDatabase = MetaDataContextsFactory.createChangedDatabase(databaseName, true, switchingResource, null,
- metaDataContextManager.getMetaDataContexts(), metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ ShardingSphereDatabase changedDatabase = new MetaDataContextsFactory(metaDataPersistService).createChangedDatabase(databaseName, true, switchingResource, null,
+ metaDataContextManager.getMetaDataContexts(), metaDataContextManager.getComputeNodeInstanceContext());
metaDataContextManager.getMetaDataContexts().getMetaData().putDatabase(changedDatabase);
metaDataContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule) each).refresh(metaDataContextManager.getMetaDataContexts().getMetaData().getAllDatabases(), GlobalRuleChangedType.DATABASE_CHANGED));
@@ -262,8 +262,8 @@ public final class StandaloneMetaDataManagerPersistService implements MetaDataMa
public void unregisterStorageUnits(final String databaseName, final Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
SwitchingResource switchingResource = metaDataContextManager.getResourceSwitchManager().switchByUnregisterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
.getDatabase(databaseName).getResourceMetaData(), toBeDroppedStorageUnitNames);
- MetaDataContexts reloadMetaDataContexts = MetaDataContextsFactory.createBySwitchResource(databaseName, false, switchingResource,
- metaDataContextManager.getMetaDataContexts(), metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(databaseName, false, switchingResource,
+ metaDataContextManager.getMetaDataContexts(), metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.persistReloadDatabaseByDrop(databaseName, reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
metaDataContextManager.dropSchemas(databaseName, reloadMetaDataContexts.getMetaData().getDatabase(databaseName),