spring-and-redis

springboot集成多redis

定义xxxProperties和xxxRedisTemplate，不要定义xxxConnectFactory
也不要使用RedisProperties。复制成一份xxxProperties。

示例代码如下：

定义一个OneRedisProperties，把RedisProperties的代码复制到这里即可。

package com.xxx.config.redis;

import java.time.Duration;
import java.util.List;

public class OneRedisProperties {
// 把RedisProperties的代码复制到这里即可。
}

定义OneRedisTemplate

package com.xxx.config.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.ruoyi.common.redis.configure.FastJson2JsonRedisSerializer;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Objects;

@Configuration
public class OneRedisTemplateConfig {
    @Bean
    @ConfigurationProperties(prefix = "one.redis")
    public OneRedisProperties oneRedisProperties() {
        return new OneRedisProperties();
    }


    // 核心：参考 RedisAutoConfiguration 动态创建连接工厂
    private RedisConnectionFactory createConnectionFactory(OneRedisProperties properties) {
        RedisConfiguration redisConfiguration;
        RedisProperties.Cluster cluster = properties.getCluster();
        if (Objects.nonNull(cluster)) {
            RedisClusterConfiguration clusterCfg = new RedisClusterConfiguration(cluster.getNodes());
            if (Objects.nonNull(properties.getPassword())) {
                clusterCfg.setPassword(properties.getPassword());
            }
            redisConfiguration = clusterCfg;
        } else {
            RedisStandaloneConfiguration standaloneCfg = new RedisStandaloneConfiguration();
            standaloneCfg.setHostName(properties.getHost());
            standaloneCfg.setPort(properties.getPort());
            standaloneCfg.setDatabase(properties.getDatabase());
            if (Objects.nonNull(properties.getPassword())) {
                standaloneCfg.setPassword(properties.getPassword());
            }
            redisConfiguration = standaloneCfg;
        }
        // 调用 Spring 原生的连接工厂创建逻辑（Lettuce 是默认客户端）
        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisConfiguration);
        factory.afterPropertiesSet();
        return factory;
    }

    @Bean("oneRedisTemplate")
    public RedisTemplate<Object, Object> oneRedisTemplate(
            @Qualifier("oneRedisProperties") OneRedisProperties oneRedisProperties) {
        RedisConnectionFactory cf = createConnectionFactory(oneRedisProperties);
        return createRedisTemplate(cf);
    }

    // 复用 Spring 风格的序列化配置（与默认 RedisTemplate 保持一致）
    public RedisTemplate<Object, Object> createRedisTemplate(RedisConnectionFactory connectionFactory) {
        // 如下配置仅供参考。
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
    /*
    若是定义了这个，会导致默认的RedisTemplate使用该连接工厂，索引可能会出错
    @Bean("oneRedisConnectionFactory")
    public RedisConnectionFactory oneRedisConnectionFactory(
            @Qualifier("oneRedisProperties") OneRedisProperties oneRedisProperties) {
        return createConnectionFactory(oneRedisProperties);
    }
     */
}

总结：只暴露 OneRedisProperties 和 OneRedisTemplate 两个bean。