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 2026/09/19 15:19:15 UTC

(shardingsphere) branch master updated: Refactor rule configuration validation with Bean Validation (#39898)

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

terrymanu 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 3294acd45ed Refactor rule configuration validation with Bean Validation (#39898)
3294acd45ed is described below

commit 3294acd45ed9c24474c479f4ef2b8e66a17ba786
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sat Sep 19 23:19:08 2026 +0800

    Refactor rule configuration validation with Bean Validation (#39898)
    
    * Refactor rule configuration validation with Bean Validation
    
    * Refactor rule configuration validation with Bean Validation
---
 .../user-manual/error-code/sql-error-code.cn.md    |   2 -
 .../user-manual/error-code/sql-error-code.en.md    |   2 -
 .../encrypt/config/EncryptRuleConfiguration.java   |   3 +
 .../EncryptRuleConfigurationValidator.java         |  60 ++++++++++++
 .../validator/ValidEncryptRuleConfiguration.java   |  57 +++++++++++
 .../config/EncryptRuleConfigurationTest.java       |  18 +++-
 .../config/EncryptRuleConfigurationChecker.java    |  34 -------
 .../EncryptRuleConfigurationCheckerTest.java       |  65 +------------
 .../mask/config/MaskRuleConfiguration.java         |   3 +
 .../validator/MaskRuleConfigurationValidator.java  |  49 ++++++++++
 .../validator/ValidMaskRuleConfiguration.java      |  57 +++++++++++
 .../mask/config/MaskRuleConfigurationTest.java     |   3 +-
 .../mask/checker/MaskRuleConfigurationChecker.java |  26 -----
 .../checker/MaskRuleConfigurationCheckerTest.java  |  23 +----
 features/readwrite-splitting/api/pom.xml           |   2 +-
 .../ReadwriteSplittingRuleConfiguration.java       |   5 +
 ...adwriteSplittingRuleConfigurationValidator.java |  47 +++++++++
 .../ValidReadwriteSplittingRuleConfiguration.java  |  57 +++++++++++
 .../ReadwriteSplittingRuleConfigurationTest.java   |  10 +-
 .../fixture/LoadBalanceAlgorithmFixture.java}      |  21 ++--
 ...algorithm.loadbalancer.spi.LoadBalanceAlgorithm |  18 ++++
 ...ReadwriteSplittingRuleConfigurationChecker.java |   4 -
 .../shadow/config/ShadowRuleConfiguration.java     |   3 +
 .../ShadowRuleConfigurationValidator.java          |  85 +++++++++++++++++
 .../validator/ValidShadowRuleConfiguration.java    |  57 +++++++++++
 .../shadow/config/ShadowRuleConfigurationTest.java |  30 +++++-
 .../config/fixture/ShadowAlgorithmFixture.java     |   8 ++
 .../checker/ShadowRuleConfigurationChecker.java    |  33 -------
 .../ShadowRuleConfigurationCheckerTest.java        |  66 -------------
 features/sharding/api/pom.xml                      |   2 +-
 .../api/config/ShardingRuleConfiguration.java      |   4 +
 .../ShardingRuleConfigurationValidator.java        | 106 +++++++++++++++++++++
 .../validator/ValidShardingRuleConfiguration.java  |  57 +++++++++++
 .../api/config/ShardingRuleConfigurationTest.java  |  72 +++++++++++++-
 .../fixture/KeyGenerateAlgorithmFixture.java}      |  18 +++-
 .../fixture/ShardingAuditAlgorithmFixture.java}    |  20 +++-
 ...infra.algorithm.keygen.spi.KeyGenerateAlgorithm |  18 ++++
 ...rdingsphere.sharding.spi.ShardingAuditAlgorithm |  18 ++++
 .../config/ShardingRuleConfigurationChecker.java   |  68 +------------
 .../ShardingRuleConfigurationCheckerTest.java      | 106 +--------------------
 .../checker/DatabaseRuleConfigurationChecker.java  |   3 +-
 .../rule/validator/RuleConfigurationValidator.java |   9 +-
 .../RuleConfigurationTypeValidationGroup.java      |  14 +--
 .../DatabaseRuleConfigurationCheckerTest.java      |  46 +++++++++
 .../validator/RuleConfigurationValidatorTest.java  |  27 ++++++
 .../fixture/ValidRuleConfigurationTypeFixture.java |  70 ++++++++++++++
 .../config/TimestampServiceRuleConfiguration.java  |   2 +
 .../TimestampServiceRuleConfigurationTest.java     |   7 +-
 .../config/fixture/TimestampServiceFixture.java    |  21 ++--
 ...shardingsphere.timeservice.spi.TimestampService |  18 ++++
 .../config/TransactionRuleConfiguration.java       |   3 +-
 .../TransactionProviderTypeValidator.java          |   2 +-
 .../config/TransactionRuleConfigurationTest.java   |   4 +-
 .../validator/MCPLaunchConfigurationValidator.java |   5 +-
 .../UniqueMCPPromptArgumentNamesValidator.java     |   9 +-
 55 files changed, 1092 insertions(+), 485 deletions(-)

diff --git a/docs/document/content/user-manual/error-code/sql-error-code.cn.md b/docs/document/content/user-manual/error-code/sql-error-code.cn.md
index c29ba1350f2..8957f63747b 100644
--- a/docs/document/content/user-manual/error-code/sql-error-code.cn.md
+++ b/docs/document/content/user-manual/error-code/sql-error-code.cn.md
@@ -246,8 +246,6 @@ SQL 错误码以标准的 SQL State,Vendor Code 和详细错误信息提供,
 |-------------|-----------|-------------------------------------------------------------------------|
 | 22000       | 42S02     | Production data source configuration does not exist in database '%s'.   |
 | 22001       | 42S02     | Shadow data source configuration does not exist in database '%s'.       |
-| 22002       | 42S02     | No available shadow data sources mappings in shadow table '%s'.         |
-| 22003       | 44000     | Default shadow algorithm class should be implement HintShadowAlgorithm. |
 | 22010       | HY004     | Shadow column '%s' of table '%s' does not support '%s' type.            |
 | 22020       | 42000     | Insert value of index '%d' can not support for shadow.                  |
 
diff --git a/docs/document/content/user-manual/error-code/sql-error-code.en.md b/docs/document/content/user-manual/error-code/sql-error-code.en.md
index dae92ada4f9..7fbf94c6617 100644
--- a/docs/document/content/user-manual/error-code/sql-error-code.en.md
+++ b/docs/document/content/user-manual/error-code/sql-error-code.en.md
@@ -247,8 +247,6 @@ SQL error codes provide by standard `SQL State`, `Vendor Code` and `Reason`, whi
 |-------------|-----------|-------------------------------------------------------------------------|
 | 22000       | 42S02     | Production data source configuration does not exist in database '%s'.   |
 | 22001       | 42S02     | Shadow data source configuration does not exist in database '%s'.       |
-| 22002       | 42S02     | No available shadow data sources mappings in shadow table '%s'.         |
-| 22003       | 44000     | Default shadow algorithm class should be implement HintShadowAlgorithm. |
 | 22010       | HY004     | Shadow column '%s' of table '%s' does not support '%s' type.            |
 | 22020       | 42000     | Insert value of index '%d' can not support for shadow.                  |
 
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
index 822c008b760..71ad246c497 100644
--- a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
@@ -21,10 +21,12 @@ import com.cedarsoftware.util.CaseInsensitiveSet;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.validator.ValidEncryptRuleConfiguration;
 import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
 import org.apache.shardingsphere.infra.config.rule.function.EnhancedRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
@@ -38,6 +40,7 @@ import java.util.stream.Collectors;
  */
 @RequiredArgsConstructor
 @Getter
+@ValidEncryptRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
 public final class EncryptRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
     
     @NotNull
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java
new file mode 100644
index 00000000000..1f54d6aaa10
--- /dev/null
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java
@@ -0,0 +1,60 @@
+/*
+ * 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.encrypt.config.validator;
+
+import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Encrypt rule configuration validator.
+ */
+public final class EncryptRuleConfigurationValidator implements ConstraintValidator<ValidEncryptRuleConfiguration, EncryptRuleConfiguration> {
+    
+    @Override
+    public boolean isValid(final EncryptRuleConfiguration value, final ConstraintValidatorContext context) {
+        return value.getTables().stream().allMatch(each -> isTableValid(each, value, context));
+    }
+    
+    private boolean isTableValid(final EncryptTableRuleConfiguration tableConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return tableConfig.getColumns().stream().allMatch(each -> isColumnValid(each, ruleConfig, context));
+    }
+    
+    private boolean isColumnValid(final EncryptColumnRuleConfiguration columnConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (!isEncryptorReferenceValid(columnConfig.getCipher(), ruleConfig, context)) {
+            return false;
+        }
+        if (columnConfig.getAssistedQuery().isPresent() && !isEncryptorReferenceValid(columnConfig.getAssistedQuery().get(), ruleConfig, context)) {
+            return false;
+        }
+        return !columnConfig.getLikeQuery().isPresent() || isEncryptorReferenceValid(columnConfig.getLikeQuery().get(), ruleConfig, context);
+    }
+    
+    private boolean isEncryptorReferenceValid(final EncryptColumnItemRuleConfiguration columnItemConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (ruleConfig.getEncryptors().containsKey(columnItemConfig.getEncryptorName())) {
+            return true;
+        }
+        context.disableDefaultConstraintViolation();
+        context.buildConstraintViolationWithTemplate(String.format("references unconfigured encryptor `%s`", columnItemConfig.getEncryptorName())).addPropertyNode("tables").addConstraintViolation();
+        return false;
+    }
+}
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java
new file mode 100644
index 00000000000..aa87f2799ee
--- /dev/null
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * 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.encrypt.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid encrypt rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = EncryptRuleConfigurationValidator.class)
+@Documented
+public @interface ValidEncryptRuleConfiguration {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid references";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java b/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
index ba3746eac68..cb3a7d85378 100644
--- a/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
+++ b/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
@@ -31,6 +31,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Map;
 import java.util.Properties;
 import java.util.stream.Stream;
 
@@ -92,6 +93,10 @@ class EncryptRuleConfigurationTest {
         invalidLikeQueryName.setLikeQuery(new EncryptColumnItemRuleConfiguration("", "foo_encryptor"));
         EncryptColumnRuleConfiguration invalidLikeQueryEncryptor = createValidColumnConfiguration();
         invalidLikeQueryEncryptor.setLikeQuery(new EncryptColumnItemRuleConfiguration("foo_like", ""));
+        EncryptColumnRuleConfiguration missingAssistedQueryEncryptor = createValidColumnConfiguration();
+        missingAssistedQueryEncryptor.setAssistedQuery(new EncryptColumnItemRuleConfiguration("foo_assisted", "bar_encryptor"));
+        EncryptColumnRuleConfiguration missingLikeQueryEncryptor = createValidColumnConfiguration();
+        missingLikeQueryEncryptor.setLikeQuery(new EncryptColumnItemRuleConfiguration("foo_like", "bar_encryptor"));
         AlgorithmConfiguration algorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
         return Stream.of(
                 Arguments.of("Null tables", new EncryptRuleConfiguration(null, Collections.emptyMap())),
@@ -117,7 +122,12 @@ class EncryptRuleConfigurationTest {
                 Arguments.of("Blank assisted query name", createRuleConfiguration(invalidAssistedQueryName)),
                 Arguments.of("Blank assisted query encryptor", createRuleConfiguration(invalidAssistedQueryEncryptor)),
                 Arguments.of("Blank like query name", createRuleConfiguration(invalidLikeQueryName)),
-                Arguments.of("Blank like query encryptor", createRuleConfiguration(invalidLikeQueryEncryptor)));
+                Arguments.of("Blank like query encryptor", createRuleConfiguration(invalidLikeQueryEncryptor)),
+                Arguments.of("Unconfigured cipher encryptor", createRuleConfiguration(createValidColumnConfiguration())),
+                Arguments.of("Unconfigured assisted query encryptor", createRuleConfiguration(missingAssistedQueryEncryptor,
+                        Collections.singletonMap("foo_encryptor", algorithmConfig))),
+                Arguments.of("Unconfigured like query encryptor", createRuleConfiguration(missingLikeQueryEncryptor,
+                        Collections.singletonMap("foo_encryptor", algorithmConfig))));
     }
     
     private static EncryptColumnRuleConfiguration createValidColumnConfiguration() {
@@ -125,7 +135,11 @@ class EncryptRuleConfigurationTest {
     }
     
     private static EncryptRuleConfiguration createRuleConfiguration(final EncryptColumnRuleConfiguration columnConfig) {
+        return createRuleConfiguration(columnConfig, Collections.emptyMap());
+    }
+    
+    private static EncryptRuleConfiguration createRuleConfiguration(final EncryptColumnRuleConfiguration columnConfig, final Map<String, AlgorithmConfiguration> encryptors) {
         EncryptTableRuleConfiguration tableConfig = new EncryptTableRuleConfiguration("foo_tbl", Collections.singleton(columnConfig));
-        return new EncryptRuleConfiguration(Collections.singleton(tableConfig), Collections.emptyMap());
+        return new EncryptRuleConfiguration(Collections.singleton(tableConfig), encryptors);
     }
 }
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
index e9df89c841f..429796130be 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
@@ -18,20 +18,11 @@
 package org.apache.shardingsphere.encrypt.checker.config;
 
 import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
 import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
 import org.apache.shardingsphere.encrypt.constant.EncryptOrder;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
 
-import javax.sql.DataSource;
 import java.util.Collection;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -39,31 +30,6 @@ import java.util.stream.Collectors;
  */
 public final class EncryptRuleConfigurationChecker implements DatabaseRuleConfigurationChecker<EncryptRuleConfiguration> {
     
-    @Override
-    public void check(final String databaseName, final EncryptRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
-        checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getEncryptors());
-    }
-    
-    private void checkTables(final String databaseName, final Collection<EncryptTableRuleConfiguration> tableRuleConfigs, final Map<String, AlgorithmConfiguration> encryptors) {
-        tableRuleConfigs.forEach(each -> checkColumns(databaseName, each, encryptors));
-    }
-    
-    private void checkColumns(final String databaseName, final EncryptTableRuleConfiguration tableRuleConfig, final Map<String, AlgorithmConfiguration> encryptors) {
-        tableRuleConfig.getColumns().forEach(each -> checkColumn(databaseName, tableRuleConfig.getName(), each, encryptors));
-    }
-    
-    private void checkColumn(final String databaseName, final String tableName, final EncryptColumnRuleConfiguration columnRuleConfig, final Map<String, AlgorithmConfiguration> encryptors) {
-        checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), columnRuleConfig.getCipher(), encryptors, "Cipher");
-        columnRuleConfig.getAssistedQuery().ifPresent(optional -> checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), optional, encryptors, "Assist Query"));
-        columnRuleConfig.getLikeQuery().ifPresent(optional -> checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), optional, encryptors, "Like Query"));
-    }
-    
-    private void checkEncryptColumnItem(final String databaseName, final String tableName, final String logicColumnName,
-                                        final EncryptColumnItemRuleConfiguration columnItem, final Map<String, AlgorithmConfiguration> encryptors, final String itemType) {
-        ShardingSpherePreconditions.checkContainsKey(encryptors, columnItem.getEncryptorName(),
-                () -> new UnregisteredAlgorithmException(itemType + " encrypt", columnItem.getEncryptorName(), new SQLExceptionIdentifier(databaseName, tableName, logicColumnName)));
-    }
-    
     @Override
     public Collection<String> getTableNames(final EncryptRuleConfiguration ruleConfig) {
         return ruleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
index 12fe9957466..fac2d6f05cd 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
@@ -18,25 +18,16 @@
 package org.apache.shardingsphere.encrypt.checker.config;
 
 import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
 import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-import java.util.Collection;
 import java.util.Collections;
-import java.util.Map;
-import java.util.Properties;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class EncryptRuleConfigurationCheckerTest {
     
@@ -48,62 +39,8 @@ class EncryptRuleConfigurationCheckerTest {
         checker = OrderedSPILoader.getServicesByClass(DatabaseRuleConfigurationChecker.class, Collections.singleton(EncryptRuleConfiguration.class)).get(EncryptRuleConfiguration.class);
     }
     
-    @SuppressWarnings("unchecked")
-    @Test
-    void assertCheckSuccess() {
-        EncryptRuleConfiguration ruleConfig = createValidRuleConfiguration();
-        assertDoesNotThrow(() -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
     private EncryptRuleConfiguration createValidRuleConfiguration() {
-        EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
-        Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
-        Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
-        return new EncryptRuleConfiguration(tables, encryptors);
-    }
-    
-    @SuppressWarnings("unchecked")
-    @Test
-    void assertCheckWithUnregisteredCipherEncryptor() {
-        EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithUnregisteredCipherEncryptor();
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    private EncryptRuleConfiguration createRuleConfigurationWithUnregisteredCipherEncryptor() {
-        EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "no_encryptor"));
-        Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
-        Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
-        return new EncryptRuleConfiguration(tables, encryptors);
-    }
-    
-    @SuppressWarnings("unchecked")
-    @Test
-    void assertCheckWithInvalidAssistColumn() {
-        EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithInvalidAssistColumn();
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    private EncryptRuleConfiguration createRuleConfigurationWithInvalidAssistColumn() {
-        EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
-        columnRuleConfig.setAssistedQuery(new EncryptColumnItemRuleConfiguration("user_assisted", "aes_assisted_encryptor"));
-        Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
-        Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
-        return new EncryptRuleConfiguration(tables, encryptors);
-    }
-    
-    @SuppressWarnings("unchecked")
-    @Test
-    void assertCheckWithInvalidLikeColumn() {
-        EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithInvalidLikeColumn();
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    private EncryptRuleConfiguration createRuleConfigurationWithInvalidLikeColumn() {
-        EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
-        columnRuleConfig.setLikeQuery(new EncryptColumnItemRuleConfiguration("user_like", "like_cn_encryptor"));
-        Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
-        Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
-        return new EncryptRuleConfiguration(tables, encryptors);
+        return new EncryptRuleConfiguration(Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.emptyList())), Collections.emptyMap());
     }
     
     @SuppressWarnings("unchecked")
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
index 778c9883fe0..436d4c64f33 100644
--- a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
@@ -24,7 +24,9 @@ import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfigurat
 import org.apache.shardingsphere.infra.config.rule.function.EnhancedRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
+import org.apache.shardingsphere.mask.config.validator.ValidMaskRuleConfiguration;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
@@ -38,6 +40,7 @@ import java.util.stream.Collectors;
  */
 @RequiredArgsConstructor
 @Getter
+@ValidMaskRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
 public final class MaskRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
     
     @NotNull
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java
new file mode 100644
index 00000000000..ff30672097c
--- /dev/null
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java
@@ -0,0 +1,49 @@
+/*
+ * 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.mask.config.validator;
+
+import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
+import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
+import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Mask rule configuration validator.
+ */
+public final class MaskRuleConfigurationValidator implements ConstraintValidator<ValidMaskRuleConfiguration, MaskRuleConfiguration> {
+    
+    @Override
+    public boolean isValid(final MaskRuleConfiguration value, final ConstraintValidatorContext context) {
+        return value.getTables().stream().allMatch(each -> isTableValid(each, value, context));
+    }
+    
+    private boolean isTableValid(final MaskTableRuleConfiguration tableConfig, final MaskRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return tableConfig.getColumns().stream().allMatch(each -> isColumnValid(each, ruleConfig, context));
+    }
+    
+    private boolean isColumnValid(final MaskColumnRuleConfiguration columnConfig, final MaskRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (ruleConfig.getMaskAlgorithms().containsKey(columnConfig.getMaskAlgorithm())) {
+            return true;
+        }
+        context.disableDefaultConstraintViolation();
+        context.buildConstraintViolationWithTemplate(String.format("references unconfigured mask algorithm `%s`", columnConfig.getMaskAlgorithm())).addPropertyNode("tables").addConstraintViolation();
+        return false;
+    }
+}
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java
new file mode 100644
index 00000000000..e180304829a
--- /dev/null
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * 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.mask.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid mask rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = MaskRuleConfigurationValidator.class)
+@Documented
+public @interface ValidMaskRuleConfiguration {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid references";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java b/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
index d69e484736c..fba5178de20 100644
--- a/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
+++ b/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
@@ -92,7 +92,8 @@ class MaskRuleConfigurationTest {
                 Arguments.of("Null column", new MaskRuleConfiguration(
                         Collections.singleton(new MaskTableRuleConfiguration("foo_tbl", Collections.singleton(null))), Collections.emptyMap())),
                 Arguments.of("Blank logic column", createRuleConfiguration(new MaskColumnRuleConfiguration("", "foo_mask"))),
-                Arguments.of("Blank column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", ""))));
+                Arguments.of("Blank column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", ""))),
+                Arguments.of("Unconfigured column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", "foo_mask"))));
     }
     
     private static MaskRuleConfiguration createRuleConfiguration(final MaskColumnRuleConfiguration columnConfig) {
diff --git a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
index 980661c2c36..44930f13ad9 100644
--- a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
+++ b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
@@ -17,20 +17,12 @@
 
 package org.apache.shardingsphere.mask.checker;
 
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
 import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
-import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
 import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
 import org.apache.shardingsphere.mask.constant.MaskOrder;
 
-import javax.sql.DataSource;
 import java.util.Collection;
-import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -38,24 +30,6 @@ import java.util.stream.Collectors;
  */
 public final class MaskRuleConfigurationChecker implements DatabaseRuleConfigurationChecker<MaskRuleConfiguration> {
     
-    @Override
-    public void check(final String databaseName, final MaskRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
-        checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getMaskAlgorithms());
-    }
-    
-    private void checkTables(final String databaseName, final Collection<MaskTableRuleConfiguration> tables, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
-        tables.forEach(each -> checkColumns(databaseName, each, maskAlgorithms));
-    }
-    
-    private void checkColumns(final String databaseName, final MaskTableRuleConfiguration tableRuleConfig, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
-        tableRuleConfig.getColumns().forEach(each -> checkColumn(databaseName, tableRuleConfig.getName(), each, maskAlgorithms));
-    }
-    
-    private void checkColumn(final String databaseName, final String tableName, final MaskColumnRuleConfiguration columnRuleConfig, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
-        ShardingSpherePreconditions.checkContainsKey(maskAlgorithms, columnRuleConfig.getMaskAlgorithm(),
-                () -> new UnregisteredAlgorithmException("Mask", columnRuleConfig.getMaskAlgorithm(), new SQLExceptionIdentifier(databaseName, tableName, columnRuleConfig.getLogicColumn())));
-    }
-    
     @Override
     public Collection<String> getTableNames(final MaskRuleConfiguration ruleConfig) {
         return ruleConfig.getTables().stream().map(MaskTableRuleConfiguration::getName).collect(Collectors.toList());
diff --git a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
index 1c0f0b7fac8..00ae6600335 100644
--- a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
+++ b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
@@ -17,19 +17,15 @@
 
 package org.apache.shardingsphere.mask.checker;
 
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
 import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
-import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
 import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -46,9 +42,8 @@ class MaskRuleConfigurationCheckerTest {
     
     @SuppressWarnings("unchecked")
     @Test
-    void assertValidCheck() {
+    void assertGetTableNames() {
         MaskRuleConfiguration ruleConfig = mockValidConfiguration();
-        assertDoesNotThrow(() -> checker.check("test", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
         assertTrue(checker.getTableNames(ruleConfig).contains("t_mask"));
     }
     
@@ -60,20 +55,4 @@ class MaskRuleConfigurationCheckerTest {
         return result;
     }
     
-    @SuppressWarnings("unchecked")
-    @Test
-    void assertInvalidCheck() {
-        MaskRuleConfiguration ruleConfig = mockInvalidConfiguration();
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("test", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    private MaskRuleConfiguration mockInvalidConfiguration() {
-        MaskRuleConfiguration result = mock(MaskRuleConfiguration.class);
-        MaskTableRuleConfiguration tableRuleConfig = mock(MaskTableRuleConfiguration.class);
-        MaskColumnRuleConfiguration columnRuleConfig = mock(MaskColumnRuleConfiguration.class);
-        when(columnRuleConfig.getMaskAlgorithm()).thenReturn("md5");
-        when(tableRuleConfig.getColumns()).thenReturn(Collections.singleton(columnRuleConfig));
-        when(result.getTables()).thenReturn(Collections.singleton(tableRuleConfig));
-        return result;
-    }
 }
diff --git a/features/readwrite-splitting/api/pom.xml b/features/readwrite-splitting/api/pom.xml
index f19fd9f23d7..fffe3c0a126 100644
--- a/features/readwrite-splitting/api/pom.xml
+++ b/features/readwrite-splitting/api/pom.xml
@@ -29,7 +29,7 @@
     <dependencies>
         <dependency>
             <groupId>org.apache.shardingsphere</groupId>
-            <artifactId>shardingsphere-infra-algorithm-core</artifactId>
+            <artifactId>shardingsphere-infra-algorithm-load-balancer-spi</artifactId>
             <version>${project.version}</version>
         </dependency>
         
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
index 8a81b473f9e..1e573d01325 100644
--- a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
@@ -22,7 +22,10 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
 import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.config.validator.ValidReadwriteSplittingRuleConfiguration;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
@@ -35,6 +38,7 @@ import java.util.Map;
  */
 @RequiredArgsConstructor
 @Getter
+@ValidReadwriteSplittingRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
 public final class ReadwriteSplittingRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
     
     @NotNull
@@ -42,5 +46,6 @@ public final class ReadwriteSplittingRuleConfiguration implements DatabaseRuleCo
     private final Collection<@NotNull ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups;
     
     @NotNull
+    @SPITypeExists(spiClassName = "org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm")
     private final Map<@NotBlank String, @NotNull AlgorithmConfiguration> loadBalancers;
 }
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java
new file mode 100644
index 00000000000..1c732eb681a
--- /dev/null
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java
@@ -0,0 +1,47 @@
+/*
+ * 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.readwritesplitting.config.validator;
+
+import com.google.common.base.Strings;
+import org.apache.shardingsphere.readwritesplitting.config.ReadwriteSplittingRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Readwrite-splitting rule configuration validator.
+ */
+public final class ReadwriteSplittingRuleConfigurationValidator implements ConstraintValidator<ValidReadwriteSplittingRuleConfiguration, ReadwriteSplittingRuleConfiguration> {
+    
+    @Override
+    public boolean isValid(final ReadwriteSplittingRuleConfiguration value, final ConstraintValidatorContext context) {
+        return value.getDataSourceGroups().stream().allMatch(each -> isLoadBalancerReferenceValid(each, value, context));
+    }
+    
+    private boolean isLoadBalancerReferenceValid(final ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupConfig,
+                                                 final ReadwriteSplittingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (Strings.isNullOrEmpty(dataSourceGroupConfig.getLoadBalancerName()) || ruleConfig.getLoadBalancers().containsKey(dataSourceGroupConfig.getLoadBalancerName())) {
+            return true;
+        }
+        context.disableDefaultConstraintViolation();
+        context.buildConstraintViolationWithTemplate(String.format("references unconfigured load balancer `%s`", dataSourceGroupConfig.getLoadBalancerName()))
+                .addPropertyNode("dataSourceGroups").addConstraintViolation();
+        return false;
+    }
+}
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java
new file mode 100644
index 00000000000..b4cd57e365e
--- /dev/null
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * 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.readwritesplitting.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid readwrite-splitting rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ReadwriteSplittingRuleConfigurationValidator.class)
+@Documented
+public @interface ValidReadwriteSplittingRuleConfiguration {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid references";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
index 930ad7ea26d..ced5782afa7 100644
--- a/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
+++ b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
@@ -52,7 +52,7 @@ class ReadwriteSplittingRuleConfigurationTest {
                                 "foo_group", "foo_write", Collections.singletonList("foo_read"), null)),
                         Collections.emptyMap())),
                 Arguments.of("Complete configuration", new ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceGroupConfig),
-                        Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("ROUND_ROBIN", new Properties())))));
+                        Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("FIXTURE", new Properties())))));
     }
     
     @ParameterizedTest(name = "{0}")
@@ -62,7 +62,7 @@ class ReadwriteSplittingRuleConfigurationTest {
     }
     
     private static Stream<Arguments> invalidRuleConfigurationArguments() {
-        AlgorithmConfiguration loadBalancer = new AlgorithmConfiguration("ROUND_ROBIN", new Properties());
+        AlgorithmConfiguration loadBalancer = new AlgorithmConfiguration("FIXTURE", new Properties());
         return Stream.of(
                 Arguments.of("Null data source groups", new ReadwriteSplittingRuleConfiguration(null, Collections.emptyMap())),
                 Arguments.of("Null data source group", new ReadwriteSplittingRuleConfiguration(Collections.singleton(null), Collections.emptyMap())),
@@ -71,6 +71,12 @@ class ReadwriteSplittingRuleConfigurationTest {
                         Collections.emptyList(), Collections.singletonMap("", loadBalancer))),
                 Arguments.of("Null load balancer", new ReadwriteSplittingRuleConfiguration(
                         Collections.emptyList(), Collections.singletonMap("foo_load_balancer", null))),
+                Arguments.of("Missing load balancer type", new ReadwriteSplittingRuleConfiguration(
+                        Collections.emptyList(), Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("MISSING", new Properties())))),
+                Arguments.of("Unconfigured group load balancer", new ReadwriteSplittingRuleConfiguration(Collections.singleton(
+                        new ReadwriteSplittingDataSourceGroupRuleConfiguration(
+                                "foo_group", "foo_write", Collections.singletonList("foo_read"), TransactionalReadQueryStrategy.PRIMARY, "bar_load_balancer")),
+                        Collections.singletonMap("foo_load_balancer", loadBalancer))),
                 Arguments.of("Blank group name", createRuleConfiguration(new ReadwriteSplittingDataSourceGroupRuleConfiguration(
                         "", "foo_write", Collections.singletonList("foo_read"), TransactionalReadQueryStrategy.PRIMARY, null))),
                 Arguments.of("Blank write data source", createRuleConfiguration(new ReadwriteSplittingDataSourceGroupRuleConfiguration(
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
similarity index 57%
rename from features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java
rename to features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
index 64c85f532ac..ee56bcbe278 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java
+++ b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
@@ -15,19 +15,24 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.shadow.exception.metadata;
+package org.apache.shardingsphere.readwritesplitting.config.fixture;
 
-import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
-import org.apache.shardingsphere.shadow.exception.ShadowSQLException;
+import org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm;
+
+import java.util.List;
 
 /**
- * Not implement hint shadow algorithm exception.
+ * Load balance algorithm fixture.
  */
-public final class NotImplementHintShadowAlgorithmException extends ShadowSQLException {
+public final class LoadBalanceAlgorithmFixture implements LoadBalanceAlgorithm {
     
-    private static final long serialVersionUID = -5012158924968675485L;
+    @Override
+    public String getTargetName(final String groupName, final List<String> availableTargetNames) {
+        return availableTargetNames.get(0);
+    }
     
-    public NotImplementHintShadowAlgorithmException() {
-        super(XOpenSQLState.CHECK_OPTION_VIOLATION, 3, "Default shadow algorithm class should be implement HintShadowAlgorithm.");
+    @Override
+    public String getType() {
+        return "FIXTURE";
     }
 }
diff --git a/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm b/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm
new file mode 100644
index 00000000000..23109945814
--- /dev/null
+++ b/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.readwritesplitting.config.fixture.LoadBalanceAlgorithmFixture
diff --git a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
index fa81656d915..19507692772 100644
--- a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
+++ b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
@@ -18,11 +18,8 @@
 package org.apache.shardingsphere.readwritesplitting.checker;
 
 import com.google.common.base.Strings;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
 import org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
 import org.apache.shardingsphere.infra.expr.entry.InlineExpressionParserFactory;
 import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
 import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
@@ -65,7 +62,6 @@ public final class ReadwriteSplittingRuleConfigurationChecker implements Databas
                 continue;
             }
             LoadBalanceAlgorithm loadBalancer = loadBalancers.get(each.getLoadBalancerName());
-            ShardingSpherePreconditions.checkNotNull(loadBalancer, () -> new UnregisteredAlgorithmException("Load balancer", each.getLoadBalancerName(), new SQLExceptionIdentifier(databaseName)));
             loadBalancer.check(databaseName, getActualDataSourceNames(each.getReadDataSourceNames()));
         }
     }
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
index 7480cfda1d5..fa04928d73b 100644
--- a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
@@ -23,8 +23,10 @@ import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfigurat
 import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
 import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
+import org.apache.shardingsphere.shadow.config.validator.ValidShadowRuleConfiguration;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
@@ -39,6 +41,7 @@ import java.util.Map;
  */
 @Getter
 @Setter
+@ValidShadowRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
 public final class ShadowRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
     
     @NotNull
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java
new file mode 100644
index 00000000000..a640e91b2ef
--- /dev/null
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java
@@ -0,0 +1,85 @@
+/*
+ * 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.shadow.config.validator;
+
+import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
+import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
+import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
+import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+/**
+ * Shadow rule configuration validator.
+ */
+public final class ShadowRuleConfigurationValidator implements ConstraintValidator<ValidShadowRuleConfiguration, ShadowRuleConfiguration> {
+    
+    @Override
+    public boolean isValid(final ShadowRuleConfiguration value, final ConstraintValidatorContext context) {
+        return isDefaultShadowAlgorithmValid(value, context) && areTableDataSourcesValid(value, context) && areTableAlgorithmsValid(value, context);
+    }
+    
+    private boolean isDefaultShadowAlgorithmValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (null == ruleConfig.getDefaultShadowAlgorithmName()) {
+            return true;
+        }
+        AlgorithmConfiguration algorithmConfig = ruleConfig.getShadowAlgorithms().get(ruleConfig.getDefaultShadowAlgorithmName());
+        if (null != algorithmConfig && "SQL_HINT".equals(algorithmConfig.getType())) {
+            return true;
+        }
+        context.disableDefaultConstraintViolation();
+        context.buildConstraintViolationWithTemplate("must reference a configured SQL_HINT shadow algorithm").addPropertyNode("defaultShadowAlgorithmName").addConstraintViolation();
+        return false;
+    }
+    
+    private boolean areTableDataSourcesValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        Collection<String> dataSourceNames = ruleConfig.getDataSources().stream().map(ShadowDataSourceConfiguration::getName).collect(Collectors.toSet());
+        return ruleConfig.getTables().entrySet().stream().allMatch(entry -> areTableDataSourcesValid(entry.getKey(), entry.getValue(), dataSourceNames, context));
+    }
+    
+    private boolean areTableDataSourcesValid(final String tableName, final ShadowTableConfiguration tableConfig, final Collection<String> dataSourceNames, final ConstraintValidatorContext context) {
+        for (String each : tableConfig.getDataSourceNames()) {
+            if (!dataSourceNames.contains(each)) {
+                context.disableDefaultConstraintViolation();
+                context.buildConstraintViolationWithTemplate(String.format("table `%s` references unconfigured shadow data source `%s`", tableName, each))
+                        .addPropertyNode("tables").addConstraintViolation();
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    private boolean areTableAlgorithmsValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return ruleConfig.getTables().entrySet().stream().allMatch(entry -> areTableAlgorithmsValid(entry.getKey(), entry.getValue(), ruleConfig, context));
+    }
+    
+    private boolean areTableAlgorithmsValid(final String tableName, final ShadowTableConfiguration tableConfig, final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        for (String each : tableConfig.getShadowAlgorithmNames()) {
+            if (!ruleConfig.getShadowAlgorithms().containsKey(each)) {
+                context.disableDefaultConstraintViolation();
+                context.buildConstraintViolationWithTemplate(String.format("table `%s` references unconfigured shadow algorithm `%s`", tableName, each))
+                        .addPropertyNode("tables").addConstraintViolation();
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java
new file mode 100644
index 00000000000..626c3d7c7d5
--- /dev/null
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * 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.shadow.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid shadow rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ShadowRuleConfigurationValidator.class)
+@Documented
+public @interface ValidShadowRuleConfiguration {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid references";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
index 421f468f866..bbb051c6b8d 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
+++ b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
@@ -26,7 +26,6 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
@@ -45,6 +44,10 @@ class ShadowRuleConfigurationTest {
     }
     
     private static Stream<Arguments> validRuleConfigurationArguments() {
+        ShadowRuleConfiguration defaultAlgorithmRuleConfig = createRuleConfiguration(
+                Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")), Collections.emptyMap(),
+                Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("SQL_HINT", new Properties())));
+        defaultAlgorithmRuleConfig.setDefaultShadowAlgorithmName("foo_shadow_algorithm");
         return Stream.of(
                 Arguments.of("Empty configuration", new ShadowRuleConfiguration()),
                 Arguments.of("Data source configuration", createRuleConfiguration(
@@ -53,8 +56,9 @@ class ShadowRuleConfigurationTest {
                 Arguments.of("Complete configuration", createRuleConfiguration(
                         Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
                         Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
-                                Arrays.asList("foo_ds", "bar_ds"), Collections.singleton("foo_shadow_algorithm"))),
-                        Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("FIXTURE", new Properties())))));
+                                Collections.singleton("foo_ds"), Collections.singleton("foo_shadow_algorithm"))),
+                        Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("FIXTURE", new Properties())))),
+                Arguments.of("Default SQL hint algorithm", defaultAlgorithmRuleConfig));
     }
     
     private static ShadowRuleConfiguration createRuleConfiguration(final Collection<ShadowDataSourceConfiguration> dataSources,
@@ -75,6 +79,12 @@ class ShadowRuleConfigurationTest {
     
     private static Stream<Arguments> invalidRuleConfigurationArguments() {
         AlgorithmConfiguration algorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
+        ShadowRuleConfiguration missingDefaultAlgorithm = createRuleConfiguration(Collections.emptyList(), Collections.emptyMap(),
+                Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("SQL_HINT", new Properties())));
+        missingDefaultAlgorithm.setDefaultShadowAlgorithmName("bar_shadow_algorithm");
+        ShadowRuleConfiguration invalidDefaultAlgorithmType = createRuleConfiguration(
+                Collections.emptyList(), Collections.emptyMap(), Collections.singletonMap("foo_shadow_algorithm", algorithmConfig));
+        invalidDefaultAlgorithmType.setDefaultShadowAlgorithmName("foo_shadow_algorithm");
         return Stream.of(
                 Arguments.of("Null data sources", createRuleConfiguration(null, Collections.emptyMap(), Collections.emptyMap())),
                 Arguments.of("Null data source", createRuleConfiguration(Collections.singleton(null), Collections.emptyMap(), Collections.emptyMap())),
@@ -108,7 +118,19 @@ class ShadowRuleConfigurationTest {
                 Arguments.of("Null shadow algorithm", createRuleConfiguration(
                         Collections.emptyList(), Collections.emptyMap(), Collections.singletonMap("foo_shadow_algorithm", null))),
                 Arguments.of("Missing shadow algorithm type", createRuleConfiguration(Collections.emptyList(), Collections.emptyMap(),
-                        Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("MISSING", new Properties())))));
+                        Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("MISSING", new Properties())))),
+                Arguments.of("Unconfigured table data source", createRuleConfiguration(
+                        Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
+                        Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
+                                Collections.singleton("bar_ds"), Collections.singleton("foo_shadow_algorithm"))),
+                        Collections.singletonMap("foo_shadow_algorithm", algorithmConfig))),
+                Arguments.of("Unconfigured table shadow algorithm", createRuleConfiguration(
+                        Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
+                        Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
+                                Collections.singleton("foo_ds"), Collections.singleton("bar_shadow_algorithm"))),
+                        Collections.singletonMap("foo_shadow_algorithm", algorithmConfig))),
+                Arguments.of("Unconfigured default shadow algorithm", missingDefaultAlgorithm),
+                Arguments.of("Default shadow algorithm without SQL hint type", invalidDefaultAlgorithmType));
     }
     
 }
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
index 6fd6cf66cdf..f590455a8bc 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
@@ -19,10 +19,18 @@ package org.apache.shardingsphere.shadow.config.fixture;
 
 import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
 
+import java.util.Collection;
+import java.util.Collections;
+
 public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
     
     @Override
     public String getType() {
         return "FIXTURE";
     }
+    
+    @Override
+    public Collection<Object> getTypeAliases() {
+        return Collections.singleton("SQL_HINT");
+    }
 }
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
index d0b89f33a34..241feb2ae79 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
+++ b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
@@ -17,26 +17,19 @@
 
 package org.apache.shardingsphere.shadow.checker;
 
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.MissingRequiredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
 import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
 import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
 import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
-import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
 import org.apache.shardingsphere.shadow.constant.ShadowOrder;
 import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredProductionDataSourceException;
 import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredShadowDataSourceException;
-import org.apache.shardingsphere.shadow.exception.metadata.NotImplementHintShadowAlgorithmException;
-import org.apache.shardingsphere.shadow.exception.metadata.ShadowDataSourceMappingNotFoundException;
 
 import javax.sql.DataSource;
 import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * Shadow rule configuration checker.
@@ -45,17 +38,7 @@ public final class ShadowRuleConfigurationChecker implements DatabaseRuleConfigu
     
     @Override
     public void check(final String databaseName, final ShadowRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
-        checkDefaultShadowAlgorithm(ruleConfig.getDefaultShadowAlgorithmName(), ruleConfig.getShadowAlgorithms());
         checkDataSources(ruleConfig.getDataSources(), dataSourceMap, databaseName);
-        checkShadowTableDataSourcesReferences(ruleConfig.getTables(), ruleConfig.getDataSources());
-        checkShadowTableAlgorithmsReferences(ruleConfig.getTables(), ruleConfig.getShadowAlgorithms(), databaseName);
-    }
-    
-    private void checkDefaultShadowAlgorithm(final String defaultShadowAlgorithmName, final Map<String, AlgorithmConfiguration> shadowAlgorithmConfigs) {
-        if (null != defaultShadowAlgorithmName) {
-            AlgorithmConfiguration algorithmConfig = shadowAlgorithmConfigs.get(defaultShadowAlgorithmName);
-            ShardingSpherePreconditions.checkState(null != algorithmConfig && "SQL_HINT".equals(algorithmConfig.getType()), NotImplementHintShadowAlgorithmException::new);
-        }
     }
     
     private void checkDataSources(final Collection<ShadowDataSourceConfiguration> shadowDataSources, final Map<String, DataSource> dataSourceMap, final String databaseName) {
@@ -65,22 +48,6 @@ public final class ShadowRuleConfigurationChecker implements DatabaseRuleConfigu
         }
     }
     
-    private void checkShadowTableDataSourcesReferences(final Map<String, ShadowTableConfiguration> shadowTables, final Collection<ShadowDataSourceConfiguration> shadowDataSources) {
-        Collection<String> dataSourceNames = shadowDataSources.stream().map(ShadowDataSourceConfiguration::getName).collect(Collectors.toSet());
-        shadowTables.forEach((key, value) -> {
-            for (String each : value.getDataSourceNames()) {
-                ShardingSpherePreconditions.checkContains(dataSourceNames, each, () -> new ShadowDataSourceMappingNotFoundException(key));
-            }
-        });
-    }
-    
-    private void checkShadowTableAlgorithmsReferences(final Map<String, ShadowTableConfiguration> shadowTables, final Map<String, AlgorithmConfiguration> shadowAlgorithms, final String databaseName) {
-        for (ShadowTableConfiguration each : shadowTables.values()) {
-            each.getShadowAlgorithmNames().forEach(shadowAlgorithmName -> ShardingSpherePreconditions.checkContainsKey(shadowAlgorithms, shadowAlgorithmName,
-                    () -> new MissingRequiredAlgorithmException("Shadow", new SQLExceptionIdentifier(databaseName))));
-        }
-    }
-    
     @Override
     public Collection<String> getRequiredDataSourceNames(final ShadowRuleConfiguration ruleConfig) {
         Collection<String> result = new LinkedHashSet<>();
diff --git a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
index 3208fa17be2..effb53e8209 100644
--- a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
+++ b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
@@ -18,18 +18,13 @@
 package org.apache.shardingsphere.shadow.checker;
 
 import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.MissingRequiredAlgorithmException;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
 import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
 import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
 import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
 import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredProductionDataSourceException;
 import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredShadowDataSourceException;
-import org.apache.shardingsphere.shadow.exception.metadata.NotImplementHintShadowAlgorithmException;
-import org.apache.shardingsphere.shadow.exception.metadata.ShadowDataSourceMappingNotFoundException;
 import org.apache.shardingsphere.test.infra.fixture.jdbc.MockedDataSource;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -57,67 +52,6 @@ class ShadowRuleConfigurationCheckerTest {
                 DatabaseRuleConfigurationChecker.class, Collections.singleton(ShadowRuleConfiguration.class)).get(ShadowRuleConfiguration.class);
     }
     
-    @Test
-    void assertCheckWithNotExistedDefaultShadowAlgorithm() {
-        assertThrows(NotImplementHintShadowAlgorithmException.class,
-                () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithNotExistedDefaultShadowAlgorithm(), createDataSourceMap(), Collections.emptyList()));
-    }
-    
-    private ShadowRuleConfiguration createRuleConfigurationWithNotExistedDefaultShadowAlgorithm() {
-        ShadowRuleConfiguration result = new ShadowRuleConfiguration();
-        result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
-        result.setDefaultShadowAlgorithmName("bar-algo");
-        result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
-        result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("foo-algo"))));
-        return result;
-    }
-    
-    @Test
-    void assertCheckWithInvalidDefaultShadowAlgorithm() {
-        assertThrows(NotImplementHintShadowAlgorithmException.class,
-                () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidDefaultShadowAlgorithm(), createDataSourceMap(), Collections.emptyList()));
-    }
-    
-    private ShadowRuleConfiguration createRuleConfigurationWithInvalidDefaultShadowAlgorithm() {
-        ShadowRuleConfiguration result = new ShadowRuleConfiguration();
-        result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("REGEX_MATCH",
-                PropertiesBuilder.build(new Property("column", "foo_id"), new Property("operation", "insert"), new Property("regex", "[1]")))));
-        result.setDefaultShadowAlgorithmName("foo-algo");
-        result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
-        result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("foo-algo"))));
-        return result;
-    }
-    
-    @Test
-    void assertCheckWithInvalidShadowTableDataSourcesReferences() {
-        assertThrows(ShadowDataSourceMappingNotFoundException.class,
-                () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidShadowTableDataSourcesReferences(), createDataSourceMap(), Collections.emptyList()));
-    }
-    
-    private ShadowRuleConfiguration createRuleConfigurationWithInvalidShadowTableDataSourcesReferences() {
-        ShadowRuleConfiguration result = new ShadowRuleConfiguration();
-        result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
-        result.setDefaultShadowAlgorithmName("foo-algo");
-        result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
-        result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("bar_ds"), Collections.singleton("foo-algo"))));
-        return result;
-    }
-    
-    @Test
-    void assertCheckWithInvalidShadowTableAlgorithmsReferences() {
-        assertThrows(MissingRequiredAlgorithmException.class,
-                () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidShadowTableAlgorithmsReferences(), createDataSourceMap(), Collections.emptyList()));
-    }
-    
-    private ShadowRuleConfiguration createRuleConfigurationWithInvalidShadowTableAlgorithmsReferences() {
-        ShadowRuleConfiguration result = new ShadowRuleConfiguration();
-        result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
-        result.setDefaultShadowAlgorithmName("foo-algo");
-        result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
-        result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("bar-algo"))));
-        return result;
-    }
-    
     @Test
     void assertCheckWithoutProductionDataSourceName() {
         assertThrows(MissingRequiredProductionDataSourceException.class,
diff --git a/features/sharding/api/pom.xml b/features/sharding/api/pom.xml
index 6532a025cf8..ef383e634de 100644
--- a/features/sharding/api/pom.xml
+++ b/features/sharding/api/pom.xml
@@ -29,7 +29,7 @@
     <dependencies>
         <dependency>
             <groupId>org.apache.shardingsphere</groupId>
-            <artifactId>shardingsphere-infra-algorithm-core</artifactId>
+            <artifactId>shardingsphere-infra-algorithm-key-generator-spi</artifactId>
             <version>${project.version}</version>
         </dependency>
         <dependency>
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
index f18522d9e60..ae2e4617e38 100644
--- a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
@@ -25,12 +25,14 @@ import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfig
 import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReferenceRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
 import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
 import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.validator.ValidShardingRuleConfiguration;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotBlank;
@@ -46,6 +48,7 @@ import java.util.stream.Collectors;
  */
 @Getter
 @Setter
+@ValidShardingRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
 public final class ShardingRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
     
     @NotNull
@@ -87,6 +90,7 @@ public final class ShardingRuleConfiguration implements DatabaseRuleConfiguratio
     private Map<@NotBlank String, @NotNull AlgorithmConfiguration> keyGenerators = new LinkedHashMap<>();
     
     @NotNull
+    @SPITypeExists(spiClassName = "org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm")
     private Map<@NotBlank String, @NotNull AlgorithmConfiguration> auditors = new LinkedHashMap<>();
     
     @Override
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java
new file mode 100644
index 00000000000..fd32b06e1fd
--- /dev/null
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java
@@ -0,0 +1,106 @@
+/*
+ * 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.sharding.api.config.validator;
+
+import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
+import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
+import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
+import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Sharding rule configuration validator.
+ */
+public final class ShardingRuleConfigurationValidator implements ConstraintValidator<ValidShardingRuleConfiguration, ShardingRuleConfiguration> {
+    
+    @Override
+    public boolean isValid(final ShardingRuleConfiguration value, final ConstraintValidatorContext context) {
+        return areTablesValid(value, context)
+                && areAutoTablesValid(value, context)
+                && isKeyGenerateStrategyValid(value.getDefaultKeyGenerateStrategy(), "defaultKeyGenerateStrategy", value, context)
+                && areKeyGenerateStrategiesValid(value, context)
+                && isAuditStrategyValid(value.getDefaultAuditStrategy(), "defaultAuditStrategy", value, context)
+                && isShardingStrategyValid(value.getDefaultDatabaseShardingStrategy(), "defaultDatabaseShardingStrategy", value, context)
+                && isShardingStrategyValid(value.getDefaultTableShardingStrategy(), "defaultTableShardingStrategy", value, context);
+    }
+    
+    private boolean areTablesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return ruleConfig.getTables().stream().noneMatch(each -> !isAuditStrategyValid(each.getAuditStrategy(), "tables", ruleConfig, context)
+                || !isShardingStrategyValid(each.getDatabaseShardingStrategy(), "tables", ruleConfig, context)
+                || !isShardingStrategyValid(each.getTableShardingStrategy(), "tables", ruleConfig, context));
+    }
+    
+    private boolean areAutoTablesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return ruleConfig.getAutoTables().stream().noneMatch(each -> !isAuditStrategyValid(each.getAuditStrategy(), "autoTables", ruleConfig, context)
+                || !isShardingStrategyValid(each.getShardingStrategy(), "autoTables", ruleConfig, context));
+    }
+    
+    private boolean isKeyGenerateStrategyValid(final KeyGenerateStrategyConfiguration strategyConfig, final String propertyName,
+                                               final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (null == strategyConfig || ruleConfig.getKeyGenerators().containsKey(strategyConfig.getKeyGeneratorName())) {
+            return true;
+        }
+        return addViolation(propertyName, String.format("references unconfigured key generator `%s`", strategyConfig.getKeyGeneratorName()), context);
+    }
+    
+    private boolean areKeyGenerateStrategiesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        return ruleConfig.getKeyGenerateStrategies().entrySet().stream().allMatch(entry -> isKeyGenerateStrategiesValid(entry.getKey(), entry.getValue(), ruleConfig, context));
+    }
+    
+    private boolean isKeyGenerateStrategiesValid(final String strategyName, final KeyGenerateStrategiesConfiguration strategyConfig,
+                                                 final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (!(strategyConfig instanceof ColumnKeyGenerateStrategiesRuleConfiguration) && !(strategyConfig instanceof SequenceKeyGenerateStrategiesRuleConfiguration)) {
+            return addViolation("keyGenerateStrategies", String.format("strategy `%s` must use column or sequence key generation", strategyName), context);
+        }
+        if (!ruleConfig.getKeyGenerators().containsKey(strategyConfig.getKeyGeneratorName())) {
+            return addViolation("keyGenerateStrategies", String.format("strategy `%s` references unconfigured key generator `%s`",
+                    strategyName, strategyConfig.getKeyGeneratorName()), context);
+        }
+        return true;
+    }
+    
+    private boolean isAuditStrategyValid(final ShardingAuditStrategyConfiguration strategyConfig, final String propertyName,
+                                         final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (null == strategyConfig) {
+            return true;
+        }
+        return strategyConfig.getAuditorNames().stream()
+                .filter(each -> !ruleConfig.getAuditors().containsKey(each)).findFirst()
+                .map(each -> addViolation(propertyName, String.format("references unconfigured auditor `%s`", each), context)).orElse(true);
+    }
+    
+    private boolean isShardingStrategyValid(final ShardingStrategyConfiguration strategyConfig, final String propertyName,
+                                            final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+        if (null == strategyConfig || strategyConfig instanceof NoneShardingStrategyConfiguration || ruleConfig.getShardingAlgorithms().containsKey(strategyConfig.getShardingAlgorithmName())) {
+            return true;
+        }
+        return addViolation(propertyName, String.format("references unconfigured sharding algorithm `%s`", strategyConfig.getShardingAlgorithmName()), context);
+    }
+    
+    private boolean addViolation(final String propertyName, final String message, final ConstraintValidatorContext context) {
+        context.disableDefaultConstraintViolation();
+        context.buildConstraintViolationWithTemplate(message).addPropertyNode(propertyName).addConstraintViolation();
+        return false;
+    }
+}
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java
new file mode 100644
index 00000000000..e35f5449211
--- /dev/null
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * 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.sharding.api.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid sharding rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ShardingRuleConfigurationValidator.class)
+@Documented
+public @interface ValidShardingRuleConfiguration {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid references";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
index a7e0443dd8c..b763c52ea2d 100644
--- a/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
@@ -74,6 +74,7 @@ class ShardingRuleConfigurationTest {
         ShardingRuleConfiguration defaultShardingColumnRuleConfig = new ShardingRuleConfiguration();
         defaultShardingColumnRuleConfig.setDefaultShardingColumn("user_id");
         defaultShardingColumnRuleConfig.getTables().add(createTableRuleConfiguration(new StandardShardingStrategyConfiguration(null, "foo_standard")));
+        defaultShardingColumnRuleConfig.getShardingAlgorithms().put("foo_standard", new AlgorithmConfiguration("FIXTURE", new Properties()));
         return Stream.of(
                 Arguments.of("Empty configuration", new ShardingRuleConfiguration()),
                 Arguments.of("Table with nullable optional values", tableRuleConfig),
@@ -100,8 +101,12 @@ class ShardingRuleConfigurationTest {
         result.setDefaultShardingColumn("user_id");
         result.getKeyGenerateStrategies().put("foo_column", new ColumnKeyGenerateStrategiesRuleConfiguration("foo_key_generator", "foo_tbl", "order_id"));
         result.getKeyGenerateStrategies().put("foo_sequence", new SequenceKeyGenerateStrategiesRuleConfiguration("foo_key_generator", "foo_sequence"));
-        result.getShardingAlgorithms().put("foo_sharding", new AlgorithmConfiguration("FIXTURE", new Properties()));
-        result.getAuditors().put("foo_auditor", new AlgorithmConfiguration("INLINE", new Properties()));
+        AlgorithmConfiguration shardingAlgorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
+        result.getShardingAlgorithms().put("foo_standard", shardingAlgorithmConfig);
+        result.getShardingAlgorithms().put("foo_complex", shardingAlgorithmConfig);
+        result.getShardingAlgorithms().put("foo_hint", shardingAlgorithmConfig);
+        result.getKeyGenerators().put("foo_key_generator", new AlgorithmConfiguration("FIXTURE", new Properties()));
+        result.getAuditors().put("foo_auditor", new AlgorithmConfiguration("FIXTURE_AUDIT", new Properties()));
         return result;
     }
     
@@ -162,9 +167,13 @@ class ShardingRuleConfigurationTest {
                         "foo_sharding", new AlgorithmConfiguration("MISSING", new Properties()))),
                 Arguments.of("Null key generators", nullKeyGenerators),
                 Arguments.of("Null key generator", createKeyGeneratorsRuleConfiguration("foo_key_generator", null)),
+                Arguments.of("Missing key generator type", createKeyGeneratorsRuleConfiguration(
+                        "foo_key_generator", new AlgorithmConfiguration("MISSING", new Properties()))),
                 Arguments.of("Null auditors", nullAuditors),
                 Arguments.of("Blank auditor name", createAuditorsRuleConfiguration("", algorithmConfig)),
                 Arguments.of("Null auditor", createAuditorsRuleConfiguration("foo_auditor", null)),
+                Arguments.of("Missing auditor type", createAuditorsRuleConfiguration(
+                        "foo_auditor", new AlgorithmConfiguration("MISSING", new Properties()))),
                 Arguments.of("Blank table logic name", createRuleConfiguration(new ShardingTableRuleConfiguration("", null))),
                 Arguments.of("Invalid table sharding strategy", createRuleConfiguration(invalidTableStrategy)),
                 Arguments.of("Invalid table audit strategy", createRuleConfiguration(invalidTableAuditStrategy)),
@@ -206,6 +215,52 @@ class ShardingRuleConfigurationTest {
                         new SequenceKeyGenerateStrategiesRuleConfiguration("foo_key_generator", ""))));
     }
     
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("invalidReferenceRuleConfigurationArguments")
+    void assertValidateInvalidReferenceRuleConfiguration(final String name, final ShardingRuleConfiguration ruleConfig) {
+        assertThrows(InvalidRuleConfigurationException.class, () -> RuleConfigurationValidator.validate(ruleConfig));
+    }
+    
+    private static Stream<Arguments> invalidReferenceRuleConfigurationArguments() {
+        ShardingRuleConfiguration unconfiguredTableDatabaseShardingAlgorithm = createValidRuleConfiguration();
+        unconfiguredTableDatabaseShardingAlgorithm.getTables().iterator().next()
+                .setDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("user_id", "bar_standard"));
+        ShardingRuleConfiguration unconfiguredTableShardingAlgorithm = createValidRuleConfiguration();
+        unconfiguredTableShardingAlgorithm.getTables().iterator().next()
+                .setTableShardingStrategy(new ComplexShardingStrategyConfiguration("order_id,user_id", "bar_complex"));
+        ShardingRuleConfiguration unconfiguredAutoTableShardingAlgorithm = createValidRuleConfiguration();
+        unconfiguredAutoTableShardingAlgorithm.getAutoTables().iterator().next().setShardingStrategy(new HintShardingStrategyConfiguration("bar_hint"));
+        ShardingRuleConfiguration unconfiguredDefaultDatabaseShardingAlgorithm = createValidRuleConfiguration();
+        unconfiguredDefaultDatabaseShardingAlgorithm.setDefaultDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("user_id", "bar_standard"));
+        ShardingRuleConfiguration unconfiguredDefaultTableShardingAlgorithm = createValidRuleConfiguration();
+        unconfiguredDefaultTableShardingAlgorithm.setDefaultTableShardingStrategy(new ComplexShardingStrategyConfiguration("order_id,user_id", "bar_complex"));
+        ShardingRuleConfiguration unconfiguredTableAuditor = createValidRuleConfiguration();
+        unconfiguredTableAuditor.getTables().iterator().next().setAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+        ShardingRuleConfiguration unconfiguredAutoTableAuditor = createValidRuleConfiguration();
+        unconfiguredAutoTableAuditor.getAutoTables().iterator().next().setAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+        ShardingRuleConfiguration unconfiguredDefaultAuditor = createValidRuleConfiguration();
+        unconfiguredDefaultAuditor.setDefaultAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+        ShardingRuleConfiguration unconfiguredDefaultKeyGenerator = createValidRuleConfiguration();
+        unconfiguredDefaultKeyGenerator.setDefaultKeyGenerateStrategy(new KeyGenerateStrategyConfiguration("order_id", "bar_key_generator"));
+        ShardingRuleConfiguration unconfiguredKeyGenerateStrategiesKeyGenerator = createValidRuleConfiguration();
+        unconfiguredKeyGenerateStrategiesKeyGenerator.getKeyGenerateStrategies().put(
+                "bar_column", new ColumnKeyGenerateStrategiesRuleConfiguration("bar_key_generator", "foo_tbl", "order_id"));
+        ShardingRuleConfiguration unsupportedKeyGenerateStrategies = createValidRuleConfiguration();
+        unsupportedKeyGenerateStrategies.getKeyGenerateStrategies().put("bar_strategy", new UnsupportedKeyGenerateStrategiesConfiguration());
+        return Stream.of(
+                Arguments.of("Unconfigured table database sharding algorithm", unconfiguredTableDatabaseShardingAlgorithm),
+                Arguments.of("Unconfigured table sharding algorithm", unconfiguredTableShardingAlgorithm),
+                Arguments.of("Unconfigured auto table sharding algorithm", unconfiguredAutoTableShardingAlgorithm),
+                Arguments.of("Unconfigured default database sharding algorithm", unconfiguredDefaultDatabaseShardingAlgorithm),
+                Arguments.of("Unconfigured default table sharding algorithm", unconfiguredDefaultTableShardingAlgorithm),
+                Arguments.of("Unconfigured table auditor", unconfiguredTableAuditor),
+                Arguments.of("Unconfigured auto table auditor", unconfiguredAutoTableAuditor),
+                Arguments.of("Unconfigured default auditor", unconfiguredDefaultAuditor),
+                Arguments.of("Unconfigured default key generator", unconfiguredDefaultKeyGenerator),
+                Arguments.of("Unconfigured key generate strategies key generator", unconfiguredKeyGenerateStrategiesKeyGenerator),
+                Arguments.of("Unsupported key generate strategies type", unsupportedKeyGenerateStrategies));
+    }
+    
     private static ShardingAutoTableRuleConfiguration createValidAutoTableRuleConfiguration() {
         return createAutoTableRuleConfiguration("foo_auto_tbl", new HintShardingStrategyConfiguration("foo_hint"));
     }
@@ -282,4 +337,17 @@ class ShardingRuleConfigurationTest {
         result.getBindingTableGroups().add(tableGroupConfig);
         return result;
     }
+    
+    private static final class UnsupportedKeyGenerateStrategiesConfiguration implements KeyGenerateStrategiesConfiguration {
+        
+        @Override
+        public String getKeyGenerateType() {
+            return "unsupported";
+        }
+        
+        @Override
+        public String getKeyGeneratorName() {
+            return "foo_key_generator";
+        }
+    }
 }
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
similarity index 59%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
index 6fd6cf66cdf..1c628109da6 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
@@ -15,11 +15,23 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.sharding.api.config.fixture;
 
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
+import org.apache.shardingsphere.infra.algorithm.core.context.AlgorithmSQLContext;
+import org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm;
 
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Key generate algorithm fixture.
+ */
+public final class KeyGenerateAlgorithmFixture implements KeyGenerateAlgorithm {
+    
+    @Override
+    public Collection<? extends Comparable<?>> generateKeys(final AlgorithmSQLContext context, final int keyGenerateCount) {
+        return Collections.emptyList();
+    }
     
     @Override
     public String getType() {
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
similarity index 53%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
index 6fd6cf66cdf..85ee9f2c327 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
@@ -15,14 +15,26 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.sharding.api.config.fixture;
 
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
+import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm;
 
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
+import java.util.List;
+
+/**
+ * Sharding audit algorithm fixture.
+ */
+public final class ShardingAuditAlgorithmFixture implements ShardingAuditAlgorithm {
+    
+    @Override
+    public void check(final SQLStatementContext sqlStatementContext, final List<Object> params, final RuleMetaData globalRuleMetaData, final ShardingSphereDatabase database) {
+    }
     
     @Override
     public String getType() {
-        return "FIXTURE";
+        return "FIXTURE_AUDIT";
     }
 }
diff --git a/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm
new file mode 100644
index 00000000000..07c90ab314a
--- /dev/null
+++ b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.sharding.api.config.fixture.KeyGenerateAlgorithmFixture
diff --git a/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm
new file mode 100644
index 00000000000..d41c55060ec
--- /dev/null
+++ b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.sharding.api.config.fixture.ShardingAuditAlgorithmFixture
diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
index 552e122009a..bb53d75f9c6 100644
--- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
+++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
@@ -17,27 +17,16 @@
 
 package org.apache.shardingsphere.sharding.checker.config;
 
-import com.google.common.base.Joiner;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
-import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.datanode.DataNode;
 import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
 import org.apache.shardingsphere.infra.expr.entry.InlineExpressionParserFactory;
 import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
 import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
 import org.apache.shardingsphere.sharding.constant.ShardingOrder;
-import org.apache.shardingsphere.sharding.exception.metadata.MissingRequiredShardingConfigurationException;
 
 import javax.sql.DataSource;
 import java.util.Collection;
@@ -55,62 +44,7 @@ public final class ShardingRuleConfigurationChecker implements DatabaseRuleConfi
     
     @Override
     public void check(final String databaseName, final ShardingRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
-        Collection<String> keyGenerators = ruleConfig.getKeyGenerators().keySet();
-        Collection<String> auditors = ruleConfig.getAuditors().keySet();
-        Collection<String> shardingAlgorithms = ruleConfig.getShardingAlgorithms().keySet();
-        checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getAutoTables(), auditors, shardingAlgorithms);
-        checkKeyGenerateStrategy(databaseName, ruleConfig.getDefaultKeyGenerateStrategy(), keyGenerators);
-        checkKeyGenerateStrategies(databaseName, ruleConfig.getKeyGenerateStrategies().values(), keyGenerators);
-        checkAuditStrategy(databaseName, ruleConfig.getDefaultAuditStrategy(), auditors);
-        checkShardingStrategy(databaseName, ruleConfig.getDefaultDatabaseShardingStrategy(), shardingAlgorithms);
-        checkShardingStrategy(databaseName, ruleConfig.getDefaultTableShardingStrategy(), shardingAlgorithms);
-    }
-    
-    private void checkTables(final String databaseName, final Collection<ShardingTableRuleConfiguration> tables,
-                             final Collection<ShardingAutoTableRuleConfiguration> autoTables, final Collection<String> auditors, final Collection<String> shardingAlgorithms) {
-        for (ShardingTableRuleConfiguration each : tables) {
-            checkAuditStrategy(databaseName, each.getAuditStrategy(), auditors);
-            checkShardingStrategy(databaseName, each.getDatabaseShardingStrategy(), shardingAlgorithms);
-            checkShardingStrategy(databaseName, each.getTableShardingStrategy(), shardingAlgorithms);
-            checkDataNodeSchemas(each);
-        }
-        for (ShardingAutoTableRuleConfiguration each : autoTables) {
-            checkAuditStrategy(databaseName, each.getAuditStrategy(), auditors);
-            checkShardingStrategy(databaseName, each.getShardingStrategy(), shardingAlgorithms);
-        }
-    }
-    
-    private void checkKeyGenerateStrategy(final String databaseName, final KeyGenerateStrategyConfiguration keyGenerateStrategy, final Collection<String> keyGenerators) {
-        if (null == keyGenerateStrategy) {
-            return;
-        }
-        ShardingSpherePreconditions.checkContains(keyGenerators, keyGenerateStrategy.getKeyGeneratorName(),
-                () -> new UnregisteredAlgorithmException("Key generate", keyGenerateStrategy.getKeyGeneratorName(), new SQLExceptionIdentifier(databaseName)));
-    }
-    
-    private void checkAuditStrategy(final String databaseName, final ShardingAuditStrategyConfiguration auditStrategy, final Collection<String> auditors) {
-        if (null == auditStrategy) {
-            return;
-        }
-        ShardingSpherePreconditions.checkState(auditors.containsAll(auditStrategy.getAuditorNames()),
-                () -> new UnregisteredAlgorithmException("Sharding audit", Joiner.on(",").join(auditStrategy.getAuditorNames()), new SQLExceptionIdentifier(databaseName)));
-    }
-    
-    private void checkKeyGenerateStrategies(final String databaseName, final Collection<KeyGenerateStrategiesConfiguration> keyGenerateStrategies, final Collection<String> keyGenerators) {
-        for (KeyGenerateStrategiesConfiguration each : keyGenerateStrategies) {
-            ShardingSpherePreconditions.checkContains(keyGenerators, each.getKeyGeneratorName(),
-                    () -> new UnregisteredAlgorithmException("Key generate", each.getKeyGeneratorName(), new SQLExceptionIdentifier(databaseName)));
-            ShardingSpherePreconditions.checkState(each instanceof ColumnKeyGenerateStrategiesRuleConfiguration || each instanceof SequenceKeyGenerateStrategiesRuleConfiguration,
-                    () -> new MissingRequiredShardingConfigurationException("Key generate type should be column or sequence", databaseName));
-        }
-    }
-    
-    private void checkShardingStrategy(final String databaseName, final ShardingStrategyConfiguration shardingStrategy, final Collection<String> shardingAlgorithms) {
-        if (null == shardingStrategy || shardingStrategy instanceof NoneShardingStrategyConfiguration) {
-            return;
-        }
-        ShardingSpherePreconditions.checkContains(shardingAlgorithms, shardingStrategy.getShardingAlgorithmName(),
-                () -> new UnregisteredAlgorithmException("sharding", shardingStrategy.getShardingAlgorithmName(), new SQLExceptionIdentifier(databaseName)));
+        ruleConfig.getTables().forEach(this::checkDataNodeSchemas);
     }
     
     private void checkDataNodeSchemas(final ShardingTableRuleConfiguration tableRuleConfig) {
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
index 9439d2ebc8a..5c01f007431 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
@@ -17,23 +17,12 @@
 
 package org.apache.shardingsphere.sharding.checker.config;
 
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
-import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
 import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
 import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
 import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -44,7 +33,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedHashSet;
-import java.util.Properties;
 import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -62,18 +50,6 @@ class ShardingRuleConfigurationCheckerTest {
                 DatabaseRuleConfigurationChecker.class, Collections.singleton(ShardingRuleConfiguration.class)).get(ShardingRuleConfiguration.class);
     }
     
-    @Test
-    void assertCheckSuccess() {
-        ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
-        ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
-        ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
-        ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
-        ruleConfig.getKeyGenerateStrategies().put("foo_column_strategy", createColumnKeyGenerateStrategyRuleConfiguration("foo_keygen"));
-        ruleConfig.getKeyGenerateStrategies().put("foo_sequence_strategy", createSequenceKeyGenerateStrategyRuleConfiguration("foo_keygen"));
-        assertDoesNotThrow(() -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
     @Test
     void assertCheckWithMultipleSchemasForSameDataSource() {
         ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
@@ -106,95 +82,23 @@ class ShardingRuleConfigurationCheckerTest {
                         new ShardingTableRuleConfiguration("bar_tbl", "ds_0.bar_schema.bar_tbl_0"))));
     }
     
-    @Test
-    void assertCheckKeyGenerateStrategiesFailed() {
-        ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ruleConfig.getKeyGenerateStrategies().put("foo_sequence_strategy", createSequenceKeyGenerateStrategyRuleConfiguration("bar_keygen"));
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    @Test
-    void assertCheckKeyGenerateStrategiesWithUnregisteredKeyGeneratorFailed() {
-        ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ruleConfig.getKeyGenerateStrategies().put("bar_tbl_foo_col", new ColumnKeyGenerateStrategiesRuleConfiguration("bar_keygen", "bar_tbl", "foo_col"));
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    @Test
-    void assertCheckAuditStrategyFailed() {
-        ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
-        ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, null)));
-        ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig,
-                new ShardingAuditStrategyConfiguration(Collections.singleton("bar_audit"), false))));
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
-    @Test
-    void assertCheckShardingStrategyFailedWithUnregisteredAlgorithm() {
-        ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
-        ruleConfig.setTables(Collections.singleton(
-                createShardingTableRuleConfiguration(new NoneShardingStrategyConfiguration(), shardingAuditStrategyConfig)));
-        ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(
-                new StandardShardingStrategyConfiguration("foo_col", "bar_algorithm"), shardingAuditStrategyConfig)));
-        assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
-    }
-    
     @Test
     void assertGetRequiredDataSourceNames() {
         ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
-        ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
-        ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
-        ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
+        ruleConfig.setTables(Collections.singleton(new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl")));
+        ruleConfig.setAutoTables(Collections.singleton(new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1")));
         assertThat(checker.getRequiredDataSourceNames(ruleConfig), is(new LinkedHashSet<>(Arrays.asList("ds_0", "ds_1"))));
     }
     
     @Test
     void assertGetTableNames() {
         ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
-        ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
-        ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
-        ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
-        ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
+        ruleConfig.setTables(Collections.singleton(new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl")));
+        ruleConfig.setAutoTables(Collections.singleton(new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1")));
         assertThat(checker.getTableNames(ruleConfig), is(Arrays.asList("foo_tbl", "bar_tbl")));
     }
     
     private ShardingRuleConfiguration createRuleConfiguration() {
-        ShardingRuleConfiguration result = new ShardingRuleConfiguration();
-        result.getShardingAlgorithms().put("foo_algorithm", new AlgorithmConfiguration("MOD", PropertiesBuilder.build(new Property("sharding-count", "1"))));
-        result.getAuditors().put("foo_audit", new AlgorithmConfiguration("foo", new Properties()));
-        result.getKeyGenerators().put("foo_keygen", new AlgorithmConfiguration("UUID", new Properties()));
-        return result;
-    }
-    
-    private ShardingStrategyConfiguration createShardingStrategyConfiguration() {
-        return new StandardShardingStrategyConfiguration("foo_col", "foo_algorithm");
-    }
-    
-    private ShardingTableRuleConfiguration createShardingTableRuleConfiguration(final ShardingStrategyConfiguration shardingStrategyConfig,
-                                                                                final ShardingAuditStrategyConfiguration shardingAuditStrategyConfig) {
-        ShardingTableRuleConfiguration result = new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl");
-        result.setDatabaseShardingStrategy(shardingStrategyConfig);
-        result.setTableShardingStrategy(shardingStrategyConfig);
-        result.setAuditStrategy(shardingAuditStrategyConfig);
-        return result;
-    }
-    
-    private ShardingAutoTableRuleConfiguration createShardingAutoTableRuleConfiguration(final ShardingStrategyConfiguration shardingStrategyConfig,
-                                                                                        final ShardingAuditStrategyConfiguration shardingAuditStrategyConfig) {
-        ShardingAutoTableRuleConfiguration result = new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1");
-        result.setShardingStrategy(shardingStrategyConfig);
-        result.setAuditStrategy(shardingAuditStrategyConfig);
-        return result;
-    }
-    
-    private KeyGenerateStrategiesConfiguration createColumnKeyGenerateStrategyRuleConfiguration(final String keyGeneratorName) {
-        return new ColumnKeyGenerateStrategiesRuleConfiguration(keyGeneratorName, "foo_tbl", "foo_col");
-    }
-    
-    private KeyGenerateStrategiesConfiguration createSequenceKeyGenerateStrategyRuleConfiguration(final String keyGeneratorName) {
-        return new SequenceKeyGenerateStrategiesRuleConfiguration(keyGeneratorName, "foo_sequence");
+        return new ShardingRuleConfiguration();
     }
 }
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
index a366f72ea71..9eb08406138 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
@@ -43,7 +43,8 @@ public interface DatabaseRuleConfigurationChecker<T extends RuleConfiguration> e
      * @param dataSourceMap data sources to be checked
      * @param builtRules built rules
      */
-    void check(String databaseName, T ruleConfig, Map<String, DataSource> dataSourceMap, Collection<ShardingSphereRule> builtRules);
+    default void check(final String databaseName, final T ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
+    }
     
     /**
      * Get required data source names.
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
index 7f24c58538e..ff155356d68 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.bval.jsr.ApacheValidationProvider;
 import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.RuleConfigurationValidationException;
@@ -29,6 +30,7 @@ import javax.validation.ConstraintViolation;
 import javax.validation.Validation;
 import javax.validation.ValidationException;
 import javax.validation.Validator;
+import javax.validation.groups.Default;
 import java.util.Collection;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -62,9 +64,14 @@ public final class RuleConfigurationValidator {
     }
     
     private static void validate(final Object config, final String ruleType) {
+        validate(config, ruleType, Default.class);
+        validate(config, ruleType, RuleConfigurationTypeValidationGroup.class);
+    }
+    
+    private static void validate(final Object config, final String ruleType, final Class<?> group) {
         Set<ConstraintViolation<Object>> violations;
         try {
-            violations = VALIDATOR.validate(config);
+            violations = VALIDATOR.validate(config, group);
         } catch (final ValidationException ex) {
             throw new RuleConfigurationValidationException(ruleType, ex);
         }
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
similarity index 74%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
index 6fd6cf66cdf..089ec43445c 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
@@ -15,14 +15,10 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.infra.config.rule.validator.group;
 
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
-
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
-    
-    @Override
-    public String getType() {
-        return "FIXTURE";
-    }
+/**
+ * Rule configuration type validation group.
+ */
+public interface RuleConfigurationTypeValidationGroup {
 }
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java
new file mode 100644
index 00000000000..932651dc814
--- /dev/null
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java
@@ -0,0 +1,46 @@
+/*
+ * 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.infra.config.rule.checker;
+
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+class DatabaseRuleConfigurationCheckerTest {
+    
+    @Test
+    void assertCheck() {
+        DatabaseRuleConfigurationChecker<RuleConfiguration> checker = new DatabaseRuleConfigurationChecker<RuleConfiguration>() {
+            
+            @Override
+            public int getOrder() {
+                return 0;
+            }
+            
+            @Override
+            public Class<RuleConfiguration> getTypeClass() {
+                return RuleConfiguration.class;
+            }
+        };
+        assertDoesNotThrow(() -> checker.check("foo_db", new RuleConfiguration() {
+        }, Collections.emptyMap(), Collections.emptyList()));
+    }
+}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
index c7cc95f5fdf..bbc15961262 100644
--- a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
@@ -21,6 +21,8 @@ import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
 import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.fixture.ValidRuleConfigurationTypeFixture;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.RuleConfigurationValidationException;
@@ -37,6 +39,7 @@ import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.isA;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class RuleConfigurationValidatorTest {
@@ -81,6 +84,21 @@ class RuleConfigurationValidatorTest {
         assertThat(actualSQLException.getErrorCode(), is(10205));
     }
     
+    @Test
+    void assertValidateDefaultGroupBeforeTypeGroup() {
+        InvalidRuleConfigurationException actual = assertThrows(InvalidRuleConfigurationException.class,
+                () -> RuleConfigurationValidator.validate(new TypeValidationFixtureRuleConfiguration("")));
+        assertThat(actual.getMessage(), containsString("Property `name`"));
+        assertFalse(actual.getMessage().contains("contains invalid type configuration"));
+    }
+    
+    @Test
+    void assertValidateTypeGroup() {
+        InvalidRuleConfigurationException actual = assertThrows(InvalidRuleConfigurationException.class,
+                () -> RuleConfigurationValidator.validate(new TypeValidationFixtureRuleConfiguration("fixture")));
+        assertThat(actual.getMessage(), containsString("contains invalid type configuration"));
+    }
+    
     @Getter
     private static final class FixtureRuleConfiguration implements RuleConfiguration {
         
@@ -106,4 +124,13 @@ class RuleConfigurationValidatorTest {
         @SPITypeExists(spiClassName = "org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.fixture.MissingSPITypeFixture")
         private final String type = "FIXTURE";
     }
+    
+    @RequiredArgsConstructor
+    @Getter
+    @ValidRuleConfigurationTypeFixture(groups = RuleConfigurationTypeValidationGroup.class)
+    private static final class TypeValidationFixtureRuleConfiguration implements RuleConfiguration {
+        
+        @NotBlank
+        private final String name;
+    }
 }
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java
new file mode 100644
index 00000000000..5e21b855a93
--- /dev/null
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java
@@ -0,0 +1,70 @@
+/*
+ * 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.infra.config.rule.validator.fixture;
+
+import javax.validation.Constraint;
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid rule configuration type fixture constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ValidRuleConfigurationTypeFixture.Validator.class)
+@Documented
+public @interface ValidRuleConfigurationTypeFixture {
+    
+    /**
+     * Get message.
+     *
+     * @return message
+     */
+    String message() default "contains invalid type configuration";
+    
+    /**
+     * Get groups.
+     *
+     * @return groups
+     */
+    Class<?>[] groups() default {};
+    
+    /**
+     * Get payload.
+     *
+     * @return payload
+     */
+    Class<? extends Payload>[] payload() default {};
+    
+    /**
+     * Valid rule configuration type fixture validator.
+     */
+    final class Validator implements ConstraintValidator<ValidRuleConfigurationTypeFixture, Object> {
+        
+        @Override
+        public boolean isValid(final Object value, final ConstraintValidatorContext context) {
+            return false;
+        }
+    }
+}
diff --git a/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java b/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
index 868826f8612..23bf95e0dc3 100644
--- a/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
+++ b/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.timeservice.config;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.infra.config.rule.scope.GlobalRuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
 
 import javax.validation.constraints.NotBlank;
 import java.util.Properties;
@@ -32,6 +33,7 @@ import java.util.Properties;
 public final class TimestampServiceRuleConfiguration implements GlobalRuleConfiguration {
     
     @NotBlank
+    @SPITypeExists(spiClassName = "org.apache.shardingsphere.timeservice.spi.TimestampService")
     private final String type;
     
     private final Properties props;
diff --git a/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
index a40c6f261c2..db59b11b743 100644
--- a/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
+++ b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
@@ -39,8 +39,8 @@ class TimestampServiceRuleConfigurationTest {
     
     private static Stream<Arguments> validRuleConfigurationArguments() {
         return Stream.of(
-                Arguments.of("Null properties", new TimestampServiceRuleConfiguration("System", null)),
-                Arguments.of("Empty properties", new TimestampServiceRuleConfiguration("System", new Properties())));
+                Arguments.of("Null properties", new TimestampServiceRuleConfiguration("FIXTURE", null)),
+                Arguments.of("Empty properties", new TimestampServiceRuleConfiguration("FIXTURE", new Properties())));
     }
     
     @ParameterizedTest(name = "{0}")
@@ -53,6 +53,7 @@ class TimestampServiceRuleConfigurationTest {
         return Stream.of(
                 Arguments.of("Null type", new TimestampServiceRuleConfiguration(null, null)),
                 Arguments.of("Empty type", new TimestampServiceRuleConfiguration("", null)),
-                Arguments.of("Blank type", new TimestampServiceRuleConfiguration(" ", null)));
+                Arguments.of("Blank type", new TimestampServiceRuleConfiguration(" ", null)),
+                Arguments.of("Missing type", new TimestampServiceRuleConfiguration("MISSING", null)));
     }
 }
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
similarity index 56%
rename from features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java
rename to kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
index 31a73f9f9dd..8190c2a8f6a 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java
+++ b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
@@ -15,19 +15,24 @@
  * limitations under the License.
  */
 
-package org.apache.shardingsphere.shadow.exception.metadata;
+package org.apache.shardingsphere.timeservice.config.fixture;
 
-import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
-import org.apache.shardingsphere.shadow.exception.ShadowSQLException;
+import org.apache.shardingsphere.timeservice.spi.TimestampService;
+
+import java.sql.Timestamp;
 
 /**
- * Shadow data source mapping not found exception.
+ * Timestamp service fixture.
  */
-public final class ShadowDataSourceMappingNotFoundException extends ShadowSQLException {
+public final class TimestampServiceFixture implements TimestampService {
     
-    private static final long serialVersionUID = 4141501883104032467L;
+    @Override
+    public Timestamp getTimestamp() {
+        return new Timestamp(0L);
+    }
     
-    public ShadowDataSourceMappingNotFoundException(final String tableName) {
-        super(XOpenSQLState.NOT_FOUND, 2, "No available shadow data sources mappings in shadow table '%s'.", tableName);
+    @Override
+    public String getType() {
+        return "FIXTURE";
     }
 }
diff --git a/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService b/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService
new file mode 100644
index 00000000000..30e25fe2dc6
--- /dev/null
+++ b/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.timeservice.config.fixture.TimestampServiceFixture
diff --git a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
index 5392e36289d..c88a97f2396 100644
--- a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
+++ b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
@@ -21,6 +21,7 @@ import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.infra.config.rule.scope.GlobalRuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.transaction.config.validator.ValidTransactionProviderType;
 
 import javax.validation.constraints.NotBlank;
@@ -30,7 +31,7 @@ import java.util.Properties;
 /**
  * Transaction rule configuration.
  */
-@ValidTransactionProviderType
+@ValidTransactionProviderType(groups = RuleConfigurationTypeValidationGroup.class)
 @RequiredArgsConstructor
 @Getter
 @EqualsAndHashCode
diff --git a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
index 1accb35fd9a..62b6abd1be3 100644
--- a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
+++ b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
@@ -32,7 +32,7 @@ public final class TransactionProviderTypeValidator implements ConstraintValidat
     
     @Override
     public boolean isValid(final TransactionRuleConfiguration value, final ConstraintValidatorContext context) {
-        if (null == value || !TransactionType.XA.name().equalsIgnoreCase(value.getDefaultType())) {
+        if (!TransactionType.XA.name().equalsIgnoreCase(value.getDefaultType())) {
             return true;
         }
         if (containsProviderType(value.getProviderType())) {
diff --git a/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java b/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
index 73500078aef..98f41d2f550 100644
--- a/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
+++ b/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.transaction.config;
 
 import org.apache.bval.jsr.ApacheValidationProvider;
 import org.apache.shardingsphere.infra.config.rule.validator.RuleConfigurationValidator;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
 import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -65,7 +66,8 @@ class TransactionRuleConfigurationTest {
     
     @Test
     void assertInvalidProviderTypePropertyPath() {
-        Collection<ConstraintViolation<TransactionRuleConfiguration>> actual = VALIDATOR.validate(new TransactionRuleConfiguration("XA", "MISSING", null));
+        Collection<ConstraintViolation<TransactionRuleConfiguration>> actual = VALIDATOR.validate(
+                new TransactionRuleConfiguration("XA", "MISSING", null), RuleConfigurationTypeValidationGroup.class);
         assertThat(actual.iterator().next().getPropertyPath().toString(), is("providerType"));
     }
 }
diff --git a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
index 73c88a04a1d..7507140c8c9 100644
--- a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
+++ b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
@@ -31,10 +31,7 @@ public final class MCPLaunchConfigurationValidator implements ConstraintValidato
     
     @Override
     public boolean isValid(final YamlMCPLaunchConfiguration value, final ConstraintValidatorContext context) {
-        if (null == value || null == value.getTransport()) {
-            return true;
-        }
-        return isValid(value.getTransport(), context);
+        return null == value || null == value.getTransport() || isValid(value.getTransport(), context);
     }
     
     private boolean isValid(final YamlMCPTransportConfiguration value, final ConstraintValidatorContext context) {
diff --git a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
index 4217242e5aa..b53bc93a28f 100644
--- a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
+++ b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
@@ -36,12 +36,7 @@ public final class UniqueMCPPromptArgumentNamesValidator implements ConstraintVa
             return true;
         }
         Set<String> names = new HashSet<>(value.size(), 1F);
-        for (Object each : value) {
-            YamlMCPPromptArgumentDescriptor argument = (YamlMCPPromptArgumentDescriptor) each;
-            if (null != argument && null != argument.getName() && !argument.getName().isBlank() && !names.add(argument.getName())) {
-                return false;
-            }
-        }
-        return true;
+        return value.stream().map(each -> (YamlMCPPromptArgumentDescriptor) each)
+                .noneMatch(argument -> null != argument && null != argument.getName() && !argument.getName().isBlank() && !names.add(argument.getName()));
     }
 }