如何实现在Redis集群情况下，同一类数据固定保存在同一个Redis实例中

山高自有客行路

已于 2025-02-25 14:45:05 修改

阅读量438

点赞数 3

分类专栏： Java Redis 文章标签： redis 数据库

于 2025-02-25 12:15:18 首次发布

本文链接：https://blog.youkuaiyun.com/m0_50742275/article/details/145848550

版权

Java 同时被 2 个专栏收录

60 篇文章

订阅专栏

Redis

6 篇文章

订阅专栏

1. 使用哈希标签（Hash Tags）

概述

Redis Cluster使用一致性哈希算法来分配数据到不同的节点上。为了确保相同类型的数据被分配到同一个Redis实例上，可以利用哈希标签（Hash Tags）。哈希标签是指在键名中用花括号 {} 包围的部分，Redis会根据这部分内容计算哈希值，并将其分配到相应的插槽。

关键点

哈希标签：键名中被 {} 包围的部分用于计算哈希值。
插槽分配：相同的哈希标签部分会导致相同的哈希值，从而保证数据分配到同一个插槽。

2. 键设计与哈希标签的结合

示例场景

假设我们有一个用户资料系统，每种类型的用户资料都有一个唯一的 typeId，我们希望所有 typeId=1 的用户资料都存储在同一个Redis实例上。

实现步骤

定义键格式：为每个类型的键添加 {typeId} 前缀，并使用哈希标签来确保同类型的数据被分配到相同的插槽。
操作示例：通过Java代码演示如何实现这一目标。

详细代码示例

1. 定义键生成函数

public class KeyGenerator {

    // 定义生成键的方法，确保包含哈希标签
    public static String generateKeyWithHashTag(String typeId, String uniqueId) {
        return String.format("{user:type:%s}:profile:%s", typeId, uniqueId);
    }

    public static void main(String[] args) {
        // 测试键生成函数
        String key1 = generateKeyWithHashTag("1", "12345");
        String key2 = generateKeyWithHashTag("1", "67890");

        System.out.println(key1);  // 输出：{user:type:1}:profile:12345
        System.out.println(key2);  // 输出：{user:type:1}:profile:67890
    }
}

2. Redis Cluster操作

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

import java.util.HashSet;
import java.util.Set;

public class RedisClusterTypeExample {

    // 定义生成键的方法，确保包含哈希标签
    public static String generateKeyWithHashTag(String typeId, String uniqueId) {
        return String.format("{user:type:%s}:profile:%s", typeId, uniqueId);
    }

    public static void main(String[] args) {
        // 设置Redis集群节点
        Set<HostAndPort> jedisClusterNodes = new HashSet<>();
        jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7000));
        jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7001));
        jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7002));

        try (JedisCluster jedisCluster = new JedisCluster(jedisClusterNodes)) {
            // 定义typeId
            String typeId = "1";

            // 使用哈希标签确保同类型的数据在同一插槽
            String userKey1 = generateKeyWithHashTag(typeId, "12345");
            String userKey2 = generateKeyWithHashTag(typeId, "67890");

            // 存储用户资料
            jedisCluster.set(userKey1, "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");
            jedisCluster.set(userKey2, "{\"name\": \"Jane Doe\", \"email\": \"jane@example.com\"}");

            // 获取用户资料
            String userData1 = jedisCluster.get(userKey1);
            System.out.println(userData1);  // 输出：{"name": "John Doe", "email": "john@example.com"}

            String userData2 = jedisCluster.get(userKey2);
            System.out.println(userData2);  // 输出：{"name": "Jane Doe", "email": "jane@example.com"}

            // 清理测试数据
            jedisCluster.del(userKey1);
            jedisCluster.del(userKey2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

详细说明

1. 键生成函数

public static String generateKeyWithHashTag(String typeId, String uniqueId) {
    return String.format("{user:type:%s}:profile:%s", typeId, uniqueId);
}

{user:type:1}：这是哈希标签部分，Redis会根据这部分内容计算哈希值。
:profile:12345 和 :profile:67890：这是具体的数据标识部分，不会影响哈希值的计算。

2. Redis Cluster操作

Set<HostAndPort> jedisClusterNodes = new HashSet<>();
jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7000));
jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7001));
jedisClusterNodes.add(new HostAndPort("127.0.0.1", 7002));

try (JedisCluster jedisCluster = new JedisCluster(jedisClusterNodes)) {
    // ... 其他操作 ...
}

Redis Cluster节点配置：指定多个节点以形成一个Redis集群。
JedisCluster 对象：用于与Redis集群进行交互。

3. 数据操作

String userKey1 = generateKeyWithHashTag(typeId, "12345");
String userKey2 = generateKeyWithHashTag(typeId, "67890");

// 存储用户资料
jedisCluster.set(userKey1, "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");
jedisCluster.set(userKey2, "{\"name\": \"Jane Doe\", \"email\": \"jane@example.com\"}");

// 获取用户资料
String userData1 = jedisCluster.get(userKey1);
System.out.println(userData1);

String userData2 = jedisCluster.get(userKey2);
System.out.println(userData2);

// 清理测试数据
jedisCluster.del(userKey1);
jedisCluster.del(userKey2);

设置和获取数据：通过 set 和 get 方法操作Redis中的数据。
清理测试数据：使用 del 方法删除不再需要的数据。

最佳实践

1. 错误处理

确保捕获并处理所有可能的异常，避免程序崩溃。特别是在网络不稳定或Redis服务不可用的情况下。

try {
    // Redis操作
} catch (Exception e) {
    e.printStackTrace();  // 或者记录日志
}

例如，在上述代码中，我们在 main 方法中已经包含了 try-catch 块来捕获异常。

2. 性能优化

连接池：使用 JedisPool 来管理与Redis集群的连接，避免频繁创建和销毁连接带来的开销。

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Jedis;

public class RedisConnectionPoolExample {
    private static final JedisPool pool = new JedisPool("localhost", 6379);

    public static void main(String[] args) {
        try (Jedis jedis = pool.getResource()) {
            jedis.set("user:profile:12345", "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");
            String userData = jedis.get("user:profile:12345");
            System.out.println(userData);  // 输出：{"name": "John Doe", "email": "john@example.com"}

            jedis.del("user:profile:12345");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

批量操作：尽量使用批量操作（如 mset 和 mget），减少网络往返次数。

Map<String, String> dataMap = new HashMap<>();
dataMap.put("user:profile:12345", "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");
dataMap.put("user:profile:67890", "{\"name\": \"Jane Doe\", \"email\": \"jane@example.com\"}");

// 批量设置数据
jedis.mset(dataMap);

// 批量获取数据
List<String> keys = Arrays.asList("user:profile:12345", "user:profile:67890");
List<String> values = jedis.mget(keys.toArray(new String[0]));
for (String value : values) {
    System.out.println(value);
}

3. 数据一致性

在分布式环境中，使用分布式锁或其他机制来保证数据的一致性，尤其是在并发写入场景下。

import redis.clients.jedis.Jedis;

public class RedisDistributedLockExample {
    private static final String LOCK_KEY = "lock:key";

    public static void main(String[] args) {
        try (Jedis jedis = new Jedis("localhost")) {
            String lockValue = "lock-value";
            long timeout = 10000;  // 超时时间10秒

            // 尝试获取锁
            long end = System.currentTimeMillis() + timeout;
            boolean isLocked = false;
            while (System.currentTimeMillis() < end) {
                if (jedis.setnx(LOCK_KEY, lockValue) == 1) {
                    isLocked = true;
                    break;
                }
                Thread.sleep(100);  // 等待100毫秒后重试
            }

            if (isLocked) {
                try {
                    // 执行需要加锁的操作
                    jedis.set("user:profile:12345", "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");
                } finally {
                    // 释放锁
                    if (lockValue.equals(jedis.get(LOCK_KEY))) {
                        jedis.del(LOCK_KEY);
                    }
                }
            } else {
                System.out.println("Failed to acquire lock.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

扩展性考虑

Redis集群扩展：如果系统规模进一步扩大，可以增加Redis集群节点的数量，Redis Cluster会自动重新分配数据。
监控和维护：定期监控Redis集群的状态，确保其健康运行。可以使用Prometheus、Grafana等工具进行监控。

具体应用场景示例

1. 用户资料系统

假设我们有一个用户资料系统，每个用户的资料包括姓名和电子邮件地址。我们需要确保所有属于特定类型的用户资料（例如 typeId=1）都存储在同一个Redis实例上。

步骤：

定义键格式：

public static String generateUserKey(String typeId, String userId) {
    return String.format("{user:type:%s}:profile:%s", typeId, userId);
}

存储用户资料：

String userKey = generateUserKey("1", "12345");
jedisCluster.set(userKey, "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}");

读取用户资料：

String userData = jedisCluster.get(userKey);
System.out.println(userData);  // 输出：{"name": "John Doe", "email": "john@example.com"}

2. 日志系统

假设我们有一个日志系统，不同类型的日志（例如 logType=error 和 logType=info）需要分别存储在不同的Redis实例上。

步骤：

定义键格式：

public static String generateLogKey(String logType, String logId) {
    return String.format("{log:type:%s}:entry:%s", logType, logId);
}

存储日志条目：

String errorLogKey = generateLogKey("error", "1");
jedisCluster.set(errorLogKey, "{\"message\": \"An error occurred\", \"timestamp\": \"2025-02-25T14:35:00Z\"}");

读取日志条目：

String errorLogData = jedisCluster.get(errorLogKey);
System.out.println(errorLogData);  // 输出：{"message": "An error occurred", "timestamp": "2025-02-25T14:35:00Z"}

总结

通过上述详细的实现步骤和代码示例，你可以确保同一类数据固定保存在同一个Redis实例中。这种方法不仅适用于用户资料系统和日志系统，还可以广泛应用于其他需要对不同类型数据进行分类管理的场景。通过合理设计键结构和利用哈希标签，可以简化数据管理和查询操作，同时提高系统的可维护性和性能。此外，结合错误处理、性能优化和数据一致性机制，可以构建一个更加健壮和高效的Redis应用。