This is an automated email from the ASF dual-hosted git repository.

wuweijie 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 28ee9a0861f Rename ReadwriteSplittingDataSourceRule to 
ReadwriteSplittingDataSourceGroupRule (#31015)
28ee9a0861f is described below

commit 28ee9a0861f2d790a867d8284d9d3ed2498ff29f
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Apr 25 23:22:39 2024 +0800

    Rename ReadwriteSplittingDataSourceRule to 
ReadwriteSplittingDataSourceGroupRule (#31015)
---
 .../route/ReadwriteSplittingDataSourceRouter.java  |  4 +-
 .../route/ReadwriteSplittingSQLRouter.java         | 14 +++----
 ...ualifiedReadwriteSplittingDataSourceRouter.java |  6 +--
 ...dReadwriteSplittingPrimaryDataSourceRouter.java |  6 +--
 ...riteSplittingTransactionalDataSourceRouter.java |  6 +--
 ...StandardReadwriteSplittingDataSourceRouter.java |  6 +--
 .../filter/DisabledReadDataSourcesFilter.java      |  4 +-
 .../standard/filter/ReadDataSourcesFilter.java     |  4 +-
 ... => ReadwriteSplittingDataSourceGroupRule.java} |  8 ++--
 .../rule/ReadwriteSplittingRule.java               | 44 +++++++++++-----------
 ...riteSplittingDataSourceMapperRuleAttribute.java |  6 +--
 .../ReadwriteSplittingExportableRuleAttribute.java |  8 ++--
 ...riteSplittingStaticDataSourceRuleAttribute.java | 22 +++++------
 ...SplittingTransactionalDataSourceRouterTest.java | 10 ++---
 ...dardReadwriteSplittingDataSourceRouterTest.java |  6 +--
 .../filter/DisabledReadDataSourcesFilterTest.java  |  6 +--
 ...ReadwriteSplittingDataSourceGroupRuleTest.java} |  9 ++---
 .../rule/ReadwriteSplittingRuleTest.java           | 22 +++++------
 ...SplittingDataSourceMapperRuleAttributeTest.java |  8 ++--
 ...wStatusFromReadwriteSplittingRulesExecutor.java | 18 ++++-----
 ...eadwriteSplittingStorageUnitStatusExecutor.java | 17 +++++----
 ...tusFromReadwriteSplittingRulesExecutorTest.java | 10 ++---
 22 files changed, 123 insertions(+), 121 deletions(-)

diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingDataSourceRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingDataSourceRouter.java
index 902d7a2ad92..6bed86521de 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingDataSourceRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingDataSourceRouter.java
@@ -25,7 +25,7 @@ import 
org.apache.shardingsphere.readwritesplitting.route.qualified.QualifiedRea
 import 
org.apache.shardingsphere.readwritesplitting.route.qualified.type.QualifiedReadwriteSplittingPrimaryDataSourceRouter;
 import 
org.apache.shardingsphere.readwritesplitting.route.qualified.type.QualifiedReadwriteSplittingTransactionalDataSourceRouter;
 import 
org.apache.shardingsphere.readwritesplitting.route.standard.StandardReadwriteSplittingDataSourceRouter;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.Arrays;
 import java.util.Collection;
@@ -36,7 +36,7 @@ import java.util.Collection;
 @RequiredArgsConstructor
 public final class ReadwriteSplittingDataSourceRouter {
     
-    private final ReadwriteSplittingDataSourceRule rule;
+    private final ReadwriteSplittingDataSourceGroupRule rule;
     
     private final ConnectionContext connectionContext;
     
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java
index 0028a0a7f40..9c59e54b29a 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouter.java
@@ -28,7 +28,7 @@ import 
org.apache.shardingsphere.infra.route.context.RouteUnit;
 import org.apache.shardingsphere.infra.session.connection.ConnectionContext;
 import org.apache.shardingsphere.infra.session.query.QueryContext;
 import 
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingOrder;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
 
 import java.util.Collection;
@@ -46,9 +46,9 @@ public final class ReadwriteSplittingSQLRouter implements 
SQLRouter<ReadwriteSpl
     public RouteContext createRouteContext(final QueryContext queryContext, 
final RuleMetaData globalRuleMetaData,
                                            final ShardingSphereDatabase 
database, final ReadwriteSplittingRule rule, final ConfigurationProperties 
props, final ConnectionContext connectionContext) {
         RouteContext result = new RouteContext();
-        ReadwriteSplittingDataSourceRule singleDataSourceRule = 
rule.getSingleDataSourceRule();
-        String dataSourceName = new 
ReadwriteSplittingDataSourceRouter(singleDataSourceRule, 
connectionContext).route(queryContext.getSqlStatementContext(), 
queryContext.getHintValueContext());
-        result.getRouteUnits().add(new RouteUnit(new 
RouteMapper(singleDataSourceRule.getName(), dataSourceName), 
Collections.emptyList()));
+        ReadwriteSplittingDataSourceGroupRule dataSourceGroupRule = 
rule.getSingleDataSourceGroupRule();
+        String dataSourceName = new 
ReadwriteSplittingDataSourceRouter(dataSourceGroupRule, 
connectionContext).route(queryContext.getSqlStatementContext(), 
queryContext.getHintValueContext());
+        result.getRouteUnits().add(new RouteUnit(new 
RouteMapper(dataSourceGroupRule.getName(), dataSourceName), 
Collections.emptyList()));
         return result;
     }
     
@@ -59,10 +59,10 @@ public final class ReadwriteSplittingSQLRouter implements 
SQLRouter<ReadwriteSpl
         Collection<RouteUnit> toBeAdded = new LinkedList<>();
         for (RouteUnit each : routeContext.getRouteUnits()) {
             String dataSourceName = each.getDataSourceMapper().getLogicName();
-            Optional<ReadwriteSplittingDataSourceRule> dataSourceRule = 
rule.findDataSourceRule(dataSourceName);
-            if (dataSourceRule.isPresent() && 
dataSourceRule.get().getName().equalsIgnoreCase(each.getDataSourceMapper().getActualName()))
 {
+            Optional<ReadwriteSplittingDataSourceGroupRule> 
dataSourceGroupRule = rule.findDataSourceGroupRule(dataSourceName);
+            if (dataSourceGroupRule.isPresent() && 
dataSourceGroupRule.get().getName().equalsIgnoreCase(each.getDataSourceMapper().getActualName()))
 {
                 toBeRemoved.add(each);
-                String actualDataSourceName = new 
ReadwriteSplittingDataSourceRouter(dataSourceRule.get(), 
connectionContext).route(queryContext.getSqlStatementContext(),
+                String actualDataSourceName = new 
ReadwriteSplittingDataSourceRouter(dataSourceGroupRule.get(), 
connectionContext).route(queryContext.getSqlStatementContext(),
                         queryContext.getHintValueContext());
                 toBeAdded.add(new RouteUnit(new 
RouteMapper(each.getDataSourceMapper().getLogicName(), actualDataSourceName), 
each.getTableMappers()));
             }
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/QualifiedReadwriteSplittingDataSourceRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/QualifiedReadwriteSplittingDataSourceRouter.java
index 6a948129d6d..862a6c82fc7 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/QualifiedReadwriteSplittingDataSourceRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/QualifiedReadwriteSplittingDataSourceRouter.java
@@ -19,7 +19,7 @@ package 
org.apache.shardingsphere.readwritesplitting.route.qualified;
 
 import 
org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
 import org.apache.shardingsphere.infra.hint.HintValueContext;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 /**
  * Qualified data source router for readwrite-splitting.
@@ -35,7 +35,7 @@ public interface QualifiedReadwriteSplittingDataSourceRouter {
      * 
      * @return qualified to route or not
      */
-    boolean isQualified(SQLStatementContext sqlStatementContext, 
ReadwriteSplittingDataSourceRule rule, HintValueContext hintValueContext);
+    boolean isQualified(SQLStatementContext sqlStatementContext, 
ReadwriteSplittingDataSourceGroupRule rule, HintValueContext hintValueContext);
     
     /**
      * Route to data source.
@@ -43,5 +43,5 @@ public interface QualifiedReadwriteSplittingDataSourceRouter {
      * @param rule Readwrite-splitting data source rule
      * @return routed data source name
      */
-    String route(ReadwriteSplittingDataSourceRule rule);
+    String route(ReadwriteSplittingDataSourceGroupRule rule);
 }
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingPrimaryDataSourceRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingPrimaryDataSourceRouter.java
index a1ce90b05ef..c17d801ad6b 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingPrimaryDataSourceRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingPrimaryDataSourceRouter.java
@@ -22,7 +22,7 @@ import 
org.apache.shardingsphere.infra.binder.context.statement.dml.SelectStatem
 import org.apache.shardingsphere.infra.hint.HintManager;
 import org.apache.shardingsphere.infra.hint.HintValueContext;
 import 
org.apache.shardingsphere.readwritesplitting.route.qualified.QualifiedReadwriteSplittingDataSourceRouter;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import org.apache.shardingsphere.sql.parser.sql.common.statement.SQLStatement;
 import 
org.apache.shardingsphere.sql.parser.sql.common.statement.dml.SelectStatement;
 import 
org.apache.shardingsphere.sql.parser.sql.dialect.handler.dml.SelectStatementHandler;
@@ -33,7 +33,7 @@ import 
org.apache.shardingsphere.sql.parser.sql.dialect.handler.dml.SelectStatem
 public final class QualifiedReadwriteSplittingPrimaryDataSourceRouter 
implements QualifiedReadwriteSplittingDataSourceRouter {
     
     @Override
-    public boolean isQualified(final SQLStatementContext sqlStatementContext, 
final ReadwriteSplittingDataSourceRule rule, final HintValueContext 
hintValueContext) {
+    public boolean isQualified(final SQLStatementContext sqlStatementContext, 
final ReadwriteSplittingDataSourceGroupRule rule, final HintValueContext 
hintValueContext) {
         return isPrimaryRoute(sqlStatementContext, hintValueContext);
     }
     
@@ -59,7 +59,7 @@ public final class 
QualifiedReadwriteSplittingPrimaryDataSourceRouter implements
     }
     
     @Override
-    public String route(final ReadwriteSplittingDataSourceRule rule) {
+    public String route(final ReadwriteSplittingDataSourceGroupRule rule) {
         return rule.getWriteDataSource();
     }
 }
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouter.java
index c731f8d280f..6f6e820242d 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouter.java
@@ -23,7 +23,7 @@ import org.apache.shardingsphere.infra.hint.HintValueContext;
 import org.apache.shardingsphere.infra.session.connection.ConnectionContext;
 import 
org.apache.shardingsphere.readwritesplitting.route.qualified.QualifiedReadwriteSplittingDataSourceRouter;
 import 
org.apache.shardingsphere.readwritesplitting.route.standard.StandardReadwriteSplittingDataSourceRouter;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 /**
  * Qualified data source transactional router for readwrite-splitting.
@@ -36,12 +36,12 @@ public final class 
QualifiedReadwriteSplittingTransactionalDataSourceRouter impl
     private final StandardReadwriteSplittingDataSourceRouter standardRouter = 
new StandardReadwriteSplittingDataSourceRouter();
     
     @Override
-    public boolean isQualified(final SQLStatementContext sqlStatementContext, 
final ReadwriteSplittingDataSourceRule rule, final HintValueContext 
hintValueContext) {
+    public boolean isQualified(final SQLStatementContext sqlStatementContext, 
final ReadwriteSplittingDataSourceGroupRule rule, final HintValueContext 
hintValueContext) {
         return connectionContext.getTransactionContext().isInTransaction();
     }
     
     @Override
-    public String route(final ReadwriteSplittingDataSourceRule rule) {
+    public String route(final ReadwriteSplittingDataSourceGroupRule rule) {
         switch (rule.getTransactionalReadQueryStrategy()) {
             case FIXED:
                 if (null == 
connectionContext.getTransactionContext().getReadWriteSplitReplicaRoute()) {
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouter.java
index 7f7842742ca..9c4ab1de94e 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouter.java
@@ -19,7 +19,7 @@ package 
org.apache.shardingsphere.readwritesplitting.route.standard;
 
 import org.apache.shardingsphere.infra.spi.ShardingSphereServiceLoader;
 import 
org.apache.shardingsphere.readwritesplitting.route.standard.filter.ReadDataSourcesFilter;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.List;
 
@@ -34,11 +34,11 @@ public final class 
StandardReadwriteSplittingDataSourceRouter {
      * @param rule Readwrite-splitting data source rule
      * @return routed data source name
      */
-    public String route(final ReadwriteSplittingDataSourceRule rule) {
+    public String route(final ReadwriteSplittingDataSourceGroupRule rule) {
         return rule.getLoadBalancer().getTargetName(rule.getName(), 
getFilteredReadDataSources(rule));
     }
     
-    private List<String> getFilteredReadDataSources(final 
ReadwriteSplittingDataSourceRule rule) {
+    private List<String> getFilteredReadDataSources(final 
ReadwriteSplittingDataSourceGroupRule rule) {
         List<String> result = 
rule.getReadwriteSplittingGroup().getReadDataSources();
         for (ReadDataSourcesFilter each : 
ShardingSphereServiceLoader.getServiceInstances(ReadDataSourcesFilter.class)) {
             result = each.filter(rule, result);
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilter.java
index 31f552952fa..7467b9f4404 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilter.java
@@ -17,7 +17,7 @@
 
 package org.apache.shardingsphere.readwritesplitting.route.standard.filter;
 
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.LinkedList;
 import java.util.List;
@@ -28,7 +28,7 @@ import java.util.List;
 public final class DisabledReadDataSourcesFilter implements 
ReadDataSourcesFilter {
     
     @Override
-    public List<String> filter(final ReadwriteSplittingDataSourceRule rule, 
final List<String> toBeFilteredReadDataSources) {
+    public List<String> filter(final ReadwriteSplittingDataSourceGroupRule 
rule, final List<String> toBeFilteredReadDataSources) {
         List<String> result = new LinkedList<>(toBeFilteredReadDataSources);
         result.removeIf(rule.getDisabledDataSourceNames()::contains);
         return result;
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/ReadDataSourcesFilter.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/ReadDataSourcesFilter.java
index 1ecfc2b1826..7ecbadf8bb4 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/ReadDataSourcesFilter.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/ReadDataSourcesFilter.java
@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.readwritesplitting.route.standard.filter;
 
 import org.apache.shardingsphere.infra.spi.annotation.SingletonSPI;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.List;
 
@@ -35,5 +35,5 @@ public interface ReadDataSourcesFilter {
      * @param toBeFilteredReadDataSources to be filtered read data sources
      * @return filtered read data sources
      */
-    List<String> filter(ReadwriteSplittingDataSourceRule rule, List<String> 
toBeFilteredReadDataSources);
+    List<String> filter(ReadwriteSplittingDataSourceGroupRule rule, 
List<String> toBeFilteredReadDataSources);
 }
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
similarity index 88%
rename from 
features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
rename to 
features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
index 77af7abe26d..74b8c050eef 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
@@ -28,10 +28,10 @@ import java.util.Collection;
 import java.util.HashSet;
 
 /**
- * Readwrite-splitting data source rule.
+ * Readwrite-splitting data source group rule.
  */
 @Getter
-public final class ReadwriteSplittingDataSourceRule {
+public final class ReadwriteSplittingDataSourceGroupRule {
     
     private final String name;
     
@@ -43,8 +43,8 @@ public final class ReadwriteSplittingDataSourceRule {
     
     private final Collection<String> disabledDataSourceNames = new HashSet<>();
     
-    public ReadwriteSplittingDataSourceRule(final 
ReadwriteSplittingDataSourceRuleConfiguration config,
-                                            final 
TransactionalReadQueryStrategy transactionalReadQueryStrategy, final 
LoadBalanceAlgorithm loadBalancer) {
+    public ReadwriteSplittingDataSourceGroupRule(final 
ReadwriteSplittingDataSourceRuleConfiguration config,
+                                                 final 
TransactionalReadQueryStrategy transactionalReadQueryStrategy, final 
LoadBalanceAlgorithm loadBalancer) {
         name = config.getName();
         this.transactionalReadQueryStrategy = transactionalReadQueryStrategy;
         this.loadBalancer = loadBalancer;
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
index e77dbc79115..4b8c4bdb86e 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
@@ -53,7 +53,7 @@ public final class ReadwriteSplittingRule implements 
DatabaseRule {
     private final Map<String, LoadBalanceAlgorithm> loadBalancers;
     
     @Getter
-    private final Map<String, ReadwriteSplittingDataSourceRule> 
dataSourceRules;
+    private final Map<String, ReadwriteSplittingDataSourceGroupRule> 
dataSourceRuleGroups;
     
     @Getter
     private final RuleAttributes attributes;
@@ -61,10 +61,12 @@ public final class ReadwriteSplittingRule implements 
DatabaseRule {
     public ReadwriteSplittingRule(final String databaseName, final 
ReadwriteSplittingRuleConfiguration ruleConfig, final InstanceContext 
instanceContext) {
         configuration = ruleConfig;
         loadBalancers = createLoadBalancers(ruleConfig);
-        dataSourceRules = createDataSourceRules(databaseName, ruleConfig);
+        dataSourceRuleGroups = createDataSourceGroupRules(databaseName, 
ruleConfig);
         attributes = new RuleAttributes(
-                new 
ReadwriteSplittingDataSourceMapperRuleAttribute(dataSourceRules.values()), new 
ReadwriteSplittingStaticDataSourceRuleAttribute(databaseName, dataSourceRules, 
instanceContext),
-                new 
ReadwriteSplittingExportableRuleAttribute(dataSourceRules), new 
ReadwriteSplittingStorageConnectorReusableRuleAttribute());
+                new 
ReadwriteSplittingDataSourceMapperRuleAttribute(dataSourceRuleGroups.values()),
+                new 
ReadwriteSplittingStaticDataSourceRuleAttribute(databaseName, 
dataSourceRuleGroups, instanceContext),
+                new 
ReadwriteSplittingExportableRuleAttribute(dataSourceRuleGroups),
+                new ReadwriteSplittingStorageConnectorReusableRuleAttribute());
     }
     
     private Map<String, LoadBalanceAlgorithm> createLoadBalancers(final 
ReadwriteSplittingRuleConfiguration ruleConfig) {
@@ -78,21 +80,21 @@ public final class ReadwriteSplittingRule implements 
DatabaseRule {
         return result;
     }
     
-    private Map<String, ReadwriteSplittingDataSourceRule> 
createDataSourceRules(final String databaseName, final 
ReadwriteSplittingRuleConfiguration ruleConfig) {
-        Map<String, ReadwriteSplittingDataSourceRule> result = new 
HashMap<>(ruleConfig.getDataSources().size(), 1F);
+    private Map<String, ReadwriteSplittingDataSourceGroupRule> 
createDataSourceGroupRules(final String databaseName, final 
ReadwriteSplittingRuleConfiguration ruleConfig) {
+        Map<String, ReadwriteSplittingDataSourceGroupRule> result = new 
HashMap<>(ruleConfig.getDataSources().size(), 1F);
         for (ReadwriteSplittingDataSourceRuleConfiguration each : 
ruleConfig.getDataSources()) {
-            result.putAll(createDataSourceRules(databaseName, each));
+            result.putAll(createDataSourceGroupRules(databaseName, each));
         }
         return result;
     }
     
-    private Map<String, ReadwriteSplittingDataSourceRule> 
createDataSourceRules(final String databaseName, final 
ReadwriteSplittingDataSourceRuleConfiguration config) {
+    private Map<String, ReadwriteSplittingDataSourceGroupRule> 
createDataSourceGroupRules(final String databaseName, final 
ReadwriteSplittingDataSourceRuleConfiguration config) {
         LoadBalanceAlgorithm loadBalanceAlgorithm = 
loadBalancers.getOrDefault(config.getName() + "." + 
config.getLoadBalancerName(), 
TypedSPILoader.getService(LoadBalanceAlgorithm.class, null));
-        return createStaticDataSourceRules(databaseName, config, 
loadBalanceAlgorithm);
+        return createStaticDataSourceGroupRules(databaseName, config, 
loadBalanceAlgorithm);
     }
     
-    private Map<String, ReadwriteSplittingDataSourceRule> 
createStaticDataSourceRules(final String databaseName, final 
ReadwriteSplittingDataSourceRuleConfiguration config,
-                                                                               
       final LoadBalanceAlgorithm loadBalanceAlgorithm) {
+    private Map<String, ReadwriteSplittingDataSourceGroupRule> 
createStaticDataSourceGroupRules(final String databaseName, final 
ReadwriteSplittingDataSourceRuleConfiguration config,
+                                                                               
                 final LoadBalanceAlgorithm loadBalanceAlgorithm) {
         List<String> inlineLogicDataSourceNames = 
InlineExpressionParserFactory.newInstance(config.getName()).splitAndEvaluate();
         List<String> inlineWriteDataSourceNames = 
InlineExpressionParserFactory.newInstance(config.getWriteDataSourceName()).splitAndEvaluate();
         List<List<String>> inlineReadDataSourceNames = 
config.getReadDataSourceNames().stream()
@@ -103,11 +105,11 @@ public final class ReadwriteSplittingRule implements 
DatabaseRule {
         inlineReadDataSourceNames.forEach(each -> 
ShardingSpherePreconditions.checkState(each.size() == 
inlineLogicDataSourceNames.size(),
                 () -> new 
InvalidReadwriteSplittingActualDataSourceInlineExpressionException(
                         ReadwriteSplittingDataSourceType.READ, new 
ReadwriteSplittingRuleExceptionIdentifier(databaseName, config.getName()))));
-        Map<String, ReadwriteSplittingDataSourceRule> result = new 
HashMap<>(inlineLogicDataSourceNames.size(), 1F);
+        Map<String, ReadwriteSplittingDataSourceGroupRule> result = new 
HashMap<>(inlineLogicDataSourceNames.size(), 1F);
         for (int i = 0; i < inlineLogicDataSourceNames.size(); i++) {
             ReadwriteSplittingDataSourceRuleConfiguration staticConfig = 
createStaticDataSourceRuleConfiguration(
                     config, i, inlineLogicDataSourceNames, 
inlineWriteDataSourceNames, inlineReadDataSourceNames);
-            result.put(inlineLogicDataSourceNames.get(i), new 
ReadwriteSplittingDataSourceRule(staticConfig, 
config.getTransactionalReadQueryStrategy(), loadBalanceAlgorithm));
+            result.put(inlineLogicDataSourceNames.get(i), new 
ReadwriteSplittingDataSourceGroupRule(staticConfig, 
config.getTransactionalReadQueryStrategy(), loadBalanceAlgorithm));
         }
         return result;
     }
@@ -120,21 +122,21 @@ public final class ReadwriteSplittingRule implements 
DatabaseRule {
     }
     
     /**
-     * Get single data source rule.
+     * Get single data source group rule.
      *
-     * @return readwrite-splitting data source rule
+     * @return readwrite-splitting data source group rule
      */
-    public ReadwriteSplittingDataSourceRule getSingleDataSourceRule() {
-        return dataSourceRules.values().iterator().next();
+    public ReadwriteSplittingDataSourceGroupRule 
getSingleDataSourceGroupRule() {
+        return dataSourceRuleGroups.values().iterator().next();
     }
     
     /**
-     * Find data source rule.
+     * Find data source group rule.
      *
      * @param dataSourceName data source name
-     * @return readwrite-splitting data source rule
+     * @return readwrite-splitting data source group rule
      */
-    public Optional<ReadwriteSplittingDataSourceRule> findDataSourceRule(final 
String dataSourceName) {
-        return Optional.ofNullable(dataSourceRules.get(dataSourceName));
+    public Optional<ReadwriteSplittingDataSourceGroupRule> 
findDataSourceGroupRule(final String dataSourceName) {
+        return Optional.ofNullable(dataSourceRuleGroups.get(dataSourceName));
     }
 }
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttribute.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttribute.java
index a949b6800a3..48024f218b0 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttribute.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttribute.java
@@ -19,7 +19,7 @@ package 
org.apache.shardingsphere.readwritesplitting.rule.attribute;
 
 import lombok.RequiredArgsConstructor;
 import 
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -31,12 +31,12 @@ import java.util.Map;
 @RequiredArgsConstructor
 public final class ReadwriteSplittingDataSourceMapperRuleAttribute implements 
DataSourceMapperRuleAttribute {
     
-    private final Collection<ReadwriteSplittingDataSourceRule> dataSourceRules;
+    private final Collection<ReadwriteSplittingDataSourceGroupRule> 
dataSourceGroupRules;
     
     @Override
     public Map<String, Collection<String>> getDataSourceMapper() {
         Map<String, Collection<String>> result = new HashMap<>();
-        for (ReadwriteSplittingDataSourceRule each : dataSourceRules) {
+        for (ReadwriteSplittingDataSourceGroupRule each : 
dataSourceGroupRules) {
             result.put(each.getName(), 
each.getReadwriteSplittingGroup().getAllDataSources());
         }
         return result;
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingExportableRuleAttribute.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingExportableRuleAttribute.java
index be83a3e9754..a3803eda18a 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingExportableRuleAttribute.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingExportableRuleAttribute.java
@@ -22,7 +22,7 @@ import 
org.apache.shardingsphere.infra.rule.attribute.exportable.ExportableRuleA
 import 
org.apache.shardingsphere.infra.rule.attribute.exportable.constant.ExportableConstants;
 import 
org.apache.shardingsphere.infra.rule.attribute.exportable.constant.ExportableItemConstants;
 import 
org.apache.shardingsphere.readwritesplitting.group.type.StaticReadwriteSplittingGroup;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -34,7 +34,7 @@ import java.util.Map;
 @RequiredArgsConstructor
 public final class ReadwriteSplittingExportableRuleAttribute implements 
ExportableRuleAttribute {
     
-    private final Map<String, ReadwriteSplittingDataSourceRule> 
dataSourceRules;
+    private final Map<String, ReadwriteSplittingDataSourceGroupRule> 
dataSourceGroupRules;
     
     @Override
     public Map<String, Object> getExportData() {
@@ -44,8 +44,8 @@ public final class ReadwriteSplittingExportableRuleAttribute 
implements Exportab
     }
     
     private Map<String, Map<String, String>> exportStaticDataSources() {
-        Map<String, Map<String, String>> result = new 
LinkedHashMap<>(dataSourceRules.size(), 1F);
-        for (ReadwriteSplittingDataSourceRule each : dataSourceRules.values()) 
{
+        Map<String, Map<String, String>> result = new 
LinkedHashMap<>(dataSourceGroupRules.size(), 1F);
+        for (ReadwriteSplittingDataSourceGroupRule each : 
dataSourceGroupRules.values()) {
             if (each.getReadwriteSplittingGroup() instanceof 
StaticReadwriteSplittingGroup) {
                 Map<String, String> exportedDataSources = new 
LinkedHashMap<>(2, 1F);
                 
exportedDataSources.put(ExportableItemConstants.PRIMARY_DATA_SOURCE_NAME, 
each.getWriteDataSource());
diff --git 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingStaticDataSourceRuleAttribute.java
 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingStaticDataSourceRuleAttribute.java
index 180b146b6d0..0713326e8a5 100644
--- 
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingStaticDataSourceRuleAttribute.java
+++ 
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingStaticDataSourceRuleAttribute.java
@@ -25,7 +25,7 @@ import 
org.apache.shardingsphere.infra.rule.attribute.datasource.StaticDataSourc
 import org.apache.shardingsphere.infra.state.datasource.DataSourceState;
 import 
org.apache.shardingsphere.mode.event.storage.StorageNodeDataSourceDeletedEvent;
 import 
org.apache.shardingsphere.readwritesplitting.exception.logic.ReadwriteSplittingDataSourceRuleNotFoundException;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -40,14 +40,14 @@ public final class 
ReadwriteSplittingStaticDataSourceRuleAttribute implements St
     
     private final String databaseName;
     
-    private final Map<String, ReadwriteSplittingDataSourceRule> 
dataSourceRules;
+    private final Map<String, ReadwriteSplittingDataSourceGroupRule> 
dataSourceGroupRules;
     
     private final InstanceContext instanceContext;
     
     @Override
     public Map<String, Collection<String>> getDataSourceMapper() {
         Map<String, Collection<String>> result = new HashMap<>();
-        for (Entry<String, ReadwriteSplittingDataSourceRule> entry : 
dataSourceRules.entrySet()) {
+        for (Entry<String, ReadwriteSplittingDataSourceGroupRule> entry : 
dataSourceGroupRules.entrySet()) {
             result.put(entry.getValue().getName(), 
entry.getValue().getReadwriteSplittingGroup().getAllDataSources());
         }
         return result;
@@ -55,30 +55,30 @@ public final class 
ReadwriteSplittingStaticDataSourceRuleAttribute implements St
     
     @Override
     public void updateStatus(final QualifiedDataSource qualifiedDataSource, 
final DataSourceState status) {
-        ReadwriteSplittingDataSourceRule dataSourceRule = 
dataSourceRules.get(qualifiedDataSource.getGroupName());
-        ShardingSpherePreconditions.checkNotNull(dataSourceRule,
+        ReadwriteSplittingDataSourceGroupRule dataSourceGroupRule = 
dataSourceGroupRules.get(qualifiedDataSource.getGroupName());
+        ShardingSpherePreconditions.checkNotNull(dataSourceGroupRule,
                 () -> new 
ReadwriteSplittingDataSourceRuleNotFoundException(qualifiedDataSource.getGroupName(),
 qualifiedDataSource.getDatabaseName()));
         if (DataSourceState.DISABLED == status) {
-            
dataSourceRule.disableDataSource(qualifiedDataSource.getDataSourceName());
+            
dataSourceGroupRule.disableDataSource(qualifiedDataSource.getDataSourceName());
         } else {
-            
dataSourceRule.enableDataSource(qualifiedDataSource.getDataSourceName());
+            
dataSourceGroupRule.enableDataSource(qualifiedDataSource.getDataSourceName());
         }
     }
     
     @Override
     public void cleanStorageNodeDataSource(final String groupName) {
-        ShardingSpherePreconditions.checkContainsKey(dataSourceRules, 
groupName, () -> new 
ReadwriteSplittingDataSourceRuleNotFoundException(groupName, databaseName));
-        deleteStorageNodeDataSources(dataSourceRules.get(groupName));
+        ShardingSpherePreconditions.checkContainsKey(dataSourceGroupRules, 
groupName, () -> new 
ReadwriteSplittingDataSourceRuleNotFoundException(groupName, databaseName));
+        deleteStorageNodeDataSources(dataSourceGroupRules.get(groupName));
     }
     
-    private void deleteStorageNodeDataSources(final 
ReadwriteSplittingDataSourceRule rule) {
+    private void deleteStorageNodeDataSources(final 
ReadwriteSplittingDataSourceGroupRule rule) {
         rule.getReadwriteSplittingGroup().getReadDataSources()
                 .forEach(each -> instanceContext.getEventBusContext().post(new 
StorageNodeDataSourceDeletedEvent(new QualifiedDataSource(databaseName, 
rule.getName(), each))));
     }
     
     @Override
     public void cleanStorageNodeDataSources() {
-        for (Entry<String, ReadwriteSplittingDataSourceRule> entry : 
dataSourceRules.entrySet()) {
+        for (Entry<String, ReadwriteSplittingDataSourceGroupRule> entry : 
dataSourceGroupRules.entrySet()) {
             deleteStorageNodeDataSources(entry.getValue());
         }
     }
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
index 4e7fdf12708..7f7209d399e 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
@@ -23,7 +23,7 @@ import 
org.apache.shardingsphere.infra.session.connection.ConnectionContext;
 import 
org.apache.shardingsphere.infra.session.connection.transaction.TransactionConnectionContext;
 import 
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
 import 
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
@@ -59,12 +59,12 @@ class 
QualifiedReadwriteSplittingTransactionalDataSourceRouterTest {
     void assertRoute() {
         ReadwriteSplittingDataSourceRuleConfiguration 
readwriteSplittingDataSourceRuleConfig =
                 new 
ReadwriteSplittingDataSourceRuleConfiguration("test_config", "write_ds", 
Arrays.asList("read_ds_0", "read_ds_1"), null);
-        ReadwriteSplittingDataSourceRule rule;
-        rule = new 
ReadwriteSplittingDataSourceRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.PRIMARY, null);
+        ReadwriteSplittingDataSourceGroupRule rule;
+        rule = new 
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.PRIMARY, null);
         assertThat(new 
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new 
ConnectionContext()).route(rule), is("write_ds"));
-        rule = new 
ReadwriteSplittingDataSourceRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.FIXED, new RoundRobinLoadBalanceAlgorithm());
+        rule = new 
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.FIXED, new RoundRobinLoadBalanceAlgorithm());
         assertThat(new 
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new 
ConnectionContext()).route(rule), is("read_ds_0"));
-        rule = new 
ReadwriteSplittingDataSourceRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.DYNAMIC, new RoundRobinLoadBalanceAlgorithm());
+        rule = new 
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig, 
TransactionalReadQueryStrategy.DYNAMIC, new RoundRobinLoadBalanceAlgorithm());
         assertThat(new 
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new 
ConnectionContext()).route(rule), is("read_ds_0"));
     }
 }
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
index b1b5f431774..9e6f1165c84 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
@@ -20,7 +20,7 @@ package 
org.apache.shardingsphere.readwritesplitting.route.standard;
 import 
org.apache.shardingsphere.infra.algorithm.loadbalancer.round.robin.RoundRobinLoadBalanceAlgorithm;
 import 
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
 import 
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -31,11 +31,11 @@ import static org.hamcrest.MatcherAssert.assertThat;
 
 class StandardReadwriteSplittingDataSourceRouterTest {
     
-    private ReadwriteSplittingDataSourceRule rule;
+    private ReadwriteSplittingDataSourceGroupRule rule;
     
     @BeforeEach
     void setUp() {
-        rule = new ReadwriteSplittingDataSourceRule(
+        rule = new ReadwriteSplittingDataSourceGroupRule(
                 new 
ReadwriteSplittingDataSourceRuleConfiguration("test_config", "write_ds", 
Arrays.asList("read_ds_0", "read_ds_1"), null),
                 TransactionalReadQueryStrategy.DYNAMIC, new 
RoundRobinLoadBalanceAlgorithm());
     }
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
index a3878857b3d..48f98185fe6 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
@@ -20,7 +20,7 @@ package 
org.apache.shardingsphere.readwritesplitting.route.standard.filter;
 import 
org.apache.shardingsphere.infra.algorithm.loadbalancer.random.RandomLoadBalanceAlgorithm;
 import 
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
 import 
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -32,11 +32,11 @@ import static org.hamcrest.MatcherAssert.assertThat;
 
 class DisabledReadDataSourcesFilterTest {
     
-    private ReadwriteSplittingDataSourceRule rule;
+    private ReadwriteSplittingDataSourceGroupRule rule;
     
     @BeforeEach
     void setUp() {
-        rule = new ReadwriteSplittingDataSourceRule(
+        rule = new ReadwriteSplittingDataSourceGroupRule(
                 new ReadwriteSplittingDataSourceRuleConfiguration("test_pr", 
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), null),
                 TransactionalReadQueryStrategy.DYNAMIC, new 
RandomLoadBalanceAlgorithm());
     }
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRuleTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
similarity index 83%
rename from 
features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRuleTest.java
rename to 
features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
index 663a66a9698..0c9435323b7 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRuleTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
@@ -27,15 +27,14 @@ import java.util.Arrays;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-class ReadwriteSplittingDataSourceRuleTest {
+class ReadwriteSplittingDataSourceGroupRuleTest {
     
     @Test
     void assertGetWriteDataSource() {
-        ReadwriteSplittingDataSourceRule readwriteSplittingDataSourceRule = 
new ReadwriteSplittingDataSourceRule(
-                new ReadwriteSplittingDataSourceRuleConfiguration("test_pr", 
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"),
-                        TransactionalReadQueryStrategy.DYNAMIC, null),
+        ReadwriteSplittingDataSourceGroupRule dataSourceGroupRule = new 
ReadwriteSplittingDataSourceGroupRule(
+                new ReadwriteSplittingDataSourceRuleConfiguration("test_pr", 
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), 
TransactionalReadQueryStrategy.DYNAMIC, null),
                 TransactionalReadQueryStrategy.DYNAMIC, new 
RandomLoadBalanceAlgorithm());
-        String writeDataSourceName = 
readwriteSplittingDataSourceRule.getWriteDataSource();
+        String writeDataSourceName = dataSourceGroupRule.getWriteDataSource();
         assertThat(writeDataSourceName, is("write_ds"));
     }
 }
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
index eab76eb6afc..1dceb8be9a0 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
@@ -39,15 +39,15 @@ import static org.mockito.Mockito.mock;
 class ReadwriteSplittingRuleTest {
     
     @Test
-    void assertFindDataSourceRule() {
-        Optional<ReadwriteSplittingDataSourceRule> actual = 
createReadwriteSplittingRule().findDataSourceRule("readwrite");
+    void assertFindDataSourceGroupRule() {
+        Optional<ReadwriteSplittingDataSourceGroupRule> actual = 
createReadwriteSplittingRule().findDataSourceGroupRule("readwrite");
         assertTrue(actual.isPresent());
-        assertDataSourceRule(actual.get());
+        assertDataSourceGroupRule(actual.get());
     }
     
     @Test
-    void assertGetSingleDataSourceRule() {
-        
assertDataSourceRule(createReadwriteSplittingRule().getSingleDataSourceRule());
+    void assertGetSingleDataSourceGroupRule() {
+        
assertDataSourceGroupRule(createReadwriteSplittingRule().getSingleDataSourceGroupRule());
     }
     
     private ReadwriteSplittingRule createReadwriteSplittingRule() {
@@ -57,7 +57,7 @@ class ReadwriteSplittingRuleTest {
                 Collections.singleton(config), 
Collections.singletonMap("random", new AlgorithmConfiguration("RANDOM", new 
Properties()))), mock(InstanceContext.class));
     }
     
-    private void assertDataSourceRule(final ReadwriteSplittingDataSourceRule 
actual) {
+    private void assertDataSourceGroupRule(final 
ReadwriteSplittingDataSourceGroupRule actual) {
         assertThat(actual.getName(), is("readwrite"));
         assertThat(actual.getReadwriteSplittingGroup().getWriteDataSource(), 
is("write_ds"));
         assertThat(actual.getReadwriteSplittingGroup().getReadDataSources(), 
is(Arrays.asList("read_ds_0", "read_ds_1")));
@@ -69,7 +69,7 @@ class ReadwriteSplittingRuleTest {
         ReadwriteSplittingRule readwriteSplittingRule = 
createReadwriteSplittingRule();
         
readwriteSplittingRule.getAttributes().getAttribute(StaticDataSourceRuleAttribute.class).updateStatus(
                 new 
QualifiedDataSource("readwrite_splitting_db.readwrite.read_ds"), 
DataSourceState.DISABLED);
-        
assertThat(readwriteSplittingRule.getSingleDataSourceRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds")));
+        
assertThat(readwriteSplittingRule.getSingleDataSourceGroupRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds")));
     }
     
     @Test
@@ -77,7 +77,7 @@ class ReadwriteSplittingRuleTest {
         ReadwriteSplittingRule readwriteSplittingRule = 
createReadwriteSplittingRule();
         
readwriteSplittingRule.getAttributes().getAttribute(StaticDataSourceRuleAttribute.class).updateStatus(
                 new 
QualifiedDataSource("readwrite_splitting_db.readwrite.read_ds_0"), 
DataSourceState.DISABLED);
-        
assertThat(readwriteSplittingRule.getSingleDataSourceRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds_0")));
+        
assertThat(readwriteSplittingRule.getSingleDataSourceGroupRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds_0")));
     }
     
     @Test
@@ -85,10 +85,10 @@ class ReadwriteSplittingRuleTest {
         ReadwriteSplittingRule readwriteSplittingRule = 
createReadwriteSplittingRule();
         
readwriteSplittingRule.getAttributes().getAttribute(StaticDataSourceRuleAttribute.class).updateStatus(
                 new 
QualifiedDataSource("readwrite_splitting_db.readwrite.read_ds_0"), 
DataSourceState.DISABLED);
-        
assertThat(readwriteSplittingRule.getSingleDataSourceRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds_0")));
+        
assertThat(readwriteSplittingRule.getSingleDataSourceGroupRule().getDisabledDataSourceNames(),
 is(Collections.singleton("read_ds_0")));
         
readwriteSplittingRule.getAttributes().getAttribute(StaticDataSourceRuleAttribute.class).updateStatus(
                 new 
QualifiedDataSource("readwrite_splitting_db.readwrite.read_ds_0"), 
DataSourceState.ENABLED);
-        
assertThat(readwriteSplittingRule.getSingleDataSourceRule().getDisabledDataSourceNames(),
 is(Collections.emptySet()));
+        
assertThat(readwriteSplittingRule.getSingleDataSourceGroupRule().getDisabledDataSourceNames(),
 is(Collections.emptySet()));
     }
     
     @Test
@@ -100,7 +100,7 @@ class ReadwriteSplittingRuleTest {
                 "random");
         ReadwriteSplittingRule readwriteSplittingRule = new 
ReadwriteSplittingRule("logic_db", new ReadwriteSplittingRuleConfiguration(
                 Collections.singleton(config), 
Collections.singletonMap("random", new AlgorithmConfiguration("RANDOM", new 
Properties()))), mock(InstanceContext.class));
-        Optional<ReadwriteSplittingDataSourceRule> actual = 
readwriteSplittingRule.findDataSourceRule("readwrite_ds");
+        Optional<ReadwriteSplittingDataSourceGroupRule> actual = 
readwriteSplittingRule.findDataSourceGroupRule("readwrite_ds");
         assertTrue(actual.isPresent());
         assertThat(actual.get().getName(), is("readwrite_ds"));
         
assertThat(actual.get().getReadwriteSplittingGroup().getWriteDataSource(), 
is("write_ds"));
diff --git 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
index 308ea1ee93c..d2ad201b258 100644
--- 
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
+++ 
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
@@ -18,7 +18,7 @@
 package org.apache.shardingsphere.readwritesplitting.rule.attribute;
 
 import 
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
@@ -33,13 +33,13 @@ class ReadwriteSplittingDataSourceMapperRuleAttributeTest {
     
     @Test
     void assertGetDataSourceMapper() {
-        Map<String, Collection<String>> actual = new 
ReadwriteSplittingDataSourceMapperRuleAttribute(Collections.singleton(createReadwriteSplittingDataSourceRule())).getDataSourceMapper();
+        Map<String, Collection<String>> actual = new 
ReadwriteSplittingDataSourceMapperRuleAttribute(Collections.singleton(createDataSourceGroupRule())).getDataSourceMapper();
         Map<String, Collection<String>> expected = 
Collections.singletonMap("readwrite", Arrays.asList("write_ds", "read_ds_0", 
"read_ds_1"));
         assertThat(actual, is(expected));
     }
     
-    private ReadwriteSplittingDataSourceRule 
createReadwriteSplittingDataSourceRule() {
-        return new ReadwriteSplittingDataSourceRule(
+    private ReadwriteSplittingDataSourceGroupRule createDataSourceGroupRule() {
+        return new ReadwriteSplittingDataSourceGroupRule(
                 new ReadwriteSplittingDataSourceRuleConfiguration("readwrite", 
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), "random"), null, null);
     }
 }
diff --git 
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutor.java
 
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutor.java
index fe691c70018..31318252483 100644
--- 
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutor.java
+++ 
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutor.java
@@ -24,7 +24,7 @@ import 
org.apache.shardingsphere.infra.merge.result.impl.local.LocalDataQueryRes
 import org.apache.shardingsphere.infra.state.datasource.DataSourceState;
 import org.apache.shardingsphere.mode.manager.ContextManager;
 import 
org.apache.shardingsphere.readwritesplitting.distsql.statement.ShowStatusFromReadwriteSplittingRulesStatement;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
 
 import java.util.Arrays;
@@ -47,22 +47,22 @@ public final class 
ShowStatusFromReadwriteSplittingRulesExecutor implements Dist
     
     @Override
     public Collection<LocalDataQueryResultRow> getRows(final 
ShowStatusFromReadwriteSplittingRulesStatement sqlStatement, final 
ContextManager contextManager) {
-        Collection<ReadwriteSplittingDataSourceRule> dataSourceRules = 
getDataSourceRules(sqlStatement);
+        Collection<ReadwriteSplittingDataSourceGroupRule> dataSourceGroupRules 
= getDataSourceGroupRules(sqlStatement);
         Collection<LocalDataQueryResultRow> result = new LinkedList<>();
-        dataSourceRules.forEach(each -> result.addAll(buildRows(each)));
+        dataSourceGroupRules.forEach(each -> result.addAll(buildRows(each)));
         return result;
     }
     
-    private Collection<ReadwriteSplittingDataSourceRule> 
getDataSourceRules(final ShowStatusFromReadwriteSplittingRulesStatement 
sqlStatement) {
+    private Collection<ReadwriteSplittingDataSourceGroupRule> 
getDataSourceGroupRules(final ShowStatusFromReadwriteSplittingRulesStatement 
sqlStatement) {
         if (sqlStatement.getRuleName().isPresent()) {
-            return rule.getDataSourceRules().values().stream().filter(each -> 
each.getName().equalsIgnoreCase(sqlStatement.getRuleName().get())).collect(Collectors.toList());
+            return 
rule.getDataSourceRuleGroups().values().stream().filter(each -> 
each.getName().equalsIgnoreCase(sqlStatement.getRuleName().get())).collect(Collectors.toList());
         }
-        return rule.getDataSourceRules().values();
+        return rule.getDataSourceRuleGroups().values();
     }
     
-    private Collection<LocalDataQueryResultRow> buildRows(final 
ReadwriteSplittingDataSourceRule dataSourceRule) {
-        return 
dataSourceRule.getReadwriteSplittingGroup().getReadDataSources().stream()
-                .map(each -> buildRow(each, 
dataSourceRule.getDisabledDataSourceNames().contains(each))).collect(Collectors.toList());
+    private Collection<LocalDataQueryResultRow> buildRows(final 
ReadwriteSplittingDataSourceGroupRule dataSourceGroupRule) {
+        return 
dataSourceGroupRule.getReadwriteSplittingGroup().getReadDataSources().stream()
+                .map(each -> buildRow(each, 
dataSourceGroupRule.getDisabledDataSourceNames().contains(each))).collect(Collectors.toList());
     }
     
     private LocalDataQueryResultRow buildRow(final String dataSourceName, 
final boolean disabled) {
diff --git 
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingStorageUnitStatusExecutor.java
 
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingStorageUnitStatusExecutor.java
index 47a8806e45e..bd6f85ddc22 100644
--- 
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingStorageUnitStatusExecutor.java
+++ 
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingStorageUnitStatusExecutor.java
@@ -33,7 +33,7 @@ import 
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingD
 import 
org.apache.shardingsphere.readwritesplitting.distsql.statement.AlterReadwriteSplittingStorageUnitStatusStatement;
 import 
org.apache.shardingsphere.readwritesplitting.exception.ReadwriteSplittingRuleExceptionIdentifier;
 import 
org.apache.shardingsphere.readwritesplitting.exception.actual.ReadwriteSplittingActualDataSourceNotFoundException;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
 
 import java.util.Optional;
@@ -60,16 +60,17 @@ public final class 
AlterReadwriteSplittingStorageUnitStatusExecutor
     }
     
     private void checkBeforeUpdate(final 
AlterReadwriteSplittingStorageUnitStatusStatement sqlStatement) {
-        Optional<ReadwriteSplittingDataSourceRule> dataSourceRule = 
rule.getDataSourceRules().values().stream().filter(each -> 
each.getName().equalsIgnoreCase(sqlStatement.getRuleName())).findAny();
-        ShardingSpherePreconditions.checkState(dataSourceRule.isPresent(), () 
-> new MissingRequiredRuleException("Readwrite-splitting", database.getName(), 
sqlStatement.getRuleName()));
-        
ShardingSpherePreconditions.checkContains(dataSourceRule.get().getReadwriteSplittingGroup().getReadDataSources(),
 sqlStatement.getStorageUnitName(),
-                () -> new ReadwriteSplittingActualDataSourceNotFoundException(
-                        ReadwriteSplittingDataSourceType.READ, 
sqlStatement.getStorageUnitName(), new 
ReadwriteSplittingRuleExceptionIdentifier(database.getName(), 
dataSourceRule.get().getName())));
+        Optional<ReadwriteSplittingDataSourceGroupRule> dataSourceGroupRule = 
rule.getDataSourceRuleGroups().values().stream()
+                .filter(each -> 
each.getName().equalsIgnoreCase(sqlStatement.getRuleName())).findAny();
+        
ShardingSpherePreconditions.checkState(dataSourceGroupRule.isPresent(), () -> 
new MissingRequiredRuleException("Readwrite-splitting", database.getName(), 
sqlStatement.getRuleName()));
+        
ShardingSpherePreconditions.checkContains(dataSourceGroupRule.get().getReadwriteSplittingGroup().getReadDataSources(),
 sqlStatement.getStorageUnitName(),
+                () -> new 
ReadwriteSplittingActualDataSourceNotFoundException(ReadwriteSplittingDataSourceType.READ,
+                        sqlStatement.getStorageUnitName(), new 
ReadwriteSplittingRuleExceptionIdentifier(database.getName(), 
dataSourceGroupRule.get().getName())));
         if (sqlStatement.isEnable()) {
-            
ShardingSpherePreconditions.checkContains(dataSourceRule.get().getDisabledDataSourceNames(),
 sqlStatement.getStorageUnitName(),
+            
ShardingSpherePreconditions.checkContains(dataSourceGroupRule.get().getDisabledDataSourceNames(),
 sqlStatement.getStorageUnitName(),
                     () -> new InvalidStorageUnitStatusException("storage unit 
is not disabled"));
         } else {
-            
ShardingSpherePreconditions.checkNotContains(dataSourceRule.get().getDisabledDataSourceNames(),
 sqlStatement.getStorageUnitName(),
+            
ShardingSpherePreconditions.checkNotContains(dataSourceGroupRule.get().getDisabledDataSourceNames(),
 sqlStatement.getStorageUnitName(),
                     () -> new InvalidStorageUnitStatusException("storage unit 
is already disabled"));
         }
     }
diff --git 
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutorTest.java
 
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutorTest.java
index 9cca049bcdf..48fdba57a9d 100644
--- 
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutorTest.java
+++ 
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowStatusFromReadwriteSplittingRulesExecutorTest.java
@@ -20,7 +20,7 @@ package 
org.apache.shardingsphere.readwritesplitting.distsql.handler.query;
 import 
org.apache.shardingsphere.infra.merge.result.impl.local.LocalDataQueryResultRow;
 import org.apache.shardingsphere.mode.manager.ContextManager;
 import 
org.apache.shardingsphere.readwritesplitting.distsql.statement.ShowStatusFromReadwriteSplittingRulesStatement;
-import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceRule;
+import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
 import 
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
 import org.junit.jupiter.api.Test;
 
@@ -56,13 +56,13 @@ class ShowStatusFromReadwriteSplittingRulesExecutorTest {
     
     private ReadwriteSplittingRule mockRule() {
         ReadwriteSplittingRule result = mock(ReadwriteSplittingRule.class);
-        Map<String, ReadwriteSplittingDataSourceRule> dataSourceRules = 
Collections.singletonMap("group_0", mockReadwriteSplittingDataSourceRule());
-        when(result.getDataSourceRules()).thenReturn(dataSourceRules);
+        Map<String, ReadwriteSplittingDataSourceGroupRule> 
dataSourceGroupRules = Collections.singletonMap("group_0", 
mockDataSourceGroupRule());
+        
when(result.getDataSourceRuleGroups()).thenReturn(dataSourceGroupRules);
         return result;
     }
     
-    private ReadwriteSplittingDataSourceRule 
mockReadwriteSplittingDataSourceRule() {
-        ReadwriteSplittingDataSourceRule result = 
mock(ReadwriteSplittingDataSourceRule.class, RETURNS_DEEP_STUBS);
+    private ReadwriteSplittingDataSourceGroupRule mockDataSourceGroupRule() {
+        ReadwriteSplittingDataSourceGroupRule result = 
mock(ReadwriteSplittingDataSourceGroupRule.class, RETURNS_DEEP_STUBS);
         
when(result.getReadwriteSplittingGroup().getReadDataSources()).thenReturn(Arrays.asList("read_ds_0",
 "read_ds_1"));
         
when(result.getDisabledDataSourceNames()).thenReturn(Collections.singleton("read_ds_1"));
         return result;

Reply via email to