redis设置多租户

为了实现Redis的多租户，我们可以使用Redis的多数据库特性，为每个租户分配一个独立的数据库。同时，我们还需要使用Spring Boot的多数据源配置来实现多Redis数据源的配置。以下是实现Redis多租户的步骤：

1.在Redis中为每个租户分配一个独立的数据库，可以使用SELECT命令来切换数据库。例如，使用SELECT 0选择第一个数据库，使用SELECT 1选择第二个数据库，以此类推。

2.在Spring Boot中配置多Redis数据源，可以使用MultiRedisTemplate来实现。MultiRedisTemplate是一个自定义的RedisTemplate，它可以管理多个Redis数据源。我们需要在配置文件中为每个Redis数据源配置不同的属性，例如host、port、password等。

3.在Redis数据源上下文切换RedisConfig中，我们需要使用ThreadLocal来存储当前租户的数据库编号。在每次访问Redis时，我们需要根据当前租户的数据库编号来切换到对应的数据库。

以下是一个简单的示例代码，演示如何实现Redis多租户：

// Redis多租户配置类
@Configuration
public class MultiRedisConfig {
    @Bean(name = "redis1")
    @ConfigurationProperties(prefix = "spring.redis1")
    public JedisConnectionFactory redis1ConnectionFactory() {
        return new JedisConnectionFactory();
    }

    @Bean(name = "redis2")
    @ConfigurationProperties(prefix = "spring.redis2")
    public JedisConnectionFactory redis2ConnectionFactory() {
        return new JedisConnectionFactory();
    }

    @Bean(name = "multiRedisTemplate")
    public MultiRedisTemplate multiRedisTemplate(@Qualifier("redis1") RedisConnectionFactory redis1ConnectionFactory,
                                                 @Qualifier("redis2") RedisConnectionFactory redis2ConnectionFactory) {
        MultiRedisTemplate multiRedisTemplate = new MultiRedisTemplate();
        Map<String, RedisConnectionFactory> connectionFactoryMap = new HashMap<>();
        connectionFactoryMap.put("redis1", redis1ConnectionFactory);
        connectionFactoryMap.put("redis2", redis2ConnectionFactory);
        multiRedisTemplate.setTargetRedisTemplateMap(connectionFactoryMap);
        return multiRedisTemplate;
    }
}

// Redis数据源上下文切换类
public class RedisContextHolder {
    private static final ThreadLocal<Integer> contextHolder = new ThreadLocal<>();

    public static void setDataSource(Integer dataSource) {
        contextHolder.set(dataSource);
    }

    public static Integer getDataSource() {
        return contextHolder.get();    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

// Redis多租户模板类
public class MultiRedisTemplate extends RedisTemplate<String, Object> {
    private Map<String, RedisConnectionFactory> targetRedisTemplateMap;

    @Override
    public void afterPropertiesSet() {
        RedisConnectionFactory defaultTargetConnectionFactory = targetRedisTemplateMap.get("redis1");
        setConnectionFactory(defaultTargetConnectionFactory);
        super.afterPropertiesSet();
    }

    @Override
    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
        Integer dataSource = RedisContextHolder.getDataSource();
        if (dataSource != null) {
            RedisConnectionFactory targetConnectionFactory = targetRedisTemplateMap.get("redis" + dataSource);
            connection = targetConnectionFactory.getConnection();
        }
        return super.preProcessConnection(connection, existingConnection);
    }

    public void setTargetRedisTemplateMap(Map<String, RedisConnectionFactory> targetRedisTemplateMap) {
        this.targetRedisTemplateMap = targetRedisTemplateMap;
    }
}

// 在业务代码中使用Redis多租户模板类
@Service
public class RedisService {
    @Autowired
    private MultiRedisTemplate multiRedisTemplate;

    public void setValue(String key, Object value) {
        RedisContextHolder.setDataSource(1); // 切换到第二个数据库
        multiRedisTemplate.opsForValue().set(key, value);
        RedisContextHolder.clearDataSource(); // 切换回默认数据库
    }

    public Object getValue(String key) {
        RedisContextHolder.setDataSource(2); // 切换到第三个数据库
        Object value = multiRedisTemplate.opsForValue().get(key);
        RedisContextHolder.clearDataSource(); // 切换回默认数据库
        return value;
    }
}