Redis数据分区的四大核心策略,对比范围分区、哈希分区、一致性哈希和客户端分片的实现

# Python + redis-py技术栈示例
import redis

# 创建按用户ID范围分布的分片连接
shard_1 = redis.Redis(host='node1', port=6379, db=0)  # 处理UID 0-9999
shard_2 = redis.Redis(host='node2', port=6379, db=0)  # 处理UID 10000-19999

def range_shard(uid):
    return shard_1 if uid < 10000 else shard_2

# 存储用户购物车数据
def set_cart(uid, items):
    client = range_shard(uid)
    client.hset(f'cart:{uid}', mapping=items)

# 使用CRC16算法实现哈希分片
from rediscluster import RedisCluster

# 配置3个节点组成的集群
startup_nodes = [
    {"host": "node1", "port": "6379"},
    {"host": "node2", "port": "6380"},
    {"host": "node3", "port": "6381"}
]

cluster = RedisCluster(startup_nodes=startup_nodes, decode_responses=True)

def hash_shard(key):
    # Redis原生使用CRC16算法
    slot = cluster.keyslot(key)
    return cluster.get_node_from_slot(slot)

# 存储商品库存
def set_stock(item_id, quantity):
    cluster.hset("inventory", item_id, quantity)

import hashlib
from bisect import bisect

class ConsistentHash:
    def __init__(self, nodes, virtual_nodes=200):
        self.ring = []
        self.nodes = {}
        for node in nodes:
            for i in range(virtual_nodes):
                key = f"{node}-{i}"
                hash_val = int(hashlib.md5(key.encode()).hexdigest(), 16)
                self.ring.append(hash_val)
                self.nodes[hash_val] = node
        self.ring.sort()

    def get_node(self, key):
        hash_val = int(hashlib.md5(key.encode()).hexdigest(), 16)
        idx = bisect(self.ring, hash_val) % len(self.ring)
        return self.nodes[self.ring[idx]]

# 初始化4个物理节点
nodes = ['redis-node1', 'redis-node2', 'redis-node3', 'redis-node4']
ch = ConsistentHash(nodes)

# 存储会话数据
def store_session(session_id, data):
    node = ch.get_node(session_id)
    conn = redis.Redis(host=node, port=6379)
    conn.setex(session_id, 3600, data)

from hashlib import sha256

class ShardedRedis:
    def __init__(self, nodes):
        self.nodes = nodes
    
    def _get_shard(self, key):
        key_hash = int(sha256(key.encode()).hexdigest(), 16)
        return self.nodes[key_hash % len(self.nodes)]
    
    def set(self, key, value):
        node = self._get_shard(key)
        return node.set(key, value)
    
    def get(self, key):
        node = self._get_shard(key)
        return node.get(key)

# 初始化三个分片实例
shards = [
    redis.Redis(host='shard1', port=6379),
    redis.Redis(host='shard2', port=6380),
    redis.Redis(host='shard3', port=6381)
]

client = ShardedRedis(shards)

# 存储文章阅读量
def incr_article_view(article_id):
    client.incr(f"article:{article_id}:views")

def safe_set(self, key, value, retries=3):
    for _ in range(retries):
        try:
            return self._get_shard(key).set(key, value)
        except redis.ConnectionError:
            continue
    raise Exception("All shards unavailable")