spring boot 配置两个redis

pom.xml 导包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.8.0</version>
</dependency>

RedisConfig 配置

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;

/**
 * redis 相关bean的配置
 */
@EnableCaching
@Configuration
public class RedisConfig{

    @Value("${spring.top-redis.port}")
    private int redisPort;

    @Value("${spring.top-redis.timeout}")
    private int redisTimeout;

    @Value("${spring.top-redis.database}")
    private int redisDb;

    @Value("${spring.top-redis.timeout}")
    private int timeout;

    @Value("${spring.top-redis.lettuce.pool.max-active}")
    private int maxActive;

    @Value("${spring.top-redis.lettuce.pool.max-wait}")
    private int maxWait;

    @Value("${spring.top-redis.lettuce.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.top-redis.lettuce.pool.min-idle}")
    private int minIdle;

    @Value("${spring.top-redis.host}")
    private String topHost;

    @Value("${spring.top-redis.password}")
    private String topPassword;

    @Value("${spring.aop-redis.host}")
    private String aopHost;

    @Value("${spring.aop-redis.password}")
    private String aopPassword;

    /**
     * Jedis数据源
     * @param redisHost
     * @param redisAuth
     * @return
     */
/*    public RedisConnectionFactory connectionJedisFactory(String redisHost, String redisAuth) {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMaxWaitMillis(maxWait);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(false);
        poolConfig.setTestWhileIdle(true);
        JedisClientConfiguration clientConfig = JedisClientConfiguration.builder()
                .usePooling().poolConfig(poolConfig).and().readTimeout(Duration.ofMillis(redisTimeout)).build();
        // 单点redis
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        // 哨兵redis
        // RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();
        // 集群redis
        // RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
        redisConfig.setHostName(redisHost);
        redisConfig.setPassword(RedisPassword.of(redisAuth));
        redisConfig.setPort(redisPort);
        redisConfig.setDatabase(redisDb);

        return new JedisConnectionFactory(redisConfig,clientConfig);
    }*/

    /**
     * 连接池、redis客户端配置
     * @return
     */
    public LettuceClientConfiguration Lettuce(){
        //连接池配置
        GenericObjectPoolConfig genericObjectPoolConfig =
                new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);

        //redis客户端配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                builder =  LettucePoolingClientConfiguration.builder().
                commandTimeout(Duration.ofSeconds(timeout));
        builder.poolConfig(genericObjectPoolConfig);
        return builder.build();
    }

    /**
     * Lettuce 数据源
     * @return
     */
    @Bean
    public RedisConnectionFactory topConnection(){
        /* ========= 基本配置 ========= */
        //单机模式
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration(topHost,redisPort);
        redisStandaloneConfiguration.setDatabase(redisDb);
        redisStandaloneConfiguration.setPassword(topPassword);
        /* ========= 连接池通用配置 ========= */
        LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(redisStandaloneConfiguration,Lettuce());
        return lettuceConnectionFactory;
    }

    /**
     * Lettuce 数据源
     * @return
     */
    @Primary
    @Bean
    public RedisConnectionFactory aopConnection(){
        /* ========= 基本配置 ========= */
        //单机模式
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration(aopHost,redisPort);
        redisStandaloneConfiguration.setDatabase(redisDb);
        redisStandaloneConfiguration.setPassword(aopPassword);
        /* ========= 连接池通用配置 ========= */
        LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(redisStandaloneConfiguration,Lettuce());
        return lettuceConnectionFactory;
    }


    /**
     * 创建redisTemplate
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> topRedisTemplate() {
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(topConnection());
        redisTemplate.setKeySerializer(keySerializer);
        redisTemplate.setHashKeySerializer(keySerializer);
        //redisTemplate.setValueSerializer(valueSerializer);
        //redisTemplate.setHashValueSerializer(valueSerializer);
        // hash的value序列化方式采用fastJson
        redisTemplate.setHashValueSerializer(new GenericFastJsonRedisSerializer());
        // value序列化方式采用fastJson
        redisTemplate.setValueSerializer(new GenericFastJsonRedisSerializer());
        return redisTemplate;
    }

    /**
     * 创建redisTemplate
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> aopRedisTemplate() {
        StringRedisSerializer keySerializer = new StringRedisSerializer();
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(aopConnection());
        redisTemplate.setKeySerializer(keySerializer);
        //redisTemplate.setValueSerializer(valueSerializer);
        redisTemplate.setHashKeySerializer(keySerializer);
        //redisTemplate.setHashValueSerializer(valueSerializer);

        // hash的value序列化方式采用fastJson
        redisTemplate.setHashValueSerializer(new GenericFastJsonRedisSerializer());
        // value序列化方式采用fastJson
        redisTemplate.setValueSerializer(new GenericFastJsonRedisSerializer());

        return redisTemplate;
    }

}

yml文件配置

spring:
  top-redis:
    #redis连接的数据库，强制所有项目皆为0，不要更改。
    database: 0
    #redis连接地址
    host: 127.0.0.1
    #端口
    port: 6379
    #redis连接密码
    password:
    # 连接超时时间（毫秒）
    timeout: 5000
    # 连接池配置
    lettuce:
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 100
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000
        # 连接池中的最大空闲连接
        max-idle: 10
        # 连接池中的最小空闲连接
        min-idle: 10
  aop-redis:
    #redis连接地址
    host: 192.168.1.2
    #redis连接密码
    password: 123456

使用redis

@Resource
private RedisTemplate topRedisTemplate;

@Resource
private RedisTemplate aopRedisTemplate;