如何配置Lettuce Redis集群异步连接池

我正在配置我的生菜重新分配池。当我按照官方文档配置时，连接池无法正常初始化，无法获取连接。官方文档指出：

RedisClusterClient clusterClient = 
RedisClusterClient.create(RedisURI.create(host, port));

AsyncPool<StatefulRedisConnection<String, String>> pool =             AsyncConnectionPoolSupport.createBoundedObjectPool(        () -> clusterClient.connectAsync(StringCodec.UTF8),     BoundedPoolConfig.create());
// execute work
CompletableFuture<String> setResult = pool.acquire().thenCompose(connection -> {        
    RedisAsyncCommands<String, String> async = connection.async();    
    async.set("key", "value");
    return async.async.set("key2", "value2").whenComplete((s, throwable) -> pool.release(c));
});

// terminating
pool.closeAsync();

// after pool completion
client.shutdownAsync();

这个配置在我的环境中不起作用。然后我添加 minIdle 配置：

final BoundedPoolConfig.Builder builder = BoundedPoolConfig.builder();
builder.minIdle(9);

它一开始是有效的，但是当我循环连接池并多次发送命令时，会抛出以下异常：

java.util.concurrent.ExecutionException: java.lang.IllegalStateException:             AsyncPool is closed   at     java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357) at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1895)

这是我的所有代码：

private String passwd = "xxxxx";
private String ip = "10.0.0.204";
;

@Bean
@Scope("singleton")
public ClientResources clientResources() {
    final DefaultClientResources defaultClientResources = DefaultClientResources.builder()
                                                                                .ioThreadPoolSize(4)
                                                                                .computationThreadPoolSize(4)
                                                                                .build();

    return defaultClientResources;
}

@Bean(destroyMethod = "shutdown")
@Scope("singleton")
public RedisClusterClient clusterClient(ClientResources clientResources) {
    final String ip = "10.0.0.204";
    final String passwd = "dingXiang123";
    final RedisURI redisURI1 = RedisURI.Builder.redis(ip, 7001).withPassword(passwd).build();
    final RedisURI redisURI2 = RedisURI.Builder.redis(ip, 7002).withPassword(passwd).build();
    final RedisURI redisURI3 = RedisURI.Builder.redis(ip, 7003).withPassword(passwd).build();
    final RedisURI redisURI4 = RedisURI.Builder.redis(ip, 7004).withPassword(passwd).build();
    final RedisURI redisURI5 = RedisURI.Builder.redis(ip, 7005).withPassword(passwd).build();
    final RedisURI redisURI6 = RedisURI.Builder.redis(ip, 7006).withPassword(passwd).build();
    RedisClusterClient clusterClient = null;
    try {
        final List<RedisURI> redisURIS = Arrays.asList(redisURI1, redisURI2, redisURI3, redisURI4, redisURI5, redisURI6);
        clusterClient = RedisClusterClient.create(clientResources, redisURIS);
        ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                                                                                            .enableAdaptiveRefreshTrigger(ClusterTopologyRefreshOptions.RefreshTrigger.MOVED_REDIRECT, ClusterTopologyRefreshOptions.RefreshTrigger.PERSISTENT_RECONNECTS)
                                                                                            //连接池refresh超时时间
                                                                                            .adaptiveRefreshTriggersTimeout(Duration.ofMinutes(3))
                                                                                            .build();


        clusterClient.setOptions(ClusterClientOptions.builder()
                                                     .topologyRefreshOptions(topologyRefreshOptions)
                                                     .autoReconnect(true)
                                                     .pingBeforeActivateConnection(true)
                                                     .build());

        final RedisAdvancedClusterAsyncCommands<String, String> async = clusterClient.connect().async();
        final RedisFuture<String> set = async.set("aa", "aaaaa");
        set.get();
        log.info("客户端初始化成功");
        return clusterClient;
    } catch (Exception e) {
        log.error("lettce客户端初始化失败，{}", e);
        if (clusterClient != null) {
            clusterClient.shutdown();
        }
    }

    return null;
}

/**
 * 初始化异步的 Cluter 模式链接池
 *
 * @param clusterClient
 * @return
 */
@Bean()
@DependsOn("clusterClient")
@Scope("singleton")
public BoundedAsyncPool<StatefulRedisClusterConnection<String, String>> lettucePool(RedisClusterClient clusterClient) {
    final BoundedPoolConfig.Builder builder = BoundedPoolConfig.builder();
    builder.minIdle(9);
    final BoundedPoolConfig boundedPoolConfig = builder.build();
    final BoundedAsyncPool<StatefulRedisClusterConnection<String, String>> lettucePool = AsyncConnectionPoolSupport.createBoundedObjectPool(
            () -> clusterClient.connectAsync(StringCodec.UTF8)
            , boundedPoolConfig
    );


    log.info("连接池初始化成功");
    return lettucePool;
}

/**
 * 从连接池获取链接
 *
 * @param lettucePool
 */
@Bean
@DependsOn("lettucePool")
public CompletableFuture<StatefulRedisClusterConnection<String, String>> clusterAsync(BoundedAsyncPool<StatefulRedisClusterConnection<String, String>> lettucePool) {

    final CompletableFuture<StatefulRedisClusterConnection<String, String>> acquire = lettucePool.acquire();
    return acquire;
}

1. 你又遇到这个问题了吗，你是怎么解决的？

2. 另外一点是，我不太喜欢redisTemplate来操作Lettuce API，所以我正在寻找原生Lettuce集群池的配置解决方案。

3. 你之前做过原集群池的配置或者Api的使用吗，或者看过详细的Demo文档吗，如果有请推荐给我（当然我也看了官方文档，我可能需要一个Demo申请学习）