Lettuce中基于配置选择Redis多连接（单机、RedisCluster、哨兵）的方法、架构疑问及工厂模式实现方案

嘿，针对你提出的关于Redis多连接场景的几个疑问，我结合Redisson客户端的设计逻辑和实际使用场景来给你拆解：

1. 为什么不提供通用Connection对象，而要区分StatefulRedisConnection和StatefulRedisClusterConnection？ #

这本质是单一职责原则的体现。不同Redis部署模式下的连接需要维护的状态完全不一样：

• StatefulRedisConnection针对单机/哨兵模式，只需要维护单个或主从节点的连接状态，无需处理集群槽位映射、节点拓扑变更这类复杂逻辑。
• StatefulRedisClusterConnection则要专门维护集群的槽位分配信息、节点列表，还要处理集群扩容、故障转移时的拓扑更新，甚至需要在不同节点间自动转发命令。

如果强行做成一个通用Connection，这个类会变得无比臃肿，既要处理单机的简单连接逻辑，又要兼容集群的复杂状态管理，不仅维护成本高，还会让用户在使用时容易混淆——比如在单机连接上调用集群专属的clusterInfo()命令，编译时不会报错，但运行时肯定出问题。拆分后，类型本身就做了约束，能避免这类误用。

2. 为什么要分开RedisClient和RedisClusterClient，而非通用客户端？ #

和上面的原因类似，这是关注点分离的设计思路：

• RedisClient针对单机/哨兵模式，初始化逻辑简单，只需要解析单个或哨兵节点地址，连接池管理也相对直接。
• RedisClusterClient则要在初始化时就去发现集群的所有节点，定期更新集群拓扑，处理节点故障时的自动重连和槽位迁移，这些逻辑和单机模式完全不兼容。

如果把这些逻辑塞进一个通用客户端，内部会有大量的if-else分支判断当前模式，代码可读性和可维护性会急剧下降。而且用户使用时，很可能不小心传入错误配置（比如给通用客户端传集群地址却开启单机模式），导致隐藏的bug。拆分客户端后，每种客户端只专注处理对应模式的逻辑，代码更清晰，用户也能通过类型明确当前使用的连接模式。

3. 如何通过工厂模式实现单机、集群、哨兵连接的切换？ #

你给出的代码已经有了工厂模式的雏形，我们可以把它封装得更优雅、更安全，避免强制类型转换的问题。下面是优化后的实现方案：

第一步：封装连接工厂类 #

import org.redisson.api.RedisClient;
import org.redisson.api.RedisClusterClient;
import org.redisson.api.RedisCommands;
import org.redisson.api.StatefulRedisConnection;
import org.redisson.api.StatefulRedisClusterConnection;
import org.redisson.client.RedisURI;
import org.redisson.client.codec.StringCodec;
import org.redisson.connection.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

public class RedisConnectionFactory {

    // 根据连接类型创建对应的客户端
    public static AbstractRedisClient createClient(String connectionType, RedisURI redisURI) {
        switch (connectionType.toLowerCase()) {
            case "cluster":
                return RedisClusterClient.create(redisURI);
            case "sentinel":
                // 哨兵模式需确保redisURI包含主节点名称等参数，示例：redis://sentinel-host:26379/mymaster
                return RedisClient.create(redisURI);
            case "single":
            default:
                return RedisClient.create(redisURI);
        }
    }

    // 根据客户端创建对应的连接池
    @SuppressWarnings("unchecked")
    public static GenericObjectPool<?> createConnectionPool(AbstractRedisClient client, GenericObjectPoolConfig poolConfig) {
        if (client instanceof RedisClient) {
            return ConnectionPoolSupport.createGenericObjectPool(
                () -> ((RedisClient) client).connect(StringCodec.INSTANCE),
                poolConfig
            );
        } else if (client instanceof RedisClusterClient) {
            return ConnectionPoolSupport.createGenericObjectPool(
                () -> ((RedisClusterClient) client).connect(StringCodec.INSTANCE),
                poolConfig
            );
        }
        throw new IllegalArgumentException("Unsupported client type: " + client.getClass().getName());
    }

    // 统一获取同步命令对象，避免外部处理类型转换
    public static RedisCommands<String, String> getSyncCommands(GenericObjectPool<?> pool) throws Exception {
        Object connection = pool.borrowObject();
        if (connection instanceof StatefulRedisConnection) {
            return ((StatefulRedisConnection<String, String>) connection).sync();
        } else if (connection instanceof StatefulRedisClusterConnection) {
            return ((StatefulRedisClusterConnection<String, String>) connection).sync();
        }
        throw new IllegalArgumentException("Unsupported connection type: " + connection.getClass().getName());
    }
}

第二步：使用工厂类切换连接模式 #

public class RedisDemo {
    public static void main(String[] args) throws Exception {
        // 从命令行参数获取连接类型，示例：args[0] = "cluster" / "sentinel" / "single"
        String connectionType = args[0];
        RedisURI redisURI = RedisURI.create("redis://your-redis-address");

        // 创建客户端
        AbstractRedisClient client = RedisConnectionFactory.createClient(connectionType, redisURI);
        // 创建连接池
        GenericObjectPool<?> pool = RedisConnectionFactory.createConnectionPool(client, new GenericObjectPoolConfig());

        // 使用连接执行命令
        try (RedisCommands<String, String> commands = RedisConnectionFactory.getSyncCommands(pool)) {
            String pong = commands.ping();
            System.out.println("Pong response: " + pong);
        } finally {
            pool.close();
            client.shutdown();
        }
    }
}

代码说明： #

• 把客户端创建、连接池创建、命令获取的逻辑都封装在RedisConnectionFactory里，外部只需要传入connectionType就能切换模式，无需关心内部类型转换细节。
• 哨兵模式直接复用RedisClient即可，它已经支持解析哨兵格式的地址。
• 用getSyncCommands方法统一返回RedisCommands接口，外部调用时不需要区分单机/集群的命令对象，因为集群连接的同步命令也实现了该接口。

内容的提问来源于stack exchange，提问作者javacoder