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);
    }
}