SpringBoot高级开发（8）SpringBoot使用Lettuce设置多个RedisTemplate实例

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifactId>
</dependency>

spring:
  redis:
    database: 0
    host: localhost
    port: 6379
    password:
    timeout: 60000
    lettuce:
      pool:
        max-active: 8 # 连接池最大连接数（使用负值表示没有限制） 默认 8
        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
        max-idle: 8 # 连接池中的最大空闲连接 默认 8
        min-idle: 0 # 连接池中的最小空闲连接 默认 0
  redis-db-2:
    database: 2
    host: 127.0.0.1
    port: 6379
    password:
    timeout: 60000
    lettuce:
      pool:
        max-active: 8
        max-wait: 8
        max-idle: 8
        min-idle: 0

package com.xiaozhangge.redis.configure;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.vavr.Tuple;
import io.vavr.Tuple6;
import org.apache.commons.lang3.StringUtils;
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.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.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * Created by xiaozhangge on 2020-01-10.
 *
 * @Value("${spring.redis-db-2.database}") int database,
 * @Value("${spring.redis-db-2.host}") String host,
 * @Value("${spring.redis-db-2.port}") int port,
 * @Value("${spring.redis-db-2.password}") String password,
 * @Value("${spring.redis-db-2.timeout}") long timeout,
 * @Value("${spring.redis-db-2.lettuce.pool.max-active}") int maxActive,
 * @Value("${spring.redis-db-2.lettuce.pool.max-wait}") int maxWait,
 * @Value("${spring.redis-db-2.lettuce.pool.max-idle}") int maxIdle,
 * @Value("${spring.redis-db-2.lettuce.pool.min-idle}") int minIdle
 */
@EnableCaching
@Configuration
public class RedisConfigure {
  /**
       * string redis Template创建操作
       *
       * @param database  Redis数据库索引
       * @param timeout   连接超时时间（秒）
       * @param maxActive 连接池最大连接数（使用负值表示沒有限制）
       * @param maxWait   连接池最大等待时间（使用负值表示沒有限制）
       * @param maxIdle   连接池中的最大空闲连接
       * @param minIdle   连接池中的最小空闲连接
       * @param host      Redis服务地址
       * @param password  Redis服务密码
       * @param port      Redis服务器连接端口
       */
      @Bean(name = "stringRedisTemplate")
      public StringRedisTemplate stringRedisTemplate(
              @Value("${spring.redis-db-2.database}")
                      int database,
              @Value("${spring.redis-db-2.timeout:5}")
                      long timeout,
              @Value("${spring.redis-db-2.lettuce.pool.max-active}")
                      int maxActive,
              @Value("${spring.redis-db-2.lettuce.pool.max-wait}")
                      int maxWait,
              @Value("${spring.redis-db-2.lettuce.pool.max-idle}")
                      int maxIdle,
              @Value("${spring.redis-db-2.lettuce.pool.min-idle}")
                      int minIdle,
              @Value("${spring.redis-db-2.host}")
                      String host,
              @Value("${spring.redis-db-2.password}")
                      String password,
              @Value("${spring.redis-db-2.port}")
                      int port
      ) {
          // connection config
          RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
          configuration.setHostName(host);
          configuration.setPort(port);
          configuration.setPassword(RedisPassword.of(password));
          configuration.setDatabase(database);

          // pool config
          GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
          genericObjectPoolConfig.setMaxTotal(maxActive);
          genericObjectPoolConfig.setMinIdle(minIdle);
          genericObjectPoolConfig.setMaxIdle(maxIdle);
          genericObjectPoolConfig.setMaxWaitMillis(maxWait);

          // create connection factory
          LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
          builder.poolConfig(genericObjectPoolConfig);
          builder.commandTimeout(Duration.ofSeconds(timeout));
          LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(
                  configuration, builder.build()
          );
          connectionFactory.afterPropertiesSet();

          // create redis template
          return createStringRedisTemplate(connectionFactory);

      }

      /**
       * 建立StringRedisTemplate
       * 此function不能加 @Bean 否则onnectionFactory 将会一律采用预设值
       */
      private StringRedisTemplate createStringRedisTemplate(
              RedisConnectionFactory redisConnectionFactory
      ) {
          StringRedisTemplate redisTemplate = new StringRedisTemplate();
          redisTemplate.setConnectionFactory(redisConnectionFactory);
          redisTemplate.setKeySerializer(new StringRedisSerializer());
          redisTemplate.setValueSerializer(new StringRedisSerializer());
          return redisTemplate;
      }
}

@Autowired
@Qualifier("first")
StringRedisTemplate firstRedisTemplate;
@Autowired
@Qualifier("stringRedisTemplate")
StringRedisTemplate secondRedisTemplate;