Refactor StandaloneMetaDataManagerPersistService

Author: terrymanu

mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java

@@ -195,9 +195,9 @@ public void removeRuleConfigurationItem(final ShardingSphereDatabase database, f
         metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(database.getName(), getReloadedMetaDataContexts(originalMetaDataContexts), needReloadTables);
     }
 
-    private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalShardingDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
+    private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
         if (toBeAlteredRuleConfig instanceof SingleRuleConfiguration) {
-            Collection<String> originalSingleTables = originalShardingDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
+            Collection<String> originalSingleTables = originalDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
             return toBeAlteredRuleConfig.getLogicTableNames().stream().filter(each -> !originalSingleTables.contains(each)).collect(Collectors.toList());
         }
         return toBeAlteredRuleConfig.getLogicTableNames();

mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java

@@ -58,12 +58,9 @@ public final class StandaloneMetaDataManagerPersistService implements MetaDataMa
 
     private final MetaDataPersistFacade metaDataPersistFacade;
 
-    private final RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder;
-    
     public StandaloneMetaDataManagerPersistService(final MetaDataContextManager metaDataContextManager) {
         this.metaDataContextManager = metaDataContextManager;
         metaDataPersistFacade = metaDataContextManager.getMetaDataPersistFacade();
-        ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
     }
 
     @Override
@@ -208,54 +205,65 @@ public void alterRuleConfiguration(final ShardingSphereDatabase database, final
             return;
         }
         Collection<String> needReloadTables = getNeedReloadTables(database, toBeAlteredRuleConfig);
-        for (MetaDataVersion each : metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(), Collections.singleton(toBeAlteredRuleConfig))) {
-            Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(database.getName(), new VersionNodePath(each.getNodePath()).getActiveVersionPath());
-            if (databaseRuleNodePath.isPresent()
-                    && new ActiveVersionChecker(metaDataPersistFacade.getRepository()).checkSame(new VersionNodePath(databaseRuleNodePath.get()), each.getActiveVersion())) {
-                metaDataContextManager.getDatabaseRuleItemManager().alter(databaseRuleNodePath.get());
-            }
-        }
+        Collection<MetaDataVersion> metaDataVersions = metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(), Collections.singleton(toBeAlteredRuleConfig));
+        alterRuleItem(database.getName(), metaDataVersions);
         Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap = metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(
                 database.getName(), metaDataContextManager.getMetaDataContexts(), needReloadTables);
         alterTables(database, schemaAndTablesMap);
         OrderedServicesCache.clearCache();
     }
 
+    private void alterRuleItem(final String databaseName, final Collection<MetaDataVersion> metaDataVersions) throws SQLException {
+        RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
+        ActiveVersionChecker activeVersionChecker = new ActiveVersionChecker(metaDataPersistFacade.getRepository());
+        for (MetaDataVersion each : metaDataVersions) {
+            Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(databaseName, new VersionNodePath(each.getNodePath()).getActiveVersionPath());
+            if (databaseRuleNodePath.isPresent() && activeVersionChecker.checkSame(new VersionNodePath(databaseRuleNodePath.get()), each.getActiveVersion())) {
+                metaDataContextManager.getDatabaseRuleItemManager().alter(databaseRuleNodePath.get());
+            }
+        }
+    }
+    
     @Override
     public void removeRuleConfigurationItem(final ShardingSphereDatabase database, final RuleConfiguration toBeRemovedRuleConfig) throws SQLException {
         if (null == toBeRemovedRuleConfig) {
             return;
         }
         Collection<String> needReloadTables = getNeedReloadTables(database, toBeRemovedRuleConfig);
         Collection<MetaDataVersion> metaDataVersions = metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(), Collections.singleton(toBeRemovedRuleConfig));
-        for (MetaDataVersion each : metaDataVersions) {
-            Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(database.getName(), new VersionNodePath(each.getNodePath()).getActiveVersionPath());
-            if (databaseRuleNodePath.isPresent()) {
-                metaDataContextManager.getDatabaseRuleItemManager().drop(databaseRuleNodePath.get());
-            }
-        }
+        removeRuleItem(database.getName(), metaDataVersions);
         Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap = metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(
                 database.getName(), metaDataContextManager.getMetaDataContexts(), needReloadTables);
         alterTables(database, schemaAndTablesMap);
         OrderedServicesCache.clearCache();
     }
 
-    private void alterTables(final ShardingSphereDatabase database, final Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap) {
-        for (Entry<String, Collection<ShardingSphereTable>> entry : schemaAndTablesMap.entrySet()) {
-            for (ShardingSphereTable each : entry.getValue()) {
-                metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(), entry.getKey(), each);
+    private void removeRuleItem(final String databaseName, final Collection<MetaDataVersion> metaDataVersions) throws SQLException {
+        RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
+        for (MetaDataVersion each : metaDataVersions) {
+            Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(databaseName, new VersionNodePath(each.getNodePath()).getActiveVersionPath());
+            if (databaseRuleNodePath.isPresent()) {
+                metaDataContextManager.getDatabaseRuleItemManager().drop(databaseRuleNodePath.get());
             }
         }
     }
 
-    private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalShardingDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
+    private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
         if (toBeAlteredRuleConfig instanceof SingleRuleConfiguration) {
-            Collection<String> originalSingleTables = originalShardingDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
+            Collection<String> originalSingleTables = originalDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
             return toBeAlteredRuleConfig.getLogicTableNames().stream().filter(each -> !originalSingleTables.contains(each)).collect(Collectors.toList());
         }
         return toBeAlteredRuleConfig.getLogicTableNames();
     }
 
+    private void alterTables(final ShardingSphereDatabase database, final Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap) {
+        for (Entry<String, Collection<ShardingSphereTable>> entry : schemaAndTablesMap.entrySet()) {
+            for (ShardingSphereTable each : entry.getValue()) {
+                metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(), entry.getKey(), each);
+            }
+        }
+    }
+    
     @Override
     public void removeRuleConfiguration(final ShardingSphereDatabase database, final String ruleType) {
         metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(), ruleType);