Fix the issue of case sensitivity when matching keys with cache enabled (#4820)

* add tech-support-qq-4.png

* Update README.md

* Enhance the user experience in the scenario of submitting duplicate keys

* Modify the key-value conflict exception prompt, adjust the code style

* fix(apollo-configService): Fix the issue of case sensitivity when matching keys with cache enabled

* fix(apollo-configService): Adding test cases

* fix(apollo-configService): Adding test cases

* doc(CHANGES.md): Update CHANGES.md

* test(apollo-biz): Optimize the test case

* fix(apollo-configService): Fix the issue of case sensitivity when matching keys with cache enabled

* fix(apollo-configService): Adding test cases

* fix(apollo-configService): Adding test cases

* doc(CHANGES.md): Update CHANGES.md

* test(apollo-biz): Optimize the test case

---------

Co-authored-by: Jason Song <nobodyiam@gmail.com>

CHANGES.md

@@ -22,6 +22,7 @@ Apollo 2.2.0
 * [Fix the issue of the system permission management page retrieving non-existent users](https://github.com/apolloconfig/apollo/pull/4802)
 * [Add release history cleaning function](https://github.com/apolloconfig/apollo/pull/4813)
 * [[Multi-Database Support][pg] Make JdbcUserDetailsManager compat with postgre](https://github.com/apolloconfig/apollo/pull/4790)
+* [Add a configuration config-service.cache.key.ignore-case to control whether the cache key is case-sensitive](https://github.com/apolloconfig/apollo/pull/4820)
 
 ------------------
 All issues and pull requests are [here](https://github.com/apolloconfig/apollo/milestone/13?closed=1)

apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/config/BizConfig.java

@@ -205,6 +205,10 @@ public class BizConfig extends RefreshableConfig {
     return getBooleanProperty("config-service.cache.enabled", false);
   }
 
+  public boolean isConfigServiceCacheKeyIgnoreCase() {
+    return getBooleanProperty("config-service.cache.key.ignore-case", false);
+  }
+
   int checkInt(int value, int min, int max, int defaultValue) {
     if (value >= min && value <= max) {
       return value;

apollo-biz/src/test/java/com/ctrip/framework/apollo/biz/config/BizConfigTest.java

@@ -27,6 +27,8 @@ import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.test.util.ReflectionTestUtils;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.when;
 
 /**
@@ -124,4 +126,11 @@ public class BizConfigTest {
     assertEquals(someValidValue, bizConfig.checkInt(someValidValue, Integer.MIN_VALUE, Integer.MAX_VALUE,
         someDefaultValue));
   }
+
+  @Test
+  public void testIsConfigServiceCacheKeyIgnoreCase() {
+    assertFalse(bizConfig.isConfigServiceCacheKeyIgnoreCase());
+    when(environment.getProperty("config-service.cache.key.ignore-case")).thenReturn("true");
+    assertTrue(bizConfig.isConfigServiceCacheKeyIgnoreCase());
+  }
 }

apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/ConfigServiceAutoConfiguration.java

@@ -67,7 +67,7 @@ public class ConfigServiceAutoConfiguration {
   public ConfigService configService() {
     if (bizConfig.isConfigServiceCacheEnabled()) {
       return new ConfigServiceWithCache(releaseService, releaseMessageService,
-          grayReleaseRulesHolder());
+          grayReleaseRulesHolder(), bizConfig);
     }
     return new DefaultConfigService(releaseService, grayReleaseRulesHolder());
   }

apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/service/config/ConfigServiceWithCache.java

@@ -17,6 +17,7 @@
 package com.ctrip.framework.apollo.configservice.service.config;
 
 import com.ctrip.framework.apollo.biz.grayReleaseRule.GrayReleaseRulesHolder;
+import com.ctrip.framework.apollo.biz.config.BizConfig;
 import com.google.common.base.Strings;
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
@@ -61,6 +62,7 @@ public class ConfigServiceWithCache extends AbstractConfigService {
 
   private final ReleaseService releaseService;
   private final ReleaseMessageService releaseMessageService;
+  private final BizConfig bizConfig;
 
   private LoadingCache<String, ConfigCacheEntry> configCache;
 
@@ -70,10 +72,12 @@ public class ConfigServiceWithCache extends AbstractConfigService {
 
   public ConfigServiceWithCache(final ReleaseService releaseService,
       final ReleaseMessageService releaseMessageService,
-      final GrayReleaseRulesHolder grayReleaseRulesHolder) {
+      final GrayReleaseRulesHolder grayReleaseRulesHolder,
+      final BizConfig bizConfig) {
     super(grayReleaseRulesHolder);
     this.releaseService = releaseService;
     this.releaseMessageService = releaseMessageService;
+    this.bizConfig = bizConfig;
     nullConfigCacheEntry = new ConfigCacheEntry(ConfigConsts.NOTIFICATION_ID_PLACEHOLDER, null);
   }
 
@@ -147,18 +151,23 @@ public class ConfigServiceWithCache extends AbstractConfigService {
   @Override
   protected Release findLatestActiveRelease(String appId, String clusterName, String namespaceName,
                                             ApolloNotificationMessages clientMessages) {
-    String key = ReleaseMessageKeyGenerator.generate(appId, clusterName, namespaceName);
+    String messageKey = ReleaseMessageKeyGenerator.generate(appId, clusterName, namespaceName);
+    String cacheKey = messageKey;
 
-    Tracer.logEvent(TRACER_EVENT_CACHE_GET, key);
+    if (bizConfig.isConfigServiceCacheKeyIgnoreCase()) {
+      cacheKey = cacheKey.toLowerCase();
+    }
+
+    Tracer.logEvent(TRACER_EVENT_CACHE_GET, cacheKey);
 
-    ConfigCacheEntry cacheEntry = configCache.getUnchecked(key);
+    ConfigCacheEntry cacheEntry = configCache.getUnchecked(cacheKey);
 
     //cache is out-dated
-    if (clientMessages != null && clientMessages.has(key) &&
-        clientMessages.get(key) > cacheEntry.getNotificationId()) {
+    if (clientMessages != null && clientMessages.has(messageKey) &&
+        clientMessages.get(messageKey) > cacheEntry.getNotificationId()) {
       //invalidate the cache and try to load from db again
-      invalidate(key);
-      cacheEntry = configCache.getUnchecked(key);
+      invalidate(cacheKey);
+      cacheEntry = configCache.getUnchecked(cacheKey);
     }
 
     return cacheEntry.getRelease();
@@ -177,10 +186,14 @@ public class ConfigServiceWithCache extends AbstractConfigService {
     }
 
     try {
-      invalidate(message.getMessage());
+      String messageKey = message.getMessage();
+      if (bizConfig.isConfigServiceCacheKeyIgnoreCase()) {
+        messageKey = messageKey.toLowerCase();
+      }
+      invalidate(messageKey);
 
       //warm up the cache
-      configCache.getUnchecked(message.getMessage());
+      configCache.getUnchecked(messageKey);
     } catch (Throwable ex) {
       //ignore
     }

apollo-configservice/src/test/java/com/ctrip/framework/apollo/configservice/service/config/ConfigServiceWithCacheAndCacheKeyIgnoreCaseTest.java

@@ -0,0 +1,382 @@
+/*
+ * Copyright 2023 Apollo Authors
+ *
+ * Licensed 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 com.ctrip.framework.apollo.configservice.service.config;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.matches;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.ctrip.framework.apollo.biz.config.BizConfig;
+import com.ctrip.framework.apollo.biz.entity.Release;
+import com.ctrip.framework.apollo.biz.entity.ReleaseMessage;
+import com.ctrip.framework.apollo.biz.grayReleaseRule.GrayReleaseRulesHolder;
+import com.ctrip.framework.apollo.biz.message.Topics;
+import com.ctrip.framework.apollo.biz.service.ReleaseMessageService;
+import com.ctrip.framework.apollo.biz.service.ReleaseService;
+import com.ctrip.framework.apollo.biz.utils.ReleaseMessageKeyGenerator;
+import com.ctrip.framework.apollo.core.dto.ApolloNotificationMessages;
+import com.google.common.collect.Lists;
+import java.util.regex.Pattern;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * @author kl (http://kailing.pub)
+ * @since 2023/3/28
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class ConfigServiceWithCacheAndCacheKeyIgnoreCaseTest {
+
+  private ConfigServiceWithCache configServiceWithCache;
+
+  @Mock
+  private ReleaseService releaseService;
+  @Mock
+  private ReleaseMessageService releaseMessageService;
+  @Mock
+  private Release someRelease;
+  @Mock
+  private ReleaseMessage someReleaseMessage;
+  @Mock
+  private BizConfig bizConfig;
+  @Mock
+  private GrayReleaseRulesHolder grayReleaseRulesHolder;
+
+  private String someAppId;
+  private String someClusterName;
+  private String someNamespaceName;
+  private String lowerCaseSomeKey;
+  private String normalSomeKey;
+  private long someNotificationId;
+  private ApolloNotificationMessages someNotificationMessages;
+
+  @Before
+  public void setUp() throws Exception {
+    configServiceWithCache = new ConfigServiceWithCache(releaseService, releaseMessageService,
+        grayReleaseRulesHolder, bizConfig);
+
+    when(bizConfig.isConfigServiceCacheKeyIgnoreCase()).thenReturn(true);
+
+    configServiceWithCache.initialize();
+
+    someAppId = "someAppId";
+    someClusterName = "someClusterName";
+    someNamespaceName = "someNamespaceName";
+    someNotificationId = 1;
+
+    normalSomeKey = ReleaseMessageKeyGenerator.generate(someAppId, someClusterName, someNamespaceName);
+    lowerCaseSomeKey = normalSomeKey.toLowerCase();
+    someNotificationMessages = new ApolloNotificationMessages();
+  }
+
+  @Test
+  public void testFindActiveOne() {
+    long someId = 1;
+
+    when(releaseService.findActiveOne(someId)).thenReturn(someRelease);
+
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    verify(releaseService, times(1)).findActiveOne(someId);
+  }
+
+  @Test
+  public void testFindActiveOneWithSameIdMultipleTimes() {
+    long someId = 1;
+
+    when(releaseService.findActiveOne(someId)).thenReturn(someRelease);
+
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+
+    verify(releaseService, times(1)).findActiveOne(someId);
+  }
+
+  @Test
+  public void testFindActiveOneWithMultipleIdMultipleTimes() {
+    long someId = 1;
+    long anotherId = 2;
+    Release anotherRelease = mock(Release.class);
+
+    when(releaseService.findActiveOne(someId)).thenReturn(someRelease);
+    when(releaseService.findActiveOne(anotherId)).thenReturn(anotherRelease);
+
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    assertEquals(someRelease,
+        configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+
+    assertEquals(anotherRelease,
+        configServiceWithCache.findActiveOne(anotherId, someNotificationMessages));
+    assertEquals(anotherRelease,
+        configServiceWithCache.findActiveOne(anotherId, someNotificationMessages));
+
+    verify(releaseService, times(1)).findActiveOne(someId);
+    verify(releaseService, times(1)).findActiveOne(anotherId);
+  }
+
+  @Test
+  public void testFindActiveOneWithReleaseNotFoundMultipleTimes() {
+    long someId = 1;
+
+    when(releaseService.findActiveOne(someId)).thenReturn(null);
+
+    assertNull(configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    assertNull(configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+    assertNull(configServiceWithCache.findActiveOne(someId, someNotificationMessages));
+
+    verify(releaseService, times(1)).findActiveOne(someId);
+  }
+
+  @Test
+  public void testFindLatestActiveRelease() {
+    when(releaseMessageService.findLatestReleaseMessageForMessages(Lists.newArrayList(lowerCaseSomeKey)))
+        .thenReturn(someReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(someRelease);
+    when(someReleaseMessage.getId()).thenReturn(someNotificationId);
+
+    Release release = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName, someNotificationMessages);
+    Release anotherRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName, someNamespaceName, someNotificationMessages);
+
+    int retryTimes = 100;
+
+    for (int i = 0; i < retryTimes; i++) {
+      configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+          someNamespaceName, someNotificationMessages);
+    }
+
+    assertEquals(someRelease, release);
+    assertEquals(someRelease, anotherRelease);
+
+    verify(releaseMessageService, times(1)).findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey));
+    verify(releaseService, times(1)).findLatestActiveRelease(
+        someAppId.toLowerCase(),
+        someClusterName.toLowerCase(),
+        someNamespaceName.toLowerCase());
+  }
+
+  @Test
+  public void testFindLatestActiveReleaseWithReleaseNotFound() {
+    when(releaseMessageService.findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey))).thenReturn(null);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(null);
+
+    Release release = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName,
+        someNotificationMessages);
+    Release anotherRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    int retryTimes = 100;
+
+    for (int i = 0; i < retryTimes; i++) {
+      configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+          someNamespaceName, someNotificationMessages);
+    }
+
+    assertNull(release);
+    assertNull(anotherRelease);
+
+    verify(releaseMessageService, times(1)).findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey));
+    verify(releaseService, times(1)).findLatestActiveRelease(
+        someAppId.toLowerCase(),
+        someClusterName.toLowerCase(),
+        someNamespaceName.toLowerCase());
+  }
+
+  @Test
+  public void testFindLatestActiveReleaseWithDirtyRelease() {
+    long someNewNotificationId = someNotificationId + 1;
+    ReleaseMessage anotherReleaseMessage = mock(ReleaseMessage.class);
+    Release anotherRelease = mock(Release.class);
+
+    when(releaseMessageService.findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey))).thenReturn
+        (someReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(someRelease);
+    when(someReleaseMessage.getId()).thenReturn(someNotificationId);
+
+    Release release = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName,
+        someNotificationMessages);
+
+    when(releaseMessageService.findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey))).thenReturn(anotherReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(anotherRelease);
+    when(anotherReleaseMessage.getId()).thenReturn(someNewNotificationId);
+
+    Release stillOldRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    someNotificationMessages.put(
+        ReleaseMessageKeyGenerator.generate(someAppId, someClusterName, someNamespaceName),
+        someNewNotificationId);
+
+    Release shouldBeNewRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    assertEquals(someRelease, release);
+    assertEquals(someRelease, stillOldRelease);
+    assertEquals(anotherRelease, shouldBeNewRelease);
+
+    verify(releaseMessageService, times(2)).findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey));
+    verify(releaseService, times(2)).findLatestActiveRelease(
+        someAppId.toLowerCase(),
+        someClusterName.toLowerCase(),
+        someNamespaceName.toLowerCase());
+  }
+
+  @Test
+  public void testFindLatestActiveReleaseWithReleaseMessageNotification() {
+    long someNewNotificationId = someNotificationId + 1;
+    ReleaseMessage anotherReleaseMessage = mock(ReleaseMessage.class);
+    Release anotherRelease = mock(Release.class);
+
+    when(releaseMessageService.findLatestReleaseMessageForMessages(Lists.newArrayList(lowerCaseSomeKey)))
+        .thenReturn(someReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(someRelease);
+    when(someReleaseMessage.getId()).thenReturn(someNotificationId);
+
+    Release release = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName,
+        someNotificationMessages);
+
+    when(releaseMessageService.findLatestReleaseMessageForMessages(Lists.newArrayList(lowerCaseSomeKey)))
+        .thenReturn(anotherReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(anotherRelease);
+
+    when(anotherReleaseMessage.getMessage()).thenReturn(lowerCaseSomeKey);
+    when(anotherReleaseMessage.getId()).thenReturn(someNewNotificationId);
+
+    Release stillOldRelease = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    configServiceWithCache.handleMessage(anotherReleaseMessage, Topics.APOLLO_RELEASE_TOPIC);
+
+    Release shouldBeNewRelease = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    assertEquals(someRelease, release);
+    assertEquals(someRelease, stillOldRelease);
+    assertEquals(anotherRelease, shouldBeNewRelease);
+
+    verify(releaseMessageService, times(2)).findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey));
+    verify(releaseService, times(2)).findLatestActiveRelease(
+        someAppId.toLowerCase(),
+        someClusterName.toLowerCase(),
+        someNamespaceName.toLowerCase());
+
+    when(anotherReleaseMessage.getMessage()).thenReturn(normalSomeKey);
+    when(anotherReleaseMessage.getId()).thenReturn(someNewNotificationId);
+
+    configServiceWithCache.handleMessage(anotherReleaseMessage, Topics.APOLLO_RELEASE_TOPIC);
+
+    shouldBeNewRelease = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName, someNotificationMessages);
+    assertEquals(anotherRelease, shouldBeNewRelease);
+  }
+
+  @Test
+  public void testFindLatestActiveReleaseWithIrrelevantMessages() {
+    long someNewNotificationId = someNotificationId + 1;
+    String someIrrelevantKey = "someIrrelevantKey";
+
+    when(releaseMessageService.findLatestReleaseMessageForMessages(Lists.newArrayList(lowerCaseSomeKey)))
+        .thenReturn(someReleaseMessage);
+    when(releaseService.findLatestActiveRelease(
+        matchesCaseInsensitive(someAppId),
+        matchesCaseInsensitive(someClusterName),
+        matchesCaseInsensitive(someNamespaceName)
+    )).thenReturn(someRelease);
+    when(someReleaseMessage.getId()).thenReturn(someNotificationId);
+
+    Release release = configServiceWithCache.findLatestActiveRelease(someAppId, someClusterName,
+        someNamespaceName,
+        someNotificationMessages);
+
+    Release stillOldRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    someNotificationMessages.put(someIrrelevantKey, someNewNotificationId);
+
+    Release shouldStillBeOldRelease = configServiceWithCache.findLatestActiveRelease(someAppId,
+        someClusterName,
+        someNamespaceName, someNotificationMessages);
+
+    assertEquals(someRelease, release);
+    assertEquals(someRelease, stillOldRelease);
+    assertEquals(someRelease, shouldStillBeOldRelease);
+
+    verify(releaseMessageService, times(1)).findLatestReleaseMessageForMessages(
+        Lists.newArrayList(lowerCaseSomeKey));
+    verify(releaseService, times(1)).findLatestActiveRelease(
+        someAppId.toLowerCase(),
+        someClusterName.toLowerCase(),
+        someNamespaceName.toLowerCase());
+  }
+
+  private String matchesCaseInsensitive(final String regex) {
+    return matches(Pattern.compile(regex, Pattern.CASE_INSENSITIVE));
+  }
+
+}

apollo-configservice/src/test/java/com/ctrip/framework/apollo/configservice/service/config/ConfigServiceWithCacheTest.java

@@ -17,6 +17,7 @@
 package com.ctrip.framework.apollo.configservice.service.config;
 
 import com.ctrip.framework.apollo.biz.grayReleaseRule.GrayReleaseRulesHolder;
+import com.ctrip.framework.apollo.biz.config.BizConfig;
 import com.ctrip.framework.apollo.core.dto.ApolloNotificationMessages;
 import com.google.common.collect.Lists;
 
@@ -56,6 +57,8 @@ public class ConfigServiceWithCacheTest {
   @Mock
   private ReleaseMessage someReleaseMessage;
   @Mock
+  private BizConfig bizConfig;
+  @Mock
   private GrayReleaseRulesHolder grayReleaseRulesHolder;
 
   private String someAppId;
@@ -68,7 +71,8 @@ public class ConfigServiceWithCacheTest {
   @Before
   public void setUp() throws Exception {
     configServiceWithCache = new ConfigServiceWithCache(releaseService, releaseMessageService,
-        grayReleaseRulesHolder);
+        grayReleaseRulesHolder, bizConfig);
+
     configServiceWithCache.initialize();
 
     someAppId = "someAppId";

docs/en/deployment/distributed-deployment-guide.md

@@ -1500,10 +1500,17 @@ This is a function switch, if configured to true, config service will cache the
 
 The default is false. Please evaluate the total configuration size and adjust the config service memory configuration before turning it on.
 
-> Ensure that the `app.id`、`apollo.cluster` of the configuration in the application is in the correct case when caching is enabled, otherwise it will not fetch the correct configuration
+> Ensure that the `app.id`、`apollo.cluster` of the configuration in the application is in the correct case when caching is enabled, otherwise it will not fetch the correct configuration, You can also refer to the `config-service.cache.key.ignore-case` configuration for compatibility processing.
 
 > `config-service.cache.enabled` configuration adjustment requires a restart of the config service to take effect
 
+#### 3.2.3.1 config-service.cache.key.ignore-case - whether to ignore the case of the configuration cache key
+> For versions 2.2.0 and above
+
+This configuration takes effect when config-service.cache.enabled is set to true, and controls whether the configuration cache key ignores case. The default value is false, which means that cache keys are strictly case-sensitive. In this case, it is necessary to ensure that the capitalization of app.id and apollo.cluster configured in the application is correct, otherwise the correct configuration cannot be obtained. It can be configured as true to ignore case sensitivity.
+
+> This configuration is used to be compatible with the configuration acquisition logic when the cache is not enabled, because MySQL database queries are case-insensitive by default. If the cache is enabled and MySQL is used, it is recommended to configure it as true. If the database used by your Apollo is case-sensitive, you must keep the default configuration as false, otherwise the configuration cannot be obtained.
+
 ### 3.2.4 `item.key.length.limit`- Maximum length limit for configuration item key
 
 The default configuration is 128.

docs/zh/deployment/distributed-deployment-guide.md

@@ -1442,10 +1442,18 @@ http://5.5.5.5:8080/eureka/,http://6.6.6.6:8080/eureka/
 
 默认为false，开启前请先评估总配置大小并调整config service内存配置。
 
-> 开启缓存后必须确保应用中配置的`app.id`、`apollo.cluster`大小写正确，否则将获取不到正确的配置
+> 开启缓存后必须确保应用中配置的`app.id`、`apollo.cluster`大小写正确，否则将获取不到正确的配置，另可参考`config-service.cache.key.ignore-case`配置做兼容处理。
 
 > `config-service.cache.enabled` 配置调整必须重启 config service 才能生效
 
+#### 3.2.3.1 config-service.cache.key.ignore-case - 是否忽略配置缓存key的大小写
+> 适用于2.2.0及以上版本
+
+该配置作用于`config-service.cache.enabled`为 true 时，用于控制配置缓存key是否忽略大小写。
+默认为 false，即缓存键大小写严格匹配。此时需要确保应用中配置的`app.id`、`apollo.cluster`大小写正确，否则将获取不到正确的配置。可配置为 true, 则忽略大小写。
+
+> 这个配置用于兼容未开启缓存时的配置获取逻辑，因为 MySQL 数据库查询默认字符串匹配大小写不敏感。如果开启了缓存，且用了 MySQL，建议配置 true。如果你 Apollo 使用的数据库字符串匹配大小写敏感，那么必须保持默认配置 false，否则将获取不到配置。
+
 ### 3.2.4 item.key.length.limit - 配置项 key 最大长度限制
 
 默认配置是128。