public class ModuloSharding {
    private final List<JedisPool> shards;
    
    public ModuloSharding(List<String> redisHosts, int port) {
        shards = new ArrayList<>();
        for (String host : redisHosts) {
            shards.add(new JedisPool(new JedisPoolConfig(), host, port));
        }
    }
    
    private int getShardIndex(String key) {
        return Math.abs(key.hashCode() % shards.size());
    }
    
    public String get(String key) {
        int index = getShardIndex(key);
        try (Jedis jedis = shards.get(index).getResource()) {
            return jedis.get(key);
        }
    }
    
    public void set(String key, String value) {
        int index = getShardIndex(key);
        try (Jedis jedis = shards.get(index).getResource()) {
            jedis.set(key, value);
        }
    }
    
    // 節(jié)點數(shù)變化時需要重新映射所有鍵
    public void reshardData(List<String> newHosts, int port) {
        List<JedisPool> newShards = new ArrayList<>();
        for (String host : newHosts) {
            newShards.add(new JedisPool(new JedisPoolConfig(), host, port));
        }
        
        // 這里需要遷移數(shù)據(jù)，遍歷所有鍵并重新分配
        // 實際實現(xiàn)中需要更復雜的邏輯來處理大量數(shù)據(jù)的遷移
        // ...
        
        this.shards = newShards;
    }
}

alpha:
  listen: 127.0.0.1:22121
  hash: fnv1a_64
  distribution: ketama
  auto_eject_hosts: true
  redis: true
  server_retry_timeout: 2000
  server_failure_limit: 3
  servers:
   - 127.0.0.1:6379:1
   - 127.0.0.1:6380:1
   - 127.0.0.1:6381:1

port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005 --cluster-replicas 1

// 使用Lettuce客戶端連接Redis Cluster
RedisURI redisUri = RedisURI.Builder
    .redis("127.0.0.1", 7000)
    .withTimeout(Duration.ofSeconds(60))
    .build();

RedisClusterClient clusterClient = RedisClusterClient.create(redisUri);
StatefulRedisClusterConnection<String, String> connection = clusterClient.connect();
RedisAdvancedClusterCommands<String, String> commands = connection.sync();

// 正常操作，客戶端會處理集群路由
commands.set("user:1000", "張三");
String value = commands.get("user:1000");

public class ConsistentHashSharding {
    private final SortedMap<Integer, JedisPool> circle = new TreeMap<>();
    private final int numberOfReplicas;
    private final HashFunction hashFunction;
    
    public ConsistentHashSharding(List<String> nodes, int replicas) {
        this.numberOfReplicas = replicas;
        this.hashFunction = Hashing.murmur3_32();
        
        for (String node : nodes) {
            addNode(node);
        }
    }
    
    public void addNode(String node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            String virtualNode = node + "-" + i;
            int hash = hashFunction.hashString(virtualNode, Charset.defaultCharset()).asInt();
            circle.put(hash, new JedisPool(new JedisPoolConfig(), node.split(":")[0], 
                       Integer.parseInt(node.split(":")[1])));
        }
    }
    
    public void removeNode(String node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            String virtualNode = node + "-" + i;
            int hash = hashFunction.hashString(virtualNode, Charset.defaultCharset()).asInt();
            circle.remove(hash);
        }
    }
    
    public JedisPool getNode(String key) {
        if (circle.isEmpty()) {
            return null;
        }
        
        int hash = hashFunction.hashString(key, Charset.defaultCharset()).asInt();
        
        if (!circle.containsKey(hash)) {
            SortedMap<Integer, JedisPool> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        
        return circle.get(hash);
    }
    
    public String get(String key) {
        JedisPool pool = getNode(key);
        try (Jedis jedis = pool.getResource()) {
            return jedis.get(key);
        }
    }
    
    public void set(String key, String value) {
        JedisPool pool = getNode(key);
        try (Jedis jedis = pool.getResource()) {
            jedis.set(key, value);
        }
    }
}

public class RangeSharding {
    private final TreeMap<Long, JedisPool> rangeMap = new TreeMap<>();
    
    public RangeSharding() {
        // 假設按用戶ID范圍分片
        rangeMap.put(0L, new JedisPool("redis1.example.com", 6379));      // 0-999999
        rangeMap.put(1000000L, new JedisPool("redis2.example.com", 6379)); // 1000000-1999999
        rangeMap.put(2000000L, new JedisPool("redis3.example.com", 6379)); // 2000000-2999999
        // 更多范圍...
    }
    
    private JedisPool getShardForUserId(long userId) {
        Map.Entry<Long, JedisPool> entry = rangeMap.floorEntry(userId);
        if (entry == null) {
            throw new IllegalArgumentException("No shard available for userId: " + userId);
        }
        return entry.getValue();
    }
    
    public String getUserData(long userId) {
        JedisPool pool = getShardForUserId(userId);
        try (Jedis jedis = pool.getResource()) {
            return jedis.get("user:" + userId);
        }
    }
    
    public void setUserData(long userId, String data) {
        JedisPool pool = getShardForUserId(userId);
        try (Jedis jedis = pool.getResource()) {
            jedis.set("user:" + userId, data);
        }
    }
}