Redis解决key冲突的问题解决

// 用户服务数据访问层
public class UserDAO {
    private JedisPool userPool;
    
    public UserDAO() {
        // 初始化专用连接池(DB1)
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(20);
        userPool = new JedisPool(config, "redis-host", 6379, 2000, null, 1); // 最后一个参数指定DB1
    }
    
    public String getUserInfo(long userId) {
        try (Jedis jedis = userPool.getResource()) {
            // 无需再select，连接池已固定DB1
            return jedis.get("user:info:" + userId);
        }
    }
}

// 订单服务数据访问层
public class OrderDAO {
    private JedisPool orderPool;
    
    public OrderDAO() {
        // 初始化订单专用连接池(DB2)
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(15);
        orderPool = new JedisPool(config, "redis-host", 6379, 2000, null, 2); // 指定DB2
    }
    // ...订单相关操作
}

// 分布式ID生成器实现
public class DistributedIdGenerator {
    private Jedis jedis;
    private String bizKey;
    
    public DistributedIdGenerator(String bizType) {
        this.jedis = new Jedis("redis-host");
        this.bizKey = "id_generator:" + bizType;
    }
    
    public long generateId() {
        while (true) {
            long current = Long.parseLong(jedis.get(bizKey) == null ? "0" : jedis.get(bizKey));
            long newId = current + 1;
            // 原子性设置新值
            if (jedis.setnx(bizKey, String.valueOf(newId)) == 1) {
                return newId;
            }
            // 短暂等待后重试
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("ID生成中断");
            }
        }
    }
}

# 库存扣减的原子操作
WATCH product:stock:1001
GET product:stock:1001
MULTI
DECRBY product:stock:1001 1
EXEC

public class RedisDistributedLock {
    private JedisPool jedisPool;
    private String lockKey;
    private String lockValue;
    private long expireTime;
    
    public RedisDistributedLock(JedisPool pool, String key, long expireMs) {
        this.jedisPool = pool;
        this.lockKey = "lock:" + key;
        this.lockValue = UUID.randomUUID().toString();
        this.expireTime = expireMs;
    }
    
    public boolean tryLock() {
        try (Jedis jedis = jedisPool.getResource()) {
            String result = jedis.set(lockKey, lockValue, 
                SetParams.setParams().nx().px(expireTime));
            return "OK".equals(result);
        }
    }
    
    public void unlock() {
        try (Jedis jedis = jedisPool.getResource()) {
            // 使用Lua脚本保证原子性
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('del', KEYS[1]) " +
                           "else return 0 end";
            jedis.eval(script, Collections.singletonList(lockKey), 
                      Collections.singletonList(lockValue));
        }
    }
    
    // 自动续期实现
    public boolean renew() {
        try (Jedis jedis = jedisPool.getResource()) {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('pexpire', KEYS[1], ARGV[2]) " +
                           "else return 0 end";
            Object result = jedis.eval(script, Collections.singletonList(lockKey), 
                                     Arrays.asList(lockValue, String.valueOf(expireTime)));
            return "1".equals(result.toString());
        }
    }
}

// 使用哈希标签强制某些key分配到相同slot
// 订单及其明细应当在同一节点
String orderKey = "order:{10086}";
String orderDetailKey = "order:{10086}:detail";

// 商品和库存应当在同一节点
String productKey = "product:{5002}";
String stockKey = "stock:{5002}";

class RedisMultiTenant:
    def __init__(self, tenant_id):
        self.namespace = f"tenant_{tenant_id}"
        self.redis = redis.StrictRedis()
    
    def make_key(self, key):
        return f"{self.namespace}:{key}"
    
    def set(self, key, value):
        return self.redis.set(self.make_key(key), value)
    
    def get(self, key):
        return self.redis.get(self.make_key(key))

# 使用示例
tenant_a = RedisMultiTenant("A")
tenant_a.set("user:1001", "Alice")  # 实际key: "tenant_A:user:1001"

tenant_b = RedisMultiTenant("B") 
tenant_b.set("user:1001", "Bob")    # 实际key: "tenant_B:user:1001"

// 基于Spring EL表达式的动态命名空间解析
public class DynamicNamespaceRedisTemplate extends RedisTemplate<String, Object> {
    
    private ExpressionParser parser = new SpelExpressionParser();
    
    @Override
    protected <K> K preProcessKey(K key) {
        if (key instanceof String) {
            String keyStr = (String) key;
            // 解析表达式如"#tenant.id + ':user:' + #userId"
            if (keyStr.contains("#")) {
                EvaluationContext context = getEvaluationContext();
                Expression exp = parser.parseExpression(keyStr);
                return (K) exp.getValue(context);
            }
        }
        return key;
    }
    
    private EvaluationContext getEvaluationContext() {
        // 从线程上下文获取租户信息等
        return new StandardEvaluationContext();
    }
}

# application.yml
spring:
  profiles:
    active: dev
  redis:
    namespace: ${spring.profiles.active}

@Configuration
public class RedisConfig {
    
    @Value("${spring.redis.namespace}")
    private String namespace;
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置命名空间前缀
        template.setKeySerializer(new StringRedisSerializer() {
            @Override
            public byte[] serialize(String key) {
                return super.serialize(namespace + ":" + key);
            }
        });
        // 其他配置...
        return template;
    }
}

public boolean safeSetKey(Jedis jedis, String key, String value) {
    // 检查key是否已存在
    Boolean keyExists = jedis.exists(key);
    
    if (keyExists) {
        // 触发告警（如日志打印、监控告警）
        System.err.println("警告：key冲突！冲突key为：" + key);
        
        // 记录冲突上下文（如当前时间、调用栈、value），便于排查
        logConflict(key, value, Thread.currentThread().getStackTrace());
        
        return false; // 拒绝写入，避免覆盖
    }
    
    // 不存在则写入
    jedis.set(key, value);
    return true;
}

// 记录冲突日志
private void logConflict(String key, String value, StackTraceElement[] stackTrace) {
    String log = String.format(
        "Key冲突日志 - 时间：%s，Key：%s，新Value：%s，调用栈：%s",
        new Date(), key, value, Arrays.toString(stackTrace)
    );
    
    // 写入日志文件或监控系统（如ELK、Prometheus）
    try (FileWriter writer = new FileWriter("redis_key_conflict.log", true)) {
        writer.write(log + "\n");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

import redis
import time
from collections import defaultdict

def scan_redis_keys(host="localhost", port=6379, db=0, pattern="*", scan_count=1000):
    """
    扫描Redis key，统计key的出现次数（次数>1即为冲突）
    """
    r = redis.Redis(host=host, port=port, db=db)
    cursor = 0
    key_count = defaultdict(int)  # 存储key出现次数
    conflict_keys = []  # 冲突key列表
    
    while True:
        # 分批扫描：cursor=0开始，match匹配模式，count每次扫描数量
        cursor, keys = r.scan(cursor=cursor, match=pattern, count=scan_count)
        
        for key in keys:
            key_str = key.decode("utf-8")
            key_count[key_str] += 1
            
            # 若出现次数>1，判定为冲突
            if key_count[key_str] > 1:
                conflict_keys.append(key_str)
        
        # 游标为0时扫描结束
        if cursor == 0:
            break
            
        time.sleep(0.1)  # 避免频繁扫描占用Redis资源
    
    # 输出扫描结果
    print(f"扫描完成，共扫描到{len(key_count)}个不同key")
    if conflict_keys:
        print(f"发现{len(conflict_keys)}个冲突key：")
        for key in set(conflict_keys):  # 去重
            print(f"- {key}（出现次数：{key_count[key]}）")
    else:
        print("未发现冲突key")
    
    return key_count, conflict_keys

# 执行扫描（匹配所有key，每次扫描1000个）
scan_redis_keys(pattern="*", scan_count=1000)

# 每天凌晨2点执行扫描
0 2 * * * /usr/bin/python3 /path/to/scan_redis_keys.py >> /var/log/redis_key_scan.log 2>&1

redis-check-aof --fix --truncate-to-timestamp 1650000000 appendonly.aof 

// 初始化Redisson客户端（生产环境建议使用连接池）
Config config = new Config();
config.useSingleServer()
      .setAddress("redis://redis-cluster:6379")
      .setPassword("secure_password")
      .setConnectionPoolSize(32);
RedissonClient redisson = Redisson.create(config);

public boolean updateOrderStatus(String orderId, String newStatus) {
    // 创建分布式锁实例
    RLock lock = redisson.getLock("lock:order:status:" + orderId);
    try (Jedis jedis = jedisPool.getResource()) {
        // 尝试获取锁（等待5秒，锁定10秒）
        if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
            try {
                // 获取当前状态
                String currentStatus = jedis.get("order:status:" + orderId);
                
                // 状态机校验（示例：只允许"待支付"→"已支付"）
                if ("待支付".equals(currentStatus) && "已支付".equals(newStatus)) {
                    // 使用事务保证原子性
                    Transaction tx = jedis.multi();
                    tx.set("order:status:" + orderId, newStatus);
                    tx.exec();
                    logStatusChange(orderId, currentStatus, newStatus); // 记录日志
                    return true;
                }
                return false;
            } finally {
                // 确保只有持有锁的线程才能解锁
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
        }
        throw new BusyException("系统繁忙，请稍后重试");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("操作被中断", e);
    }
}