SpringBoot+Redis多DB动态切换

🧠 功能目标

该方案实现了 Redis 多数据库（多 DB index）环境下，通过注解或显式指定的方式在代码层自动切换 Redis 数据库，无需手动 select 操作，支持线程安全、可恢复的动态切换机制。

动态切换 Redis 库的方案适合一些小型或简单的应用场景，主要用于 资源节约、简单隔离、逻辑清晰 的情况。但随着应用的增长和流量的增加，使用 Redis 集群或其他分布式缓存方案可能会更加适应需求。

---

📦 模块组成

组件	说明
@SwitchDatabase	注解：方法粒度声明 Redis 使用哪个数据库
DatabaseSwitchAspect	AOP 切面：拦截 @SwitchDatabase 注解，自动切库
DynamicDatabaseConnectionFactory	Redis 连接工厂扩展：支持线程级别的 select(db)
RedisDatabaseSwitcher	切库控制器：封装切换逻辑
RedisUtil	Redis 工具类：封装常用 Redis 操作，同时支持传入 db 参数切库
RedisConfig	配置类：初始化动态连接工厂和 RedisTemplate

---

✅ 使用方式

✅ 方式一：使用 @SwitchDatabase 注解自动切库（推荐）

适合无侵入的服务方法层使用，自动切库，自动恢复。

@SwitchDatabase(1)
public void updateUserCache(String userId) {
    redisUtil.set("user:" + userId, "someData");
}

✅ 方式二：工具类中手动指定 db 切换（适用于底层封装或灵活需求）

redisUtil.set("shop:token:" + token, "abc", 60, TimeUnit.MINUTES, 2);

String val = redisUtil.get("shop:token:" + token, String.class, 2);

---

⚙️ 自动切换实现逻辑

1. @SwitchDatabase

注解会被 AOP 切面拦截；

1. DatabaseSwitchAspect

记录当前线程数据库 db，并切换至目标 db；

1. 方法执行完毕后自动切换回原 db，避免影响线程后续逻辑；
2. DynamicDatabaseConnectionFactory

重写了 getConnection() 方法，确保每次连接池获取连接时都执行 select(db)，真正实现动态切库；

1. 所有 Redis 操作透明进行。

---

🔄 线程安全说明

• 使用ThreadLocal 保存每个线程的 Redis DB index；
• 每次切换数据库仅在当前线程内有效；
• 切面自动恢复原数据库，确保线程复用时数据一致性。

---

📘 配置参考

application.yml:

spring:
  redis:
    host: localhost
    port: 6379
    password: your_password
    database: 0 # 默认数据库，可通过注解/参数动态切换

---

🧪 示例：完整流程

import com.zll.platform.reids.annotation.SwitchDatabase;
import com.zll.platform.reids.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 缓存AOP切换库测试类
 * @author chenxuefeng
 */
@Component
public class RedisDemoService {
    @Autowired
    private RedisUtil redisUtil;

    @SwitchDatabase(3)
    public void testWithDb3() {
        redisUtil.set("key-db3", "value3", 5, TimeUnit.MINUTES);
        String value = redisUtil.get("key-db3", String.class);
        System.out.println("从数据库3中读取的值: " + value);
    }

    @SwitchDatabase(4)
    public void testWithDb4() {
        redisUtil.set("key-db4", "value4", 5, TimeUnit.MINUTES);
        String value = redisUtil.get("key-db4", String.class);
        System.out.println("从数据库4中读取的值: " + value);
    }

    @SwitchDatabase(5)
    public void testLocked() {
        boolean locked = redisUtil.tryLock("lock:order", String.valueOf(123), 600);
        String value = redisUtil.get("lock:order", String.class);
        System.out.println("从数据库5中读取锁的值: " + value);
    }
}


//测试类
@SpringBootTest(classes = ZllPlatformApplication.class)
public class RedisUtilTest {
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private RedisDemoService demoService;
    @Autowired
    private RedisDatabaseSwitcher switcher;

    @Test
    public void testLocked() {
        // 简单加锁
        boolean locked = redisUtil.tryLock("lock:order", String.valueOf(123), 600);
        System.out.println(locked);
        // 简单释放锁
        boolean unlocked = redisUtil.unlock("lock:order", String.valueOf(123));
        System.out.println(unlocked);
    }

    @Test
    public void testLocked5() {
        demoService.testLocked();
    }


    @Test
    public void testDb3() {
        // 这里走的是代理，AOP 能生效
        demoService.testWithDb3();
    }

    @Test
    @SwitchDatabase(4)
    public void testDb4() {
        demoService.testWithDb4();
    }

    @Test
    public void testStringSetAndGet5() {
        switcher.switchDatabase(5); // 切到 db5

        redisUtil.set("test", "test", 1, TimeUnit.HOURS);
        String value = redisUtil.get("test", String.class);
        System.out.println("Get from Redis (db5): " + value);
    }


    @Test
    public void testMultiDbIsolation() {
        redisUtil.set("key1", "val-db1", 10, TimeUnit.MINUTES, 1);
        redisUtil.set("key1", "val-db2", 10, TimeUnit.MINUTES, 2);

        String v1 = redisUtil.get("key1", String.class, 1);
        String v2 = redisUtil.get("key1", String.class, 2);

        System.out.println("db1 value: " + v1);
        System.out.println("db2 value: " + v2);
    }

    @Test
    public void testStringSetAndGet() {
        redisUtil.set("test", "test", 1, TimeUnit.HOURS);
        String value = redisUtil.get("test", String.class);
        System.out.println("Get from Redis: " + value);
    }

    @Test
    public void testList() {
        redisUtil.lPush("myList", "v1");
        Object val = redisUtil.lPop("myList");
        System.out.println("Pop from List: " + val);
    }

    @Test
    public void testSet() {
        redisUtil.sAdd("mySet", "a", "b", "c");
        Set<Object> members = redisUtil.sMembers("mySet");
        System.out.println("Set Members: " + members);
    }

    @Test
    public void testHash() {
        redisUtil.hSet("myHash", "field1", "value1");
        Object val = redisUtil.hGet("myHash", "field1");
        System.out.println("Hash Value: " + val);
    }

---

💡 后期扩展建议

1. ✅ 支持 Redisson 多数据源：与 RedisDatabaseSwitcher 一致管理 RedissonClient 切换；
2. 🔒 整合分布式锁：Redisson 支持看门狗机制的锁，配合 DB 切库也能安全使用；
3. 🚀 支持缓存前缀隔离 + 库隔离混合策略：既可多库也能前缀隔离；
4. 👀 全局默认 db 支持：如未指定注解或参数时自动 fallback 到配置文件默认 db。

✅ 总结对比表格

对比项	自动切库方案（动态 DB）	单库方案（传统）
开发复杂度	高，需要自定义配置、切面	低，开箱即用
代码简洁性	高，一套工具支持多DB	低，可能需要多个 RedisTemplate
多租户支持	强，天然适配	弱，需自定义逻辑
隔离性	好，不同库物理隔离	差，需靠 key 前缀区分
性能	稍低，有 AOP 切面和上下文切换	高，无额外逻辑
可扩展性	强	弱
兼容 Redis Cluster	❌ 不支持（PS：后期上云时记得选择主从模式）	✅ 支持