fix(redis-keeper-spring-boot-starter): Fixed the issue where idle redis connections were not closed after dynamically refreshing the configuration, and the same configuration reuses the redis client.

Author: codeba

redis-keeper-core/src/main/java/org/codeba/redis/keeper/core/CacheTemplate.java

@@ -3655,4 +3655,9 @@ public interface CacheTemplate {
      */
     CompletableFuture<Boolean> tryAcquireAsync(String key, long permits);
 
+    /**
+     * Destroy.
+     */
+    void destroy();
+
 }

redis-keeper-example/redis-keeper-example-springcloud/src/main/java/org/codeba/redis/keeper/springcloud/TestController.java

@@ -1,34 +1,37 @@
 /*
  * Copyright (c) 2024-2025, redis-keeper ([email protected])
  *
- *    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
+ *     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
+ *         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.
+ *     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.codeba.redis.keeper.springcloud;
 
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.codeba.redis.keeper.core.CacheTemplate;
 import org.codeba.redis.keeper.core.CacheTemplateProvider;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * The type Test controller.
  *
  * @author codeba
  */
+@Slf4j
 @RestController
 @RequiredArgsConstructor
 public class TestController {
@@ -39,12 +42,38 @@ public class TestController {
      * Test refresh.
      */
     @RequestMapping("/refresh")
-    public void testRefresh() {
-        final Optional<CacheTemplate> templateOptional = provider.getTemplate("ds1");
-        templateOptional.ifPresent(cacheTemplate -> {
-            cacheTemplate.set("foo", "bar");
-            cacheTemplate.del("foo");
+    public boolean testRefresh() {
+        final long start = System.currentTimeMillis();
+
+        final CompletableFuture<Void> f1 = CompletableFuture.runAsync(() -> {
+            for (int i = 0; i < 100000; i++) {
+                final Optional<CacheTemplate> templateOptional = provider.getTemplate("ds4");
+                templateOptional.ifPresent(cacheTemplate -> {
+                    cacheTemplate.incr("testRefresh");
+                });
+            }
+        });
+        final CompletableFuture<Void> f2 = CompletableFuture.runAsync(() -> {
+            for (int i = 0; i < 100000; i++) {
+                final Optional<CacheTemplate> templateOptional = provider.getTemplate("ds4");
+                templateOptional.ifPresent(cacheTemplate -> {
+                    cacheTemplate.incr("testRefresh");
+                });
+            }
+        });
+        final CompletableFuture<Void> f3 = CompletableFuture.runAsync(() -> {
+            for (int i = 0; i < 100000; i++) {
+                final Optional<CacheTemplate> templateOptional = provider.getTemplate("ds4");
+                templateOptional.ifPresent(cacheTemplate -> {
+                    cacheTemplate.incr("testRefresh");
+                });
+            }
         });
+
+        CompletableFuture.allOf(f1, f2, f3).join();
+        log.info("cost time: {}", (System.currentTimeMillis() - start));
+
+        return true;
     }
 
 

redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisDatasourceProperties.java

@@ -1,22 +1,23 @@
 /*
  * Copyright (c) 2024-2025, redis-keeper ([email protected])
  *
- *    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
+ *     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
+ *         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.
+ *     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.codeba.redis.keeper.spring.boot;
 
 import lombok.Data;
+import org.springframework.beans.factory.DisposableBean;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 
 import java.util.List;
@@ -29,10 +30,33 @@
  */
 @Data
 @ConfigurationProperties(prefix = "redis-keeper.redis")
-public class RedisDatasourceProperties {
+public class RedisDatasourceProperties implements DisposableBean {
 
+    /**
+     * The Lazy refresh, when a configuration change occurs, the bean initialized immediately or when the bean is first invoked
+     * <p>
+     * true: the bean initialized when the bean is first invoked
+     * false: the bean initialized immediately
+     */
+    private boolean lazyRefresh = true;
+    /**
+     * The Datasource. One-to-one redis data source
+     */
     private Map<String, RedisKeeperProperties> datasource;
 
+    /**
+     * The Datasources. One-to-many redis data sources
+     */
     private Map<String, List<RedisKeeperProperties>> datasources;
 
+    /**
+     * Destroy.
+     */
+    @Override
+    public void destroy() {
+        lazyRefresh = true;
+        datasource = null;
+        datasources = null;
+    }
+
 }

redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisKeeperAutoConfiguration.java

@@ -1,17 +1,17 @@
 /*
  * Copyright (c) 2024-2025, redis-keeper ([email protected])
  *
- *    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
+ *     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
+ *         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.
+ *     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.codeba.redis.keeper.spring.boot;
@@ -26,12 +26,16 @@
 import org.redisson.config.Config;
 import org.redisson.config.SentinelServersConfig;
 import org.redisson.config.SingleServerConfig;
+import org.springframework.aop.scope.ScopedProxyUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.cloud.context.scope.refresh.RefreshScopeRefreshedEvent;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.event.EventListener;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
@@ -56,28 +60,69 @@
 @SuppressWarnings({"unchecked"})
 @EnableConfigurationProperties({RedisDatasourceProperties.class, RedissonDatasourceProperties.class})
 public class RedisKeeperAutoConfiguration<T> {
+    /**
+     * The constant PROVIDER_BEAN_NAME.
+     */
+    private static final String PROVIDER_BEAN_NAME = "cacheTemplateProvider";
+
+    /**
+     * The Context.
+     */
+    @Autowired
+    private ApplicationContext context;
 
+    /**
+     * The Cache datasource.
+     */
     @Autowired(required = false)
     private CacheDatasource<T> cacheDatasource;
 
+    /**
+     * The Redis properties.
+     */
+    @Autowired
+    private RedisDatasourceProperties redisProperties;
+
+    /**
+     * The Redisson properties.
+     */
+    @Autowired
+    private RedissonDatasourceProperties redissonProperties;
+
     /**
      * Cache template provider cache template provider.
      *
-     * @param redisProperties    the redis properties
-     * @param redissonProperties the redisson properties
      * @return the cache template provider
      * @throws IOException the io exception
      */
-    @Bean
+    @Bean(name = RedisKeeperAutoConfiguration.PROVIDER_BEAN_NAME)
     @RefreshScope
-    public CacheTemplateProvider<T> cacheTemplateProvider(RedisDatasourceProperties redisProperties, RedissonDatasourceProperties redissonProperties) throws IOException {
+    public CacheTemplateProvider<T> cacheTemplateProvider() throws IOException {
         final Map<String, T> loadMap = load(redisProperties, redissonProperties);
-        final Map<String, List<T>> loadsMap = loads(redisProperties, redissonProperties);
-
-        return new CacheTemplateProvider<>(loadMap, loadsMap);
+        final Map<String, List<T>> loadListMap = loads(redisProperties, redissonProperties);
+        // clean
+        cacheDatasource.clean();
+        return new CacheTemplateProvider<>(loadMap, loadListMap);
     }
 
+    /**
+     * On refresh.
+     */
+    @EventListener(RefreshScopeRefreshedEvent.class)
+    public void onRefresh() {
+        if (!redisProperties.isLazyRefresh() || !redissonProperties.isLazyRefresh()) {
+            this.context.getBean(ScopedProxyUtils.getTargetBeanName(PROVIDER_BEAN_NAME));
+        }
+    }
 
+    /**
+     * Load map.
+     *
+     * @param redisProperties    the redis properties
+     * @param redissonProperties the redisson properties
+     * @return the map
+     * @throws IOException the io exception
+     */
     private Map<String, T> load(RedisDatasourceProperties redisProperties, RedissonDatasourceProperties redissonProperties) throws IOException {
         if (null == cacheDatasource) {
             cacheDatasource = (CacheDatasource<T>) new DefaultCacheDatasource();
@@ -116,6 +161,13 @@ private Map<String, T> load(RedisDatasourceProperties redisProperties, RedissonD
         return cacheDatasource.initialize(map);
     }
 
+    /**
+     * Loads map.
+     *
+     * @param redisProperties    the redis properties
+     * @param redissonProperties the redisson properties
+     * @return the map
+     */
     private Map<String, List<T>> loads(RedisDatasourceProperties redisProperties, RedissonDatasourceProperties redissonProperties) {
         if (null == cacheDatasource) {
             cacheDatasource = (CacheDatasource<T>) new DefaultCacheDatasource();
@@ -175,6 +227,13 @@ private Map<String, List<T>> loads(RedisDatasourceProperties redisProperties, Re
         return cacheDatasource.initializeMulti(map);
     }
 
+    /**
+     * Config config.
+     *
+     * @param redissonKeeperProperties the redisson keeper properties
+     * @return the config
+     * @throws IOException the io exception
+     */
     private Config config(RedissonKeeperProperties redissonKeeperProperties) throws IOException {
         Config result = null;
         final String config = redissonKeeperProperties.getConfig();
@@ -187,6 +246,13 @@ private Config config(RedissonKeeperProperties redissonKeeperProperties) throws
         return result;
     }
 
+    /**
+     * Config config.
+     *
+     * @param redisProperties the redis properties
+     * @return the config
+     * @throws IOException the io exception
+     */
     private Config config(RedisProperties redisProperties) throws IOException {
         Config config;
         Method clusterMethod = ReflectionUtils.findMethod(RedisProperties.class, "getCluster");

redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisKeeperProperties.java

@@ -1,17 +1,17 @@
 /*
  * Copyright (c) 2024-2025, redis-keeper ([email protected])
  *
- *    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
+ *     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
+ *         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.
+ *     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.codeba.redis.keeper.spring.boot;
@@ -30,6 +30,21 @@
 @Data
 @EqualsAndHashCode(callSuper = true)
 public class RedisKeeperProperties extends RedisProperties {
+    /**
+     * The Status is the identity of the data source, you can specify the identity through the cacheProvider class to get the corresponding data source
+     * <p>
+     * Value range: RO, WO, RW, SKIP
+     * RO: Read-only cache datasource status
+     * WO: Write-only cache datasource status.
+     * RW: Read-write cache datasource status.
+     * SKIP: Skip cache datasource status.
+     */
     private String status = CacheDatasourceStatus.RW.name();
+    /**
+     * The Invoke params print, means whether to print an entry log when executing the methods of the cacheTemplate class.
+     * <p>
+     * true : print entry log
+     * false: not print entry log
+     */
     private boolean invokeParamsPrint;
 }