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.

codeba · codeba · commit 98707c07e68a · 2025-04-13T16:55:03.000+08:00
diff --git a/redis-keeper-core/src/main/java/org/codeba/redis/keeper/core/CacheTemplate.java b/redis-keeper-core/src/main/java/org/codeba/redis/keeper/core/CacheTemplate.java
@@ -65,4 +65,9 @@ public interface CacheTemplate extends KBitSet, KGeneric, KGeo, KMap, KHyperLogL
      */
     CompletableFuture<List<?>> pipelineWithResponsesAsync(Consumer<KBatch> batchConsumer);
 
+    /**
+     * Destroy.
+     */
+    void destroy();
+
 }
diff --git a/redis-keeper-example/redis-keeper-example-springcloud/src/main/java/org/codeba/redis/keeper/springcloud/TestController.java b/redis-keeper-example/redis-keeper-example-springcloud/src/main/java/org/codeba/redis/keeper/springcloud/TestController.java
@@ -17,18 +17,21 @@
 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 {
@@ -42,12 +45,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;
     }
 
 
diff --git a/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisDatasourceProperties.java b/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisDatasourceProperties.java
@@ -17,6 +17,7 @@
 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,8 +30,12 @@
  */
 @Data
 @ConfigurationProperties(prefix = "redis-keeper.redis")
-public class RedisDatasourceProperties {
+public class RedisDatasourceProperties implements DisposableBean {
 
+    /**
+     * The Lazy refresh.
+     */
+    private boolean lazyRefresh = true;
     /**
      * The Datasource.
      */
@@ -41,4 +46,14 @@ public class RedisDatasourceProperties {
      */
     private Map<String, List<RedisKeeperProperties>> datasources;
 
+    /**
+     * Destroy.
+     */
+    @Override
+    public void destroy() {
+        lazyRefresh = true;
+        datasource = null;
+        datasources = null;
+    }
+
 }
diff --git a/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisKeeperAutoConfiguration.java b/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedisKeeperAutoConfiguration.java
@@ -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,30 +60,61 @@
 @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.
+     * <p>
      *
-     * @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.
diff --git a/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedissonDatasourceProperties.java b/redis-keeper-spring-boot-starter/src/main/java/org/codeba/redis/keeper/spring/boot/RedissonDatasourceProperties.java
@@ -17,6 +17,7 @@
 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,8 +30,11 @@
  */
 @Data
 @ConfigurationProperties(prefix = "redis-keeper.redisson")
-public class RedissonDatasourceProperties {
-
+public class RedissonDatasourceProperties implements DisposableBean {
+    /**
+     * The Lazy refresh.
+     */
+    private boolean lazyRefresh = true;
     /**
      * The Datasource.
      */
@@ -41,4 +45,14 @@ public class RedissonDatasourceProperties {
      */
     private Map<String, List<RedissonKeeperProperties>> datasources;
 
+    /**
+     * Destroy.
+     */
+    @Override
+    public void destroy() {
+        lazyRefresh = true;
+        datasource = null;
+        datasources = null;
+    }
+
 }
diff --git a/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/CacheDatasource.java b/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/CacheDatasource.java
@@ -17,14 +17,24 @@
 package org.codeba.redis.keeper.support;
 
 import org.codeba.redis.keeper.core.CacheDatasourceStatus;
+import org.codeba.redis.keeper.core.CacheTemplate;
 import org.codeba.redis.keeper.core.Provider;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
@@ -36,6 +46,21 @@
  */
 public interface CacheDatasource<T> {
 
+    /**
+     * The constant TEMPLATE_CACHE_MAP.
+     */
+    ConcurrentHashMap<String, Object> TEMPLATE_CACHE_MAP = new ConcurrentHashMap<>();
+
+    /**
+     * The constant TEMPLATE_CONFIG_CACHE_SET.
+     */
+    Set<String> TEMPLATE_CONFIG_CACHE_SET = Collections.synchronizedSet(new HashSet<>());
+
+    /**
+     * The constant THREAD_POOL_EXECUTOR.
+     */
+    ExecutorService THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(5, 10, 2, TimeUnit.MINUTES, new LinkedBlockingQueue<>(100));
+
     /**
      * Instant template t.
      *
@@ -51,6 +76,7 @@ public interface CacheDatasource<T> {
      * @return the map
      */
     default Map<String, T> initialize(Map<String, CacheKeeperConfig> datasourceMap) {
+        TEMPLATE_CONFIG_CACHE_SET.clear();
         final Map<String, T> map = new HashMap<>();
 
         if (null == datasourceMap || datasourceMap.isEmpty()) {
@@ -66,7 +92,13 @@ default Map<String, T> initialize(Map<String, CacheKeeperConfig> datasourceMap)
             }).accept(config);
 
             // cacheTemplate Instantiation
-            final T template = instantTemplate(config);
+            final String configString = config.toString();
+            TEMPLATE_CONFIG_CACHE_SET.add(configString);
+            T template = getTemplate(configString);
+            if (null == template) {
+                template = instantTemplate(config);
+                TEMPLATE_CACHE_MAP.put(configString, template);
+            }
 
             // <name, template>
             map.put(key.trim(), template);
@@ -86,6 +118,7 @@ default Map<String, T> initialize(Map<String, CacheKeeperConfig> datasourceMap)
      * @return the map
      */
     default Map<String, List<T>> initializeMulti(Map<String, List<CacheKeeperConfig>> datasourceMap) {
+        TEMPLATE_CONFIG_CACHE_SET.clear();
         final Map<String, List<T>> map = new HashMap<>();
 
         if (null == datasourceMap || datasourceMap.isEmpty()) {
@@ -103,7 +136,13 @@ default Map<String, List<T>> initializeMulti(Map<String, List<CacheKeeperConfig>
                         }).accept(config);
 
                         // cacheTemplate Instantiation
-                        final T template = instantTemplate(config);
+                        final String configString = config.toString();
+                        TEMPLATE_CONFIG_CACHE_SET.add(configString);
+                        T template = getTemplate(configString);
+                        if (null == template) {
+                            template = instantTemplate(config);
+                            TEMPLATE_CACHE_MAP.put(configString, template);
+                        }
 
                         // <name-datasourceStatus, List<template>>
                         final CacheDatasourceStatus datasourceStatus = checkDatasourceStatus(config.getStatus());
@@ -151,4 +190,37 @@ default CacheDatasourceStatus checkDatasourceStatus(String name) {
 
     }
 
+    /**
+     * Gets template.
+     *
+     * @param config the config
+     * @return the template
+     */
+    default T getTemplate(String config) {
+        final Object object = TEMPLATE_CACHE_MAP.get(config);
+        return null == object ? null : (T) object;
+    }
+
+    /**
+     * Clean.
+     */
+    default void clean() {
+        for (Iterator<Map.Entry<String, Object>> it = TEMPLATE_CACHE_MAP.entrySet().iterator(); it.hasNext(); ) {
+            final Map.Entry<String, Object> entry = it.next();
+            final String key = entry.getKey();
+            if (!TEMPLATE_CONFIG_CACHE_SET.contains(key)) {
+                final Object value = entry.getValue();
+                if (null != value) {
+                    // clean async
+                    CompletableFuture.runAsync(() -> {
+                        CacheTemplate template = (CacheTemplate) value;
+                        template.destroy();
+                        template = null;
+                    }, THREAD_POOL_EXECUTOR);
+                }
+                it.remove();
+            }
+        }
+    }
+
 }
diff --git a/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/CacheKeeperConfig.java b/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/CacheKeeperConfig.java
@@ -19,6 +19,8 @@
 import org.codeba.redis.keeper.core.CacheDatasourceStatus;
 import org.redisson.config.Config;
 
+import java.io.IOException;
+
 /**
  * The type Cache keeper config.
  *
@@ -79,6 +81,17 @@ public CacheKeeperConfig(String status, Config config, boolean invokeParamsPrint
         this.config = config;
     }
 
+    @Override
+    public String toString() {
+        final String configYAML;
+        try {
+            configYAML = config.toYAML();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        return Utils.getMD5(status + invokeParamsPrint + configYAML);
+    }
+
     /**
      * Gets status.
      *
diff --git a/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/DefaultRedissonTemplate.java b/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/DefaultRedissonTemplate.java
diff --git a/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/Utils.java b/redis-keeper-support/src/main/java/org/codeba/redis/keeper/support/Utils.java

Original file line number	Diff line number	Diff line change
`@@ -65,4 +65,9 @@ public interface CacheTemplate extends KBitSet, KGeneric, KGeo, KMap, KHyperLogL`
`65`	`65`	`*/`
`66`	`66`	`CompletableFuture<List<?>> pipelineWithResponsesAsync(Consumer<KBatch> batchConsumer);`
`67`	`67`
	`68`	`+ /**`
	`69`	`+ * Destroy.`
	`70`	`+ */`
	`71`	`+ void destroy();`
	`72`	`+`
`68`	`73`	`}`