diff --git a/dubbo-bootstrap/src/main/java/org/apache/dubbo/bootstrap/DubboBootstrap.java b/dubbo-bootstrap/src/main/java/org/apache/dubbo/bootstrap/DubboBootstrap.java
index 4f1daa16b5e..9de48a63218 100644
--- a/dubbo-bootstrap/src/main/java/org/apache/dubbo/bootstrap/DubboBootstrap.java
+++ b/dubbo-bootstrap/src/main/java/org/apache/dubbo/bootstrap/DubboBootstrap.java
@@ -51,9 +51,7 @@
 import org.apache.dubbo.config.utils.ReferenceConfigCache;
 import org.apache.dubbo.event.EventDispatcher;
 import org.apache.dubbo.event.EventListener;
-import org.apache.dubbo.metadata.WritableMetadataService;
 import org.apache.dubbo.metadata.report.MetadataReportInstance;
-import org.apache.dubbo.metadata.store.RemoteWritableMetadataService;
 import org.apache.dubbo.registry.client.AbstractServiceDiscoveryFactory;
 import org.apache.dubbo.registry.client.DefaultServiceInstance;
 import org.apache.dubbo.registry.client.ServiceDiscovery;
@@ -517,7 +515,7 @@ public DubboBootstrap start() {
             exportServices();
 
             // Not only provider register and some services are exported
-            if (!onlyRegisterProvider && !configManager.getServiceConfigs().isEmpty()) {
+            if (!onlyRegisterProvider && !configManager.getServices().isEmpty()) {
                 /**
                  * export {@link MetadataService}
                  */
@@ -718,7 +716,7 @@ private List<URL> exportMetadataService(ApplicationConfig applicationConfig,
     }
 
     private void exportServices() {
-        configManager.getServiceConfigs().forEach(this::exportServiceConfig);
+        configManager.getServices().forEach(this::exportServiceConfig);
     }
 
     public void exportServiceConfig(ServiceConfig<?> serviceConfig) {
@@ -729,7 +727,7 @@ private void referServices() {
         if (cache == null) {
             cache = ReferenceConfigCache.getCache();
         }
-        configManager.getReferenceConfigs().forEach(cache::get);
+        configManager.getReferences().forEach(cache::get);
     }
 
     public boolean isOnlyRegisterProvider() {
@@ -816,7 +814,7 @@ private void destroyProtocolConfigs() {
     }
 
     private void destroyReferenceConfigs() {
-        configManager.getReferenceConfigs().forEach(ReferenceConfig::destroy);
+        configManager.getReferences().forEach(ReferenceConfig::destroy);
         if (logger.isDebugEnabled()) {
             logger.debug(NAME + "'s all ReferenceConfigs have been destroyed.");
         }
diff --git a/dubbo-bootstrap/src/test/java/org/apache/dubbo/bootstrap/DubboServiceConsumerBootstrap.java b/dubbo-bootstrap/src/test/java/org/apache/dubbo/bootstrap/DubboServiceConsumerBootstrap.java
index 0f7a958f021..760fbdcd1fd 100644
--- a/dubbo-bootstrap/src/test/java/org/apache/dubbo/bootstrap/DubboServiceConsumerBootstrap.java
+++ b/dubbo-bootstrap/src/test/java/org/apache/dubbo/bootstrap/DubboServiceConsumerBootstrap.java
@@ -41,7 +41,7 @@ public static void main(String[] args) throws Exception {
 
         ConfigManager configManager = ConfigManager.getInstance();
 
-        ReferenceConfig<EchoService> referenceConfig = configManager.getReferenceConfig("ref");
+        ReferenceConfig<EchoService> referenceConfig = configManager.getReference("ref");
 
         EchoService echoService = referenceConfig.get();
 
diff --git a/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/AbstractConfig.java b/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/AbstractConfig.java
index c1a7548585d..d729644992c 100644
--- a/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/AbstractConfig.java
+++ b/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/AbstractConfig.java
@@ -40,6 +40,7 @@
 import java.lang.reflect.Modifier;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -638,7 +639,7 @@ public boolean equals(Object obj) {
                     Method method2 = obj.getClass().getMethod(method1.getName(), method1.getParameterTypes());
                     Object value1 = method1.invoke(this, new Object[]{});
                     Object value2 = method2.invoke(obj, new Object[]{});
-                    if ((value1 != null && value2 != null) && !value1.equals(value2)) {
+                    if (!Objects.equals(value1, value2)) {
                         return false;
                     }
                 } catch (Exception e) {
diff --git a/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/context/ConfigManager.java b/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/context/ConfigManager.java
index 0e4d610d394..69967409a8f 100644
--- a/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/context/ConfigManager.java
+++ b/dubbo-config/dubbo-config-api/src/main/java/org/apache/dubbo/config/context/ConfigManager.java
@@ -117,56 +117,6 @@ public Optional<ApplicationConfig> getApplication() {
         return ofNullable(getConfig(ApplicationConfig.class));
     }
 
-    /**
-     * Add the dubbo {@link AbstractConfig config}
-     *
-     * @param config the dubbo {@link AbstractConfig config}
-     */
-    public void addConfig(AbstractConfig config) {
-        addConfig(config, false);
-    }
-
-    protected void addConfig(AbstractConfig config, boolean unique) {
-        if (config == null) {
-            return;
-        }
-        Class<? extends AbstractConfig> configType = config.getClass();
-        write(() -> {
-            Map<String, AbstractConfig> configsMap = configsCache.computeIfAbsent(configType, type -> newMap());
-            addIfAbsent(config, configsMap, unique);
-        });
-    }
-
-    protected <C extends AbstractConfig> Map<String, C> getConfigsMap(Class<? extends C> configType) {
-        return read(() -> (Map) configsCache.getOrDefault(configType, emptyMap()));
-    }
-
-    protected <C extends AbstractConfig> Collection<C> getConfigs(Class<C> configType) {
-        return read(() -> getConfigsMap(configType).values());
-    }
-
-    protected <C extends AbstractConfig> C getConfig(Class<C> configType, String id) {
-        return read(() -> {
-            Map<String, C> configsMap = (Map) configsCache.getOrDefault(configType, emptyMap());
-            return configsMap.get(id);
-        });
-    }
-
-    protected <C extends AbstractConfig> C getConfig(Class<C> configType) throws IllegalStateException {
-        return read(() -> {
-            Map<String, C> configsMap = (Map) configsCache.getOrDefault(configType, emptyMap());
-            int size = configsMap.size();
-            if (size < 1) {
-//                throw new IllegalStateException("No such " + configType.getName() + " is found");
-                return null;
-            } else if (size > 1) {
-                throw new IllegalStateException("The expected single matching " + configType.getName() + " but found " + size + " instances");
-            } else {
-                return configsMap.values().iterator().next();
-            }
-        });
-    }
-
     // MonitorConfig correlative methods
 
     public void setMonitor(MonitorConfig monitor) {
@@ -181,7 +131,6 @@ public Optional<MonitorConfig> getMonitor() {
 
     public void setModule(ModuleConfig module) {
         addConfig(module, true);
-
     }
 
     public Optional<ModuleConfig> getModule() {
@@ -234,6 +183,10 @@ public void addProvider(ProviderConfig providerConfig) {
         addConfig(providerConfig);
     }
 
+    public void addProviders(Iterable<ProviderConfig> providerConfigs) {
+        providerConfigs.forEach(this::addProvider);
+    }
+
     public Optional<ProviderConfig> getProvider(String id) {
         return ofNullable(getConfig(ProviderConfig.class, id));
     }
@@ -252,6 +205,10 @@ public void addConsumer(ConsumerConfig consumerConfig) {
         addConfig(consumerConfig);
     }
 
+    public void addConsumers(Iterable<ConsumerConfig> consumerConfigs) {
+        consumerConfigs.forEach(this::addConsumer);
+    }
+
     public Optional<ConsumerConfig> getConsumer(String id) {
         return ofNullable(getConfig(ConsumerConfig.class, id));
     }
@@ -341,11 +298,15 @@ public void addService(ServiceConfig<?> serviceConfig) {
         addConfig(serviceConfig);
     }
 
-    public Collection<ServiceConfig> getServiceConfigs() {
+    public void addServices(Iterable<ServiceConfig<?>> serviceConfigs) {
+        serviceConfigs.forEach(this::addService);
+    }
+
+    public Collection<ServiceConfig> getServices() {
         return getConfigs(ServiceConfig.class);
     }
 
-    public <T> ServiceConfig<T> getServiceConfig(String id) {
+    public <T> ServiceConfig<T> getService(String id) {
         return getConfig(ServiceConfig.class, id);
     }
 
@@ -355,11 +316,15 @@ public void addReference(ReferenceConfig<?> referenceConfig) {
         addConfig(referenceConfig);
     }
 
-    public Collection<ReferenceConfig> getReferenceConfigs() {
+    public void addReferences(Iterable<ReferenceConfig<?>> referenceConfigs) {
+        referenceConfigs.forEach(this::addReference);
+    }
+
+    public Collection<ReferenceConfig> getReferences() {
         return getConfigs(ReferenceConfig.class);
     }
 
-    public <T> ReferenceConfig<T> getReferenceConfig(String id) {
+    public <T> ReferenceConfig<T> getReference(String id) {
         return getConfig(ReferenceConfig.class, id);
     }
 
@@ -393,7 +358,57 @@ public void clear() {
         });
     }
 
-    private <C extends AbstractConfig> Collection<String> getConfigIds(Class<C> configType) {
+    /**
+     * Add the dubbo {@link AbstractConfig config}
+     *
+     * @param config the dubbo {@link AbstractConfig config}
+     */
+    public void addConfig(AbstractConfig config) {
+        addConfig(config, false);
+    }
+
+    protected void addConfig(AbstractConfig config, boolean unique) {
+        if (config == null) {
+            return;
+        }
+        Class<? extends AbstractConfig> configType = config.getClass();
+        write(() -> {
+            Map<String, AbstractConfig> configsMap = configsCache.computeIfAbsent(configType, type -> newMap());
+            addIfAbsent(config, configsMap, unique);
+        });
+    }
+
+    protected <C extends AbstractConfig> Map<String, C> getConfigsMap(Class<? extends C> configType) {
+        return read(() -> (Map) configsCache.getOrDefault(configType, emptyMap()));
+    }
+
+    protected <C extends AbstractConfig> Collection<C> getConfigs(Class<C> configType) {
+        return read(() -> getConfigsMap(configType).values());
+    }
+
+    protected <C extends AbstractConfig> C getConfig(Class<C> configType, String id) {
+        return read(() -> {
+            Map<String, C> configsMap = (Map) configsCache.getOrDefault(configType, emptyMap());
+            return configsMap.get(id);
+        });
+    }
+
+    protected <C extends AbstractConfig> C getConfig(Class<C> configType) throws IllegalStateException {
+        return read(() -> {
+            Map<String, C> configsMap = (Map) configsCache.getOrDefault(configType, emptyMap());
+            int size = configsMap.size();
+            if (size < 1) {
+//                throw new IllegalStateException("No such " + configType.getName() + " is found");
+                return null;
+            } else if (size > 1) {
+                throw new IllegalStateException("The expected single matching " + configType.getName() + " but found " + size + " instances");
+            } else {
+                return configsMap.values().iterator().next();
+            }
+        });
+    }
+
+    protected <C extends AbstractConfig> Collection<String> getConfigIds(Class<C> configType) {
         return getConfigs(configType)
                 .stream()
                 .map(AbstractConfig::getId)
@@ -406,8 +421,10 @@ private <V> V write(Callable<V> callable) {
         try {
             writeLock.lock();
             value = callable.call();
+        } catch (RuntimeException e) {
+            throw e;
         } catch (Throwable e) {
-            throw new RuntimeException(e);
+            throw new RuntimeException(e.getCause());
         } finally {
             writeLock.unlock();
         }
@@ -421,12 +438,9 @@ private void write(Runnable runnable) {
         });
     }
 
-
     private <V> V read(Callable<V> callable) {
         Lock readLock = lock.readLock();
-
         V value = null;
-
         try {
             readLock.lock();
             value = callable.call();
@@ -435,7 +449,6 @@ private <V> V read(Callable<V> callable) {
         } finally {
             readLock.unlock();
         }
-
         return value;
     }
 
diff --git a/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/context/ConfigManagerTest.java b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/context/ConfigManagerTest.java
index 44e896d517d..41f5f3b83e2 100644
--- a/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/context/ConfigManagerTest.java
+++ b/dubbo-config/dubbo-config-api/src/test/java/org/apache/dubbo/config/context/ConfigManagerTest.java
@@ -17,15 +17,28 @@
 package org.apache.dubbo.config.context;
 
 import org.apache.dubbo.config.ApplicationConfig;
+import org.apache.dubbo.config.ConfigCenterConfig;
+import org.apache.dubbo.config.ConsumerConfig;
+import org.apache.dubbo.config.MetricsConfig;
 import org.apache.dubbo.config.ModuleConfig;
 import org.apache.dubbo.config.MonitorConfig;
+import org.apache.dubbo.config.ProtocolConfig;
+import org.apache.dubbo.config.ProviderConfig;
+import org.apache.dubbo.config.ReferenceConfig;
+import org.apache.dubbo.config.RegistryConfig;
+import org.apache.dubbo.config.ServiceConfig;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import java.util.Collection;
+
+import static java.util.Arrays.asList;
+import static org.apache.dubbo.common.constants.CommonConstants.DEFAULT_KEY;
 import static org.apache.dubbo.config.context.ConfigManager.getInstance;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
@@ -40,32 +53,197 @@ public class ConfigManagerTest {
     @BeforeEach
     public void init() {
         configManager.clear();
+    }
+
+    @Test
+    public void testDefaultValues() {
+        // assert single
         assertFalse(configManager.getApplication().isPresent());
         assertFalse(configManager.getMonitor().isPresent());
-        assertFalse(configManager.getMonitor().isPresent());
+        assertFalse(configManager.getModule().isPresent());
+        assertFalse(configManager.getMetrics().isPresent());
+
+        // providers and consumers
+        assertFalse(configManager.getDefaultProvider().isPresent());
+        assertFalse(configManager.getDefaultConsumer().isPresent());
+        assertTrue(configManager.getProviders().isEmpty());
+        assertTrue(configManager.getConsumers().isEmpty());
+
+        // protocols
+        assertTrue(configManager.getProtocols().isEmpty());
+        assertTrue(configManager.getDefaultProtocols().isEmpty());
+        assertTrue(configManager.getProtocolIds().isEmpty());
+
+        // registries
+        assertTrue(configManager.getRegistries().isEmpty());
+        assertTrue(configManager.getDefaultRegistries().isEmpty());
+        assertTrue(configManager.getRegistryIds().isEmpty());
+
+        // services and references
+        assertTrue(configManager.getServices().isEmpty());
+        assertTrue(configManager.getReferences().isEmpty());
+
+        // config centers
+        assertTrue(configManager.getConfigCenters().isEmpty());
+
+        // metadata
+        assertTrue(configManager.getMetadataConfigs().isEmpty());
     }
 
+    // Test ApplicationConfig correlative methods
     @Test
     public void testApplicationConfig() {
-        ApplicationConfig applicationConfig = new ApplicationConfig();
-        configManager.setApplication(applicationConfig);
+        ApplicationConfig config = new ApplicationConfig();
+        configManager.setApplication(config);
         assertTrue(configManager.getApplication().isPresent());
-        assertEquals(applicationConfig, configManager.getApplication().get());
+        assertEquals(config, configManager.getApplication().get());
+        assertThrows(IllegalStateException.class, () -> {
+            configManager.setApplication(new ApplicationConfig("test"));
+        });
     }
 
+    // Test MonitorConfig correlative methods
     @Test
     public void testMonitorConfig() {
         MonitorConfig monitorConfig = new MonitorConfig();
+        monitorConfig.setGroup("test");
         configManager.setMonitor(monitorConfig);
         assertTrue(configManager.getMonitor().isPresent());
         assertEquals(monitorConfig, configManager.getMonitor().get());
+        assertThrows(IllegalStateException.class, () -> {
+            configManager.setMonitor(new MonitorConfig());
+        });
     }
 
+    // Test MonitorConfig correlative methods
     @Test
     public void tesModuleConfig() {
         ModuleConfig config = new ModuleConfig();
         configManager.setModule(config);
         assertTrue(configManager.getModule().isPresent());
         assertEquals(config, configManager.getModule().get());
+        assertThrows(IllegalStateException.class, () -> {
+            configManager.setModule(new ModuleConfig("test"));
+        });
+    }
+
+    // Test MetricsConfig correlative methods
+    @Test
+    public void tesMetricsConfig() {
+        MetricsConfig config = new MetricsConfig();
+        configManager.setMetrics(config);
+        assertTrue(configManager.getMetrics().isPresent());
+        assertEquals(config, configManager.getMetrics().get());
+        assertThrows(IllegalStateException.class, () -> {
+            MetricsConfig metricsConfig = new MetricsConfig();
+            metricsConfig.setPort("101");
+            configManager.setMetrics(metricsConfig);
+        });
+    }
+
+    // Test ProviderConfig correlative methods
+    @Test
+    public void testProviderConfig() {
+        ProviderConfig config = new ProviderConfig();
+        configManager.addProviders(asList(config, null));
+        Collection<ProviderConfig> configs = configManager.getProviders();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertFalse(configManager.getDefaultProvider().isPresent());
+
+        config.setId(DEFAULT_KEY);
+        configManager.addProvider(config);
+        assertTrue(configManager.getDefaultProvider().isPresent());
+        configs = configManager.getProviders();
+        assertEquals(2, configs.size());
+    }
+
+    // Test ConsumerConfig correlative methods
+    @Test
+    public void testConsumerConfig() {
+        ConsumerConfig config = new ConsumerConfig();
+        configManager.addConsumers(asList(config, null));
+        Collection<ConsumerConfig> configs = configManager.getConsumers();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertFalse(configManager.getDefaultConsumer().isPresent());
+
+        config.setId(DEFAULT_KEY);
+        configManager.addConsumer(config);
+        assertTrue(configManager.getDefaultConsumer().isPresent());
+        configs = configManager.getConsumers();
+        assertEquals(2, configs.size());
+    }
+
+    // Test ProtocolConfig correlative methods
+    @Test
+    public void testProtocolConfig() {
+        ProtocolConfig config = new ProtocolConfig();
+        configManager.addProtocols(asList(config, null));
+        Collection<ProtocolConfig> configs = configManager.getProtocols();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertFalse(configManager.getDefaultProtocols().isEmpty());
+    }
+
+    // Test RegistryConfig correlative methods
+    @Test
+    public void testRegistryConfig() {
+        RegistryConfig config = new RegistryConfig();
+        configManager.addRegistries(asList(config, null));
+        Collection<RegistryConfig> configs = configManager.getRegistries();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertFalse(configManager.getDefaultRegistries().isEmpty());
+    }
+
+    // Test ServiceConfig correlative methods
+    @Test
+    public void testServiceConfig() {
+        ServiceConfig config = new ServiceConfig();
+        config.setId("test");
+        configManager.addServices(asList(config, null));
+        Collection<ServiceConfig> configs = configManager.getServices();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertEquals(config, configManager.getService("test"));
+    }
+
+    // Test ReferenceConfig correlative methods
+    @Test
+    public void testReferenceConfig() {
+        ReferenceConfig config = new ReferenceConfig();
+        config.setId("test");
+        configManager.addReferences(asList(config, null));
+        Collection<ReferenceConfig> configs = configManager.getReferences();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+        assertEquals(config, configManager.getReference("test"));
+    }
+
+    // Test ConfigCenterConfig correlative methods
+    @Test
+    public void testConfigCenterConfig() {
+        ConfigCenterConfig config = new ConfigCenterConfig();
+        configManager.addConfigCenters(asList(config, null));
+        Collection<ConfigCenterConfig> configs = configManager.getConfigCenters();
+        assertEquals(1, configs.size());
+        assertEquals(config, configs.iterator().next());
+    }
+
+    @Test
+    public void testAddConfig() {
+        configManager.addConfig(new ApplicationConfig());
+        configManager.addConfig(new ProviderConfig());
+        configManager.addConfig(new ProtocolConfig());
+
+        assertTrue(configManager.getApplication().isPresent());
+        assertFalse(configManager.getProviders().isEmpty());
+        assertFalse(configManager.getProtocols().isEmpty());
+    }
+
+    @Test
+    public void testRefreshAll() {
+        configManager.refreshAll();
     }
 }