springBoot Redis 多数据源 完整测试

springboot配置redis多数据源目录.png

前言：
项目：springboot2.0.5 + redis + swagger2
测试目的：配置redis多数据源
配置数据源个数: 这里配置了双数据源，可以复制配置多数据源。

这里的测试，可以直接拿到项目中使用，可以无脑复制及使用！

1、配置依赖 pom.xml

   
   
      org.springframework.boot
      spring-boot-starter-data-redis
      2.0.5.RELEASE
   
   
      redis.clients
      jedis
      2.9.0
   

   
      org.projectlombok
      lombok
       1.16.18
      true
   

   
      org.springframework.boot
      spring-boot-starter-web
      2.0.5.RELEASE
   
   
      org.springframework.boot
      spring-boot-starter-tomcat
      2.0.5.RELEASE
      provided
   
   
      org.springframework.boot
      spring-boot-starter-test
      2.0.5.RELEASE
      test
   

   
   
      io.swagger
      swagger-models
      1.5.21
      compile
   
   
      io.swagger
      swagger-annotations
      1.5.21
      compile
   
   
      io.springfox
      springfox-swagger-ui
      2.9.2
   
   
      io.springfox
      springfox-swagger2
      2.9.2
      
         
            io.swagger
            swagger-models
         
         
            io.swagger
            swagger-annotations
         
      
   
   

2、redis配置 application.yml

# 主配置文件主要用来存放公共设置，不受环境配置影响
server:
  port: 8080
  servlet:
    context-path: /springboot-test-redis2
spring:
  redis:
    database: 6   # Redis数据库索引（默认为0）
    host: 127.0.0.1  # Redis服务器地址
    port: 6379         # Redis服务器连接端口
    password:    # Redis服务器连接密码（默认为空）
    max-wait: 30000    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    max-active: 100   # 连接池最大连接数（使用负值表示没有限制）
    max-idle: 20     # 连接池中的最大空闲连接
    min-idle: 0     # 连接池中的最小空闲连接
    timeout: 5000  # 连接超时时间（毫秒）
  #自定义配置
  redis2:
    database: 5   # Redis数据库索引（默认为0）
    host: 192.168.2.169  # Redis服务器地址，若测试也可以用127.0.0.1本地的redis，因为database索引库用的不是一个
    port: 6379         # Redis服务器连接端口
    password:    # Redis服务器连接密码（默认为空）
    timeout: 5000  # 连接超时时间（毫秒）
    

3、在config文件下配置redis多实例

RedisConfig.ava

package com.dist.config;

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.CachingConfigurerSupport;
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.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.ObjectUtils;

import java.time.Duration;

/**设置Redis多实例的基类
 * @author [email protected]
 * @data 2019/7/29 10:17
 */
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport{

    /**
     * 数据源1 默认配置(127.0.0.1) redis template
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return createRedisTemplate(redisConnectionFactory);
    }

    /**
     * 数据源2 redis template
     */
    @Bean
    public RedisTemplate redisTemplate2(
            @Value("${spring.redis2.database}") int database,
            @Value("${spring.redis.timeout}") long timeout,
            @Value("${spring.redis.max-active}") int maxActive,
            @Value("${spring.redis.max-wait}") int maxWait,
            @Value("${spring.redis.max-idle}") int maxIdle,
            @Value("${spring.redis.min-idle}") int minIdle,

            @Value("${spring.redis2.host}") String hostName,
            @Value("${spring.redis2.port}") int port,
            @Value("${spring.redis2.password}") String password) {

        /* ========= 基本配置 ========= */
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName(hostName);
        configuration.setPort(port);
        configuration.setDatabase(database);
        if (!ObjectUtils.isEmpty(password)) {
            RedisPassword redisPassword = RedisPassword.of(password);
            configuration.setPassword(redisPassword);
        }

        /* ========= 连接池通用配置 ========= */
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);

        /* ========= jedis pool ========= */
        /*
        JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration
                .builder();
        builder.connectTimeout(Duration.ofSeconds(timeout));
        builder.usePooling();
        builder.poolConfig(genericObjectPoolConfig);
        JedisConnectionFactory connectionFactory = new JedisConnectionFactory(configuration, builder.build());
        // 连接池初始化
        connectionFactory.afterPropertiesSet();
        */

        /* ========= lettuce pool ========= */
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
        builder.poolConfig(genericObjectPoolConfig);
        builder.commandTimeout(Duration.ofSeconds(timeout));
        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, builder.build());
        connectionFactory.afterPropertiesSet();

        /* ========= 创建 template ========= */
        return createRedisTemplate(connectionFactory);
    }

    /**
     * json 实现 redisTemplate
     * 

     * 该方法不能加 @Bean 否则不管如何调用，connectionFactory都会是默认配置
     *
     * @param redisConnectionFactory
     * @return
     */
    public RedisTemplate createRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer