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/02/07 16:47:26 UTC

(shardingsphere) branch master updated: Refactor usage of VersionNodePathParser (#34597)

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 e02dd5173ac Refactor usage of VersionNodePathParser (#34597)
e02dd5173ac is described below

commit e02dd5173ac6cef262f18ba894ceab224465823b
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sat Feb 8 00:47:20 2025 +0800

    Refactor usage of VersionNodePathParser (#34597)
    
    * Add VersionNodePathParser
    
    * Refactor usage of VersionNodePathParser
    
    * Refactor usage of VersionNodePathParser
---
 .../type/RuleItemAlteredBuildExecutor.java         |  4 +-
 .../type/RuleItemDroppedBuildExecutor.java         |  2 +-
 .../node/path/config/GlobalPropertiesNodePath.java | 12 ++++
 .../mode/node/path/config/GlobalRuleNodePath.java  | 21 +++++--
 .../config/rule/item/NamedRuleItemNodePath.java    |  6 +-
 .../config/rule/item/UniqueRuleItemNodePath.java   |  8 +--
 .../path/metadata/DataSourceMetaDataNodePath.java  | 21 ++++---
 .../node/path/metadata/TableMetaDataNodePath.java  | 11 ++--
 .../node/path/metadata/ViewMetaDataNodePath.java   | 11 ++--
 .../mode/node/path/version/VersionNodePath.java    | 54 ----------------
 ...ionNodePath.java => VersionNodePathParser.java} | 72 +++++++--------------
 .../tuple/YamlRepositoryTupleSwapperEngine.java    | 10 +--
 .../path/version/VersionNodePathParserTest.java    | 73 ++++++++++++++++++++++
 .../node/path/version/VersionNodePathTest.java     | 47 --------------
 .../database/metadata/MetaDataChangedHandler.java  | 12 ++--
 .../metadata/type/TableChangedHandler.java         |  2 +-
 .../database/metadata/type/ViewChangedHandler.java |  2 +-
 .../global/type/GlobalRuleChangedHandler.java      |  2 +-
 .../global/type/PropertiesChangedHandler.java      |  2 +-
 19 files changed, 176 insertions(+), 196 deletions(-)

diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemAlteredBuildExecutor.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemAlteredBuildExecutor.java
index f72cdbe4549..09c9ad54bf8 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemAlteredBuildExecutor.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemAlteredBuildExecutor.java
@@ -37,14 +37,14 @@ public final class RuleItemAlteredBuildExecutor implements RuleItemChangedBuildE
     @Override
     public Optional<AlterRuleItem> build(final RuleNodePath ruleNodePath, final String databaseName, final MetaDataVersion metaDataVersion) {
         for (Entry<String, NamedRuleItemNodePath> entry : ruleNodePath.getNamedItems().entrySet()) {
-            Optional<String> itemName = entry.getValue().getVersionNodePath().findIdentifierByActiveVersionPath(metaDataVersion.getPath(), 1);
+            Optional<String> itemName = entry.getValue().getVersionNodePathParser().findIdentifierByActiveVersionPath(metaDataVersion.getPath(), 1);
             if (itemName.isPresent()) {
                 return Optional.of(new AlterNamedRuleItem(databaseName, itemName.get(), metaDataVersion.getPath(),
                         metaDataVersion.getNextActiveVersion(), ruleNodePath.getRoot().getRuleType() + "." + entry.getKey()));
             }
         }
         for (Entry<String, UniqueRuleItemNodePath> entry : ruleNodePath.getUniqueItems().entrySet()) {
-            if (entry.getValue().getVersionNodePath().isActiveVersionPath(metaDataVersion.getPath())) {
+            if (entry.getValue().getVersionNodePathParser().isActiveVersionPath(metaDataVersion.getPath())) {
                 return Optional.of(new AlterUniqueRuleItem(databaseName, metaDataVersion.getPath(),
                         metaDataVersion.getNextActiveVersion(), ruleNodePath.getRoot().getRuleType() + "." + entry.getKey()));
             }
diff --git a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemDroppedBuildExecutor.java b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemDroppedBuildExecutor.java
index fc84e18c362..c5f01397e46 100644
--- a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemDroppedBuildExecutor.java
+++ b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/changed/executor/type/RuleItemDroppedBuildExecutor.java
@@ -43,7 +43,7 @@ public final class RuleItemDroppedBuildExecutor implements RuleItemChangedBuildE
             }
         }
         for (Entry<String, UniqueRuleItemNodePath> entry : ruleNodePath.getUniqueItems().entrySet()) {
-            if (entry.getValue().getVersionNodePath().isActiveVersionPath(metaDataVersion.getPath())) {
+            if (entry.getValue().getVersionNodePathParser().isActiveVersionPath(metaDataVersion.getPath())) {
                 return Optional.of(new DropUniqueRuleItem(databaseName, ruleNodePath.getRoot().getRuleType() + "." + entry.getKey()));
             }
         }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalPropertiesNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalPropertiesNodePath.java
index 5b30e622b4a..15f2ea8bb62 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalPropertiesNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalPropertiesNodePath.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.mode.node.path.config;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 /**
  * Global properties node path.
@@ -29,6 +30,8 @@ public final class GlobalPropertiesNodePath {
     
     private static final String ROOT_NODE = "/props";
     
+    private static final VersionNodePathParser PARSER = new VersionNodePathParser(getRootPath());
+    
     /**
      * Get properties path.
      *
@@ -46,4 +49,13 @@ public final class GlobalPropertiesNodePath {
     public static VersionNodePath getVersionNodePath() {
         return new VersionNodePath(getRootPath());
     }
+    
+    /**
+     * Get properties version node path parser.
+     *
+     * @return properties version node path parser
+     */
+    public static VersionNodePathParser getVersionNodePathParser() {
+        return PARSER;
+    }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalRuleNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalRuleNodePath.java
index 5e12a06969c..0fa2d7d0274 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalRuleNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/GlobalRuleNodePath.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.mode.node.path.NodePathPattern;
 import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 /**
  * Global props node path.
@@ -30,6 +31,8 @@ public final class GlobalRuleNodePath {
     
     private static final String ROOT_NODE = "/rules";
     
+    private static final VersionNodePathParser PARSER = new VersionNodePathParser(NodePathPattern.IDENTIFIER);
+    
     /**
      * Get global rule root path.
      *
@@ -60,11 +63,21 @@ public final class GlobalRuleNodePath {
     }
     
     /**
-     * Get global rule version pattern node path.
+     * Get view version pattern node path parser.
      *
-     * @return global rule version pattern node path
+     * @return view version node path parser
+     */
+    public static VersionNodePathParser getVersionNodePathParser() {
+        return PARSER;
+    }
+    
+    /**
+     * Get view version pattern node path parser.
+     *
+     * @param ruleTypeName rule type name
+     * @return view version node path parser
      */
-    public static VersionNodePath getVersionPatternNodePath() {
-        return new VersionNodePath(NodePathPattern.IDENTIFIER);
+    public static VersionNodePathParser getVersionNodePathParser(final String ruleTypeName) {
+        return new VersionNodePathParser(ruleTypeName);
     }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/NamedRuleItemNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/NamedRuleItemNodePath.java
index 9d92e924657..9cb326ee142 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/NamedRuleItemNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/NamedRuleItemNodePath.java
@@ -20,7 +20,7 @@ package org.apache.shardingsphere.mode.node.path.config.rule.item;
 import lombok.Getter;
 import org.apache.shardingsphere.mode.node.path.NodePathPattern;
 import org.apache.shardingsphere.mode.node.path.config.rule.root.RuleRootNodePath;
-import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 import java.util.Optional;
 import java.util.regex.Matcher;
@@ -36,12 +36,12 @@ public final class NamedRuleItemNodePath {
     private final Pattern itemPathPattern;
     
     @Getter
-    private final VersionNodePath versionNodePath;
+    private final VersionNodePathParser versionNodePathParser;
     
     public NamedRuleItemNodePath(final RuleRootNodePath rootNodePath, final String type) {
         this.type = type;
         String pattern = String.join("/", rootNodePath.getNodePrefix() + type, NodePathPattern.IDENTIFIER);
-        versionNodePath = new VersionNodePath(pattern);
+        versionNodePathParser = new VersionNodePathParser(pattern);
         itemPathPattern = Pattern.compile(pattern + "$");
     }
     
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/UniqueRuleItemNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/UniqueRuleItemNodePath.java
index fccb514d98d..d05e356c699 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/UniqueRuleItemNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/config/rule/item/UniqueRuleItemNodePath.java
@@ -19,7 +19,7 @@ package org.apache.shardingsphere.mode.node.path.config.rule.item;
 
 import lombok.Getter;
 import org.apache.shardingsphere.mode.node.path.config.rule.root.RuleRootNodePath;
-import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 /**
  * Unique rule item node path.
@@ -31,18 +31,18 @@ public final class UniqueRuleItemNodePath {
     private final String type;
     
     @Getter
-    private final VersionNodePath versionNodePath;
+    private final VersionNodePathParser versionNodePathParser;
     
     public UniqueRuleItemNodePath(final RuleRootNodePath ruleRootNodePath, final String type) {
         parentNode = null;
         this.type = type;
-        versionNodePath = new VersionNodePath(ruleRootNodePath.getNodePrefix() + type);
+        versionNodePathParser = new VersionNodePathParser(ruleRootNodePath.getNodePrefix() + type);
     }
     
     public UniqueRuleItemNodePath(final RuleRootNodePath ruleRootNodePath, final String parentNode, final String type) {
         this.parentNode = parentNode;
         this.type = type;
-        versionNodePath = new VersionNodePath(ruleRootNodePath.getNodePrefix() + parentNode + "/" + type);
+        versionNodePathParser = new VersionNodePathParser(ruleRootNodePath.getNodePrefix() + parentNode + "/" + type);
     }
     
     /**
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/DataSourceMetaDataNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/DataSourceMetaDataNodePath.java
index a511e3f5917..9172324fe2a 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/DataSourceMetaDataNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/DataSourceMetaDataNodePath.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.mode.node.path.NodePathPattern;
 import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 import java.util.Optional;
 import java.util.regex.Matcher;
@@ -40,6 +41,10 @@ public final class DataSourceMetaDataNodePath {
     
     private static final String UNITS_NODE = "units";
     
+    private static final VersionNodePathParser STORAGE_UNITS_PARSER = new VersionNodePathParser(String.join("/", getStorageUnitsPath(NodePathPattern.IDENTIFIER), NodePathPattern.IDENTIFIER));
+    
+    private static final VersionNodePathParser STORAGE_NODES_PARSER = new VersionNodePathParser(String.join("/", getStorageNodesPath(NodePathPattern.IDENTIFIER), NodePathPattern.IDENTIFIER));
+    
     /**
      * Get data source root path.
      *
@@ -115,21 +120,21 @@ public final class DataSourceMetaDataNodePath {
     }
     
     /**
-     * Get storage unit version pattern unit path.
+     * Get storage unit version unit path parser.
      *
-     * @return storage unit version pattern node path
+     * @return storage unit version node path parser
      */
-    public static VersionNodePath getStorageUnitVersionPatternNodePath() {
-        return new VersionNodePath(String.join("/", getStorageUnitsPath(NodePathPattern.IDENTIFIER), NodePathPattern.IDENTIFIER));
+    public static VersionNodePathParser getStorageUnitVersionNodePathParser() {
+        return STORAGE_UNITS_PARSER;
     }
     
     /**
-     * Get storage node version pattern node path.
+     * Get storage node version node path parser.
      *
-     * @return storage node version pattern node path
+     * @return storage node version node path parser
      */
-    public static VersionNodePath getStorageNodeVersionPatternNodePath() {
-        return new VersionNodePath(String.join("/", getStorageNodesPath(NodePathPattern.IDENTIFIER), NodePathPattern.IDENTIFIER));
+    public static VersionNodePathParser getStorageNodeVersionNodePathParser() {
+        return STORAGE_NODES_PARSER;
     }
     
     /**
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/TableMetaDataNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/TableMetaDataNodePath.java
index 96d649836e4..2052cd037e0 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/TableMetaDataNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/TableMetaDataNodePath.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.mode.node.path.NodePathPattern;
 import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 import java.util.Optional;
 import java.util.regex.Matcher;
@@ -34,6 +35,8 @@ public final class TableMetaDataNodePath {
     
     private static final String TABLES_NODE = "tables";
     
+    private static final VersionNodePathParser PARSER = new VersionNodePathParser(getTablePath(NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER));
+    
     /**
      * Get table root path.
      *
@@ -92,11 +95,11 @@ public final class TableMetaDataNodePath {
     }
     
     /**
-     * Get table version pattern node path.
+     * Get table version pattern node path parser.
      *
-     * @return table version node path
+     * @return table version node path parser
      */
-    public static VersionNodePath getVersionPatternNodePath() {
-        return new VersionNodePath(getTablePath(NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER));
+    public static VersionNodePathParser getVersionNodePathParser() {
+        return PARSER;
     }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/ViewMetaDataNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/ViewMetaDataNodePath.java
index 913e1628bdd..d1a59755696 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/ViewMetaDataNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/metadata/ViewMetaDataNodePath.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.shardingsphere.mode.node.path.NodePathPattern;
 import org.apache.shardingsphere.mode.node.path.version.VersionNodePath;
+import org.apache.shardingsphere.mode.node.path.version.VersionNodePathParser;
 
 import java.util.Optional;
 import java.util.regex.Matcher;
@@ -34,6 +35,8 @@ public final class ViewMetaDataNodePath {
     
     private static final String VIEWS_NODE = "views";
     
+    private static final VersionNodePathParser PARSER = new VersionNodePathParser(getViewPath(NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER));
+    
     /**
      * Get view root path.
      *
@@ -92,11 +95,11 @@ public final class ViewMetaDataNodePath {
     }
     
     /**
-     * Get view version pattern node path.
+     * Get view version pattern node path parser.
      *
-     * @return view version node path
+     * @return view version node path parser
      */
-    public static VersionNodePath getVersionPatternNodePath() {
-        return new VersionNodePath(getViewPath(NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER, NodePathPattern.IDENTIFIER));
+    public static VersionNodePathParser getVersionNodePathParser() {
+        return PARSER;
     }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java
index a2203e8c9e4..983567ce55c 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java
@@ -19,18 +19,12 @@ package org.apache.shardingsphere.mode.node.path.version;
 
 import lombok.RequiredArgsConstructor;
 
-import java.util.Optional;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
 /**
  * Version node path.
  */
 @RequiredArgsConstructor
 public final class VersionNodePath {
     
-    public static final String VERSION_PATTERN = "(\\d+)";
-    
     private static final String ACTIVE_VERSION = "active_version";
     
     private static final String VERSIONS = "versions";
@@ -64,52 +58,4 @@ public final class VersionNodePath {
     public String getVersionPath(final int version) {
         return String.join("/", getVersionsPath(), String.valueOf(version));
     }
-    
-    /**
-     * Judge whether to active version path.
-     *
-     * @param path to be judged path
-     * @return is active version path or not
-     */
-    public boolean isActiveVersionPath(final String path) {
-        Pattern pattern = Pattern.compile(getActiveVersionPath() + "$", Pattern.CASE_INSENSITIVE);
-        return pattern.matcher(path).find();
-    }
-    
-    /**
-     * Find identifier name by active version path.
-     *
-     * @param activeVersionPath active version path
-     * @param identifierGroupIndex identifier group index
-     * @return found identifier
-     */
-    public Optional<String> findIdentifierByActiveVersionPath(final String activeVersionPath, final int identifierGroupIndex) {
-        Pattern pattern = Pattern.compile(getActiveVersionPath() + "$", Pattern.CASE_INSENSITIVE);
-        Matcher matcher = pattern.matcher(activeVersionPath);
-        return matcher.find() ? Optional.of(matcher.group(identifierGroupIndex)) : Optional.empty();
-    }
-    
-    /**
-     * Judge whether to version path.
-     *
-     * @param path to be judged path
-     * @return is version path or not
-     */
-    public boolean isVersionPath(final String path) {
-        Pattern pattern = Pattern.compile(String.join("/", getVersionsPath(), VERSION_PATTERN) + "$", Pattern.CASE_INSENSITIVE);
-        return pattern.matcher(path).find();
-    }
-    
-    /**
-     * Find identifier name by versions' path.
-     *
-     * @param versionsPath versions path
-     * @param identifierGroupIndex identifier group index
-     * @return found identifier
-     */
-    public Optional<String> findIdentifierByVersionsPath(final String versionsPath, final int identifierGroupIndex) {
-        Pattern pattern = Pattern.compile(getVersionsPath(), Pattern.CASE_INSENSITIVE);
-        Matcher matcher = pattern.matcher(versionsPath);
-        return matcher.find() ? Optional.of(matcher.group(identifierGroupIndex)) : Optional.empty();
-    }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParser.java
similarity index 59%
copy from mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java
copy to mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParser.java
index a2203e8c9e4..69ee7141147 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePath.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParser.java
@@ -17,63 +17,48 @@
 
 package org.apache.shardingsphere.mode.node.path.version;
 
-import lombok.RequiredArgsConstructor;
-
 import java.util.Optional;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
- * Version node path.
+ * Version node path parser.
  */
-@RequiredArgsConstructor
-public final class VersionNodePath {
+public final class VersionNodePathParser {
     
-    public static final String VERSION_PATTERN = "(\\d+)";
+    private static final String VERSION_PATTERN = "(\\d+)";
     
-    private static final String ACTIVE_VERSION = "active_version";
+    private final Pattern activeVersionPattern;
     
-    private static final String VERSIONS = "versions";
+    private final Pattern versionPattern;
     
-    private final String path;
+    private final Pattern versionWildcardPattern;
     
-    /**
-     * Get active version path.
-     *
-     * @return active version path
-     */
-    public String getActiveVersionPath() {
-        return String.join("/", path, ACTIVE_VERSION);
-    }
-    
-    /**
-     * Get versions path.
-     *
-     * @return versions path
-     */
-    public String getVersionsPath() {
-        return String.join("/", path, VERSIONS);
+    public VersionNodePathParser(final String regex) {
+        VersionNodePath nodePath = new VersionNodePath(regex);
+        activeVersionPattern = Pattern.compile(nodePath.getActiveVersionPath() + "$", Pattern.CASE_INSENSITIVE);
+        versionPattern = Pattern.compile(String.join("/", nodePath.getVersionsPath(), VERSION_PATTERN) + "$", Pattern.CASE_INSENSITIVE);
+        versionWildcardPattern = Pattern.compile(nodePath.getVersionsPath(), Pattern.CASE_INSENSITIVE);
     }
     
     /**
-     * Get version path.
+     * Judge whether to active version path.
      *
-     * @param version version
-     * @return version path
+     * @param path to be judged path
+     * @return is active version path or not
      */
-    public String getVersionPath(final int version) {
-        return String.join("/", getVersionsPath(), String.valueOf(version));
+    public boolean isActiveVersionPath(final String path) {
+        return activeVersionPattern.matcher(path).find();
     }
     
     /**
-     * Judge whether to active version path.
+     * Judge whether to version path.
      *
      * @param path to be judged path
-     * @return is active version path or not
+     * @return is version path or not
      */
-    public boolean isActiveVersionPath(final String path) {
-        Pattern pattern = Pattern.compile(getActiveVersionPath() + "$", Pattern.CASE_INSENSITIVE);
-        return pattern.matcher(path).find();
+    public boolean isVersionPath(final String path) {
+        return versionPattern.matcher(path).find();
     }
     
     /**
@@ -84,22 +69,10 @@ public final class VersionNodePath {
      * @return found identifier
      */
     public Optional<String> findIdentifierByActiveVersionPath(final String activeVersionPath, final int identifierGroupIndex) {
-        Pattern pattern = Pattern.compile(getActiveVersionPath() + "$", Pattern.CASE_INSENSITIVE);
-        Matcher matcher = pattern.matcher(activeVersionPath);
+        Matcher matcher = activeVersionPattern.matcher(activeVersionPath);
         return matcher.find() ? Optional.of(matcher.group(identifierGroupIndex)) : Optional.empty();
     }
     
-    /**
-     * Judge whether to version path.
-     *
-     * @param path to be judged path
-     * @return is version path or not
-     */
-    public boolean isVersionPath(final String path) {
-        Pattern pattern = Pattern.compile(String.join("/", getVersionsPath(), VERSION_PATTERN) + "$", Pattern.CASE_INSENSITIVE);
-        return pattern.matcher(path).find();
-    }
-    
     /**
      * Find identifier name by versions' path.
      *
@@ -108,8 +81,7 @@ public final class VersionNodePath {
      * @return found identifier
      */
     public Optional<String> findIdentifierByVersionsPath(final String versionsPath, final int identifierGroupIndex) {
-        Pattern pattern = Pattern.compile(getVersionsPath(), Pattern.CASE_INSENSITIVE);
-        Matcher matcher = pattern.matcher(versionsPath);
+        Matcher matcher = versionWildcardPattern.matcher(versionsPath);
         return matcher.find() ? Optional.of(matcher.group(identifierGroupIndex)) : Optional.empty();
     }
 }
diff --git a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/tuple/YamlRepositoryTupleSwapperEngine.java b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/tuple/YamlRepositoryTupleSwapperEngine.java
index 07a7a4eb319..c5106f8d177 100644
--- a/mode/node/src/main/java/org/apache/shardingsphere/mode/node/tuple/YamlRepositoryTupleSwapperEngine.java
+++ b/mode/node/src/main/java/org/apache/shardingsphere/mode/node/tuple/YamlRepositoryTupleSwapperEngine.java
@@ -153,7 +153,7 @@ public final class YamlRepositoryTupleSwapperEngine {
                                                                         final Class<? extends YamlRuleConfiguration> toBeSwappedType, final RepositoryTupleEntity tupleEntity) {
         if (YamlGlobalRuleConfiguration.class.isAssignableFrom(toBeSwappedType)) {
             for (RepositoryTuple each : repositoryTuples) {
-                if (GlobalRuleNodePath.getVersionNodePath(tupleEntity.value()).isVersionPath(each.getKey())) {
+                if (GlobalRuleNodePath.getVersionNodePathParser(tupleEntity.value()).isVersionPath(each.getKey())) {
                     return Optional.of(YamlEngine.unmarshal(each.getValue(), toBeSwappedType));
                 }
             }
@@ -162,7 +162,7 @@ public final class YamlRepositoryTupleSwapperEngine {
         YamlRuleConfiguration yamlRuleConfig = toBeSwappedType.getConstructor().newInstance();
         RuleNodePath ruleNodePath = TypedSPILoader.getService(RuleNodePathProvider.class, yamlRuleConfig.getRuleConfigurationType()).getRuleNodePath();
         for (RepositoryTuple each : repositoryTuples.stream().filter(each -> ruleNodePath.getRoot().isValidatedPath(each.getKey())).collect(Collectors.toList())) {
-            if (ruleNodePath.getUniqueItem(tupleEntity.value()).getVersionNodePath().isVersionPath(each.getKey())) {
+            if (ruleNodePath.getUniqueItem(tupleEntity.value()).getVersionNodePathParser().isVersionPath(each.getKey())) {
                 return Optional.of(YamlEngine.unmarshal(each.getValue(), toBeSwappedType));
             }
         }
@@ -202,17 +202,17 @@ public final class YamlRepositoryTupleSwapperEngine {
         String tupleName = getTupleName(field);
         RepositoryTupleKeyListNameGenerator tupleKeyListNameGenerator = field.getAnnotation(RepositoryTupleKeyListNameGenerator.class);
         if (null != tupleKeyListNameGenerator && fieldValue instanceof Collection) {
-            ruleNodePath.getNamedItem(tupleName).getVersionNodePath()
+            ruleNodePath.getNamedItem(tupleName).getVersionNodePathParser()
                     .findIdentifierByVersionsPath(repositoryTuple.getKey(), 1).ifPresent(optional -> ((Collection) fieldValue).add(repositoryTuple.getValue()));
             return;
         }
         if (fieldValue instanceof Map) {
             Class<?> valueClass = (Class) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[1];
-            ruleNodePath.getNamedItem(tupleName).getVersionNodePath().findIdentifierByVersionsPath(repositoryTuple.getKey(), 1)
+            ruleNodePath.getNamedItem(tupleName).getVersionNodePathParser().findIdentifierByVersionsPath(repositoryTuple.getKey(), 1)
                     .ifPresent(optional -> ((Map) fieldValue).put(optional, YamlEngine.unmarshal(repositoryTuple.getValue(), valueClass)));
             return;
         }
-        if (!ruleNodePath.getUniqueItem(tupleName).getVersionNodePath().isVersionPath(repositoryTuple.getKey())) {
+        if (!ruleNodePath.getUniqueItem(tupleName).getVersionNodePathParser().isVersionPath(repositoryTuple.getKey())) {
             return;
         }
         if (fieldValue instanceof Collection) {
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParserTest.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParserTest.java
new file mode 100644
index 00000000000..fb47ee3cfb8
--- /dev/null
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathParserTest.java
@@ -0,0 +1,73 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.mode.node.path.version;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class VersionNodePathParserTest {
+    
+    private final VersionNodePathParser parser = new VersionNodePathParser("/metadata/([\\w\\-]+)/schemas/([\\w\\-]+)/tables/([\\w\\-]+)");
+    
+    @Test
+    void assertIsActiveVersionPath() {
+        assertTrue(parser.isActiveVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version"));
+        assertFalse(parser.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions"));
+    }
+    
+    @Test
+    void assertFindIdentifierByActiveVersionPath() {
+        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version";
+        assertThat(parser.findIdentifierByActiveVersionPath(path, 1), is(Optional.of("foo_db")));
+        assertThat(parser.findIdentifierByActiveVersionPath(path, 2), is(Optional.of("foo_schema")));
+        assertThat(parser.findIdentifierByActiveVersionPath(path, 3), is(Optional.of("foo_tbl")));
+    }
+    
+    @Test
+    void assertNotFindIdentifierByActiveVersionPath() {
+        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions";
+        assertFalse(parser.findIdentifierByActiveVersionPath(path, 1).isPresent());
+    }
+    
+    @Test
+    void assertIsVersionPath() {
+        assertTrue(parser.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0"));
+        assertFalse(parser.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions"));
+        assertFalse(parser.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/xxx"));
+    }
+    
+    @Test
+    void assertFindIdentifierByVersionsPath() {
+        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0";
+        assertThat(parser.findIdentifierByVersionsPath(path, 1), is(Optional.of("foo_db")));
+        assertThat(parser.findIdentifierByVersionsPath(path, 2), is(Optional.of("foo_schema")));
+        assertThat(parser.findIdentifierByVersionsPath(path, 3), is(Optional.of("foo_tbl")));
+    }
+    
+    @Test
+    void assertNotFindIdentifierByVersionsPath() {
+        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version";
+        assertFalse(parser.findIdentifierByVersionsPath(path, 1).isPresent());
+    }
+}
diff --git a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathTest.java b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathTest.java
index 3e2b91102c0..4f94288fcce 100644
--- a/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathTest.java
+++ b/mode/node/src/test/java/org/apache/shardingsphere/mode/node/path/version/VersionNodePathTest.java
@@ -19,17 +19,11 @@ package org.apache.shardingsphere.mode.node.path.version;
 
 import org.junit.jupiter.api.Test;
 
-import java.util.Optional;
-
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class VersionNodePathTest {
     
-    private final VersionNodePath versionPatternNodePath = new VersionNodePath("/metadata/([\\w\\-]+)/schemas/([\\w\\-]+)/tables/([\\w\\-]+)");
-    
     @Test
     void assertGetActiveVersionPath() {
         assertThat(new VersionNodePath("foo").getActiveVersionPath(), is("foo/active_version"));
@@ -44,45 +38,4 @@ class VersionNodePathTest {
     void assertGetVersionPath() {
         assertThat(new VersionNodePath("foo").getVersionPath(0), is("foo/versions/0"));
     }
-    
-    @Test
-    void assertIsActiveVersionPath() {
-        assertTrue(versionPatternNodePath.isActiveVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version"));
-        assertFalse(versionPatternNodePath.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions"));
-    }
-    
-    @Test
-    void assertFindIdentifierByActiveVersionPath() {
-        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version";
-        assertThat(versionPatternNodePath.findIdentifierByActiveVersionPath(path, 1), is(Optional.of("foo_db")));
-        assertThat(versionPatternNodePath.findIdentifierByActiveVersionPath(path, 2), is(Optional.of("foo_schema")));
-        assertThat(versionPatternNodePath.findIdentifierByActiveVersionPath(path, 3), is(Optional.of("foo_tbl")));
-    }
-    
-    @Test
-    void assertNotFindIdentifierByActiveVersionPath() {
-        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions";
-        assertFalse(versionPatternNodePath.findIdentifierByActiveVersionPath(path, 1).isPresent());
-    }
-    
-    @Test
-    void assertIsVersionPath() {
-        assertTrue(versionPatternNodePath.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/0"));
-        assertFalse(versionPatternNodePath.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions"));
-        assertFalse(versionPatternNodePath.isVersionPath("/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions/xxx"));
-    }
-    
-    @Test
-    void assertFindIdentifierByVersionsPath() {
-        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/versions";
-        assertThat(versionPatternNodePath.findIdentifierByVersionsPath(path, 1), is(Optional.of("foo_db")));
-        assertThat(versionPatternNodePath.findIdentifierByVersionsPath(path, 2), is(Optional.of("foo_schema")));
-        assertThat(versionPatternNodePath.findIdentifierByVersionsPath(path, 3), is(Optional.of("foo_tbl")));
-    }
-    
-    @Test
-    void assertNotFindIdentifierByVersionsPath() {
-        String path = "/metadata/foo_db/schemas/foo_schema/tables/foo_tbl/active_version";
-        assertFalse(versionPatternNodePath.findIdentifierByVersionsPath(path, 1).isPresent());
-    }
 }
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
index aacfbd68a2e..a3b5c47cbad 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
@@ -94,11 +94,11 @@ public final class MetaDataChangedHandler {
     }
     
     private boolean isTableMetaDataChanged(final String key) {
-        return TableMetaDataNodePath.isTablePath(key) || TableMetaDataNodePath.getVersionPatternNodePath().isActiveVersionPath(key);
+        return TableMetaDataNodePath.isTablePath(key) || TableMetaDataNodePath.getVersionNodePathParser().isActiveVersionPath(key);
     }
     
     private void handleTableChanged(final String databaseName, final String schemaName, final DataChangedEvent event) {
-        if ((Type.ADDED == event.getType() || Type.UPDATED == event.getType()) && TableMetaDataNodePath.getVersionPatternNodePath().isActiveVersionPath(event.getKey())) {
+        if ((Type.ADDED == event.getType() || Type.UPDATED == event.getType()) && TableMetaDataNodePath.getVersionNodePathParser().isActiveVersionPath(event.getKey())) {
             tableChangedHandler.handleCreatedOrAltered(databaseName, schemaName, event);
         } else if (Type.DELETED == event.getType() && TableMetaDataNodePath.isTablePath(event.getKey())) {
             tableChangedHandler.handleDropped(databaseName, schemaName, event);
@@ -106,11 +106,11 @@ public final class MetaDataChangedHandler {
     }
     
     private boolean isViewMetaDataChanged(final String key) {
-        return ViewMetaDataNodePath.getVersionPatternNodePath().isActiveVersionPath(key) || ViewMetaDataNodePath.isViewPath(key);
+        return ViewMetaDataNodePath.getVersionNodePathParser().isActiveVersionPath(key) || ViewMetaDataNodePath.isViewPath(key);
     }
     
     private void handleViewChanged(final String databaseName, final String schemaName, final DataChangedEvent event) {
-        if ((Type.ADDED == event.getType() || Type.UPDATED == event.getType()) && ViewMetaDataNodePath.getVersionPatternNodePath().isActiveVersionPath(event.getKey())) {
+        if ((Type.ADDED == event.getType() || Type.UPDATED == event.getType()) && ViewMetaDataNodePath.getVersionNodePathParser().isActiveVersionPath(event.getKey())) {
             viewChangedHandler.handleCreatedOrAltered(databaseName, schemaName, event);
         } else if (Type.DELETED == event.getType() && ViewMetaDataNodePath.isViewPath(event.getKey())) {
             viewChangedHandler.handleDropped(databaseName, schemaName, event);
@@ -118,7 +118,7 @@ public final class MetaDataChangedHandler {
     }
     
     private void handleDataSourceChanged(final String databaseName, final DataChangedEvent event) {
-        Optional<String> storageUnitName = DataSourceMetaDataNodePath.getStorageUnitVersionPatternNodePath().findIdentifierByActiveVersionPath(event.getKey(), 2);
+        Optional<String> storageUnitName = DataSourceMetaDataNodePath.getStorageUnitVersionNodePathParser().findIdentifierByActiveVersionPath(event.getKey(), 2);
         boolean isActiveVersion = true;
         if (!storageUnitName.isPresent()) {
             storageUnitName = DataSourceMetaDataNodePath.findStorageUnitNameByStorageUnitPath(event.getKey());
@@ -128,7 +128,7 @@ public final class MetaDataChangedHandler {
             handleStorageUnitChanged(databaseName, event, storageUnitName.get(), isActiveVersion);
             return;
         }
-        Optional<String> storageNodeName = DataSourceMetaDataNodePath.getStorageNodeVersionPatternNodePath().findIdentifierByActiveVersionPath(event.getKey(), 2);
+        Optional<String> storageNodeName = DataSourceMetaDataNodePath.getStorageNodeVersionNodePathParser().findIdentifierByActiveVersionPath(event.getKey(), 2);
         isActiveVersion = true;
         if (!storageNodeName.isPresent()) {
             storageNodeName = DataSourceMetaDataNodePath.findStorageNodeNameByStorageNodePath(event.getKey());
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/TableChangedHandler.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/TableChangedHandler.java
index 65869661ebb..9e58559fc26 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/TableChangedHandler.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/TableChangedHandler.java
@@ -46,7 +46,7 @@ public final class TableChangedHandler {
      * @param event data changed event
      */
     public void handleCreatedOrAltered(final String databaseName, final String schemaName, final DataChangedEvent event) {
-        String tableName = TableMetaDataNodePath.getVersionPatternNodePath().findIdentifierByActiveVersionPath(event.getKey(), 3)
+        String tableName = TableMetaDataNodePath.getVersionNodePathParser().findIdentifierByActiveVersionPath(event.getKey(), 3)
                 .orElseThrow(() -> new IllegalStateException("Table name not found."));
         ActiveVersionChecker.checkActiveVersion(contextManager, event);
         ShardingSphereTable table = contextManager.getPersistServiceFacade().getMetaDataPersistFacade().getDatabaseMetaDataFacade().getTable().load(databaseName, schemaName, tableName);
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/ViewChangedHandler.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/ViewChangedHandler.java
index 01e4535f8c4..b486537c02d 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/ViewChangedHandler.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/type/ViewChangedHandler.java
@@ -46,7 +46,7 @@ public final class ViewChangedHandler {
      * @param event data changed event
      */
     public void handleCreatedOrAltered(final String databaseName, final String schemaName, final DataChangedEvent event) {
-        String viewName = ViewMetaDataNodePath.getVersionPatternNodePath().findIdentifierByActiveVersionPath(event.getKey(), 3).orElseThrow(() -> new IllegalStateException("View name not found."));
+        String viewName = ViewMetaDataNodePath.getVersionNodePathParser().findIdentifierByActiveVersionPath(event.getKey(), 3).orElseThrow(() -> new IllegalStateException("View name not found."));
         ActiveVersionChecker.checkActiveVersion(contextManager, event);
         ShardingSphereView view = contextManager.getPersistServiceFacade().getMetaDataPersistFacade().getDatabaseMetaDataFacade().getView().load(databaseName, schemaName, viewName);
         contextManager.getMetaDataContextManager().getDatabaseMetaDataManager().alterView(databaseName, schemaName, view);
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/GlobalRuleChangedHandler.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/GlobalRuleChangedHandler.java
index bf3541f70c7..9dae2a10d9a 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/GlobalRuleChangedHandler.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/GlobalRuleChangedHandler.java
@@ -47,7 +47,7 @@ public final class GlobalRuleChangedHandler implements GlobalDataChangedEventHan
     
     @Override
     public void handle(final ContextManager contextManager, final DataChangedEvent event) {
-        Optional<String> ruleTypeName = GlobalRuleNodePath.getVersionPatternNodePath().findIdentifierByActiveVersionPath(event.getKey(), 1);
+        Optional<String> ruleTypeName = GlobalRuleNodePath.getVersionNodePathParser().findIdentifierByActiveVersionPath(event.getKey(), 1);
         if (!ruleTypeName.isPresent()) {
             return;
         }
diff --git a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/PropertiesChangedHandler.java b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/PropertiesChangedHandler.java
index 2f6b07ea1c1..0d0c51e3167 100644
--- a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/PropertiesChangedHandler.java
+++ b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/global/type/PropertiesChangedHandler.java
@@ -44,7 +44,7 @@ public final class PropertiesChangedHandler implements GlobalDataChangedEventHan
     
     @Override
     public void handle(final ContextManager contextManager, final DataChangedEvent event) {
-        if (!GlobalPropertiesNodePath.getVersionNodePath().isActiveVersionPath(event.getKey())) {
+        if (!GlobalPropertiesNodePath.getVersionNodePathParser().isActiveVersionPath(event.getKey())) {
             return;
         }
         ActiveVersionChecker.checkActiveVersion(contextManager, event);