//最近发现redis 数据都是默认存在db0的 看着就崩溃了。这么做无非就是想让不同类型的数据属于不同的应用程序而彼此分开 后面自己总结了三种方法给大家分享下 有什么不足的地方大家也可以指出来哦

提供了三种方式 切换db的方法 

1- 第一种方式最简单 先看看redis 的yml 文件的配置 这个是单机的配配置

spring:
  thymeleaf:
    cache: false
  redis:
    #REDIS 数据库索引（默认为0）
    database: 0
    #redis服务地址
    host: 127.0.0.1
    #redis服务连接端口
    port: 6379
    #redis密码（没有密码默认为空）
    password:
    #连接池最大连接数（使用负值表示没有限制）
    jedis:
      pool:
        max-active: 8
    lettuce:
      pool:
        #连接池最大堵塞等待时间（使用负值表示没有限制）
        max-wait: -1
        #连接池最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 0
        #连接超时时间（毫秒）
    timeout: 5000

第二步 我们用最简单的方法实现切库

    /**
     * 添加字符串
     *
     * @param key
     */
    @RequestMapping("/ha")
    @ResponseBody
    public void demo02(String key) {
        //Redis服务
        Jedis jedis = new  Jedis();
        //切库表示你要存的db几
        jedis.select(10);
        //写进数据
        jedis.set("K1", key);
        System.out.println(key);
    }

 2- 现在介绍第二种方式切换的方式

2-1 :先配置yml文件的信息@value 调用的方法 

redis:
  #REDIS 数据库索引（默认为0）
  database: 0
  #redis服务地址
  host: 127.0.0.1
  #redis服务连接端口
  port: 6379
  #redis密码（没有密码默认为空）
  password:
  #连接池最大连接数（使用负值表示没有限制）
  #连接池最大堵塞等待时间（使用负值表示没有限制）
  maxWait: -1
  #连接池最大空闲连接
  maxIdle: 8
  #连接池中的最小空闲连接
  minIdle: 0
  #连接超时时间（毫秒）
  timeout: 5000
  #redis切库默认0默认第一个值 表示现在只能切换db0和db1如果想切换更多的可以在逗号后面多添加几个值
  dbs: 0,1

2-2:我们看下配置 容器下的配置

package com.lwq.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.PostConstruct;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Component
@Slf4j
public class redisDbConfig {
    @Value("${redis.host}")
    private String hostName;
    @Value("${redis.port}")
    private int port;
    @Value("${redis.password}")
    private String passWord;
    @Value("${redis.maxIdle}")
    private int maxIdl;
    @Value("${redis.minIdle}")
    private int minIdl;
    @Value("${redis.timeout}")
    private int timeout;

    private int defaultDb;

    @Value("${redis.dbs}")
    private List<Integer> dbs;

    public static Map<Integer, RedisTemplate<Serializable, Object>> redisTemplateMap = new HashMap<>();

    /**
     * 只加载一次的服务器
     * @throws Exception
     */
    @PostConstruct
    public void initRedisTemp() throws Exception {
        log.info("###### START 初始化 Redis 连接池 START ######");
        defaultDb = dbs.get(0);
        for (Integer db : dbs) {
            log.info("###### 正在加载Redis-db-" + db+ " ######");
            redisTemplateMap.put(db, redisTemplateObject(db));
        }
        log.info("###### END 初始化 Redis 连接池 END ######");
    }


    private RedisTemplate<Serializable, Object> redisTemplateObject(Integer db) {
        RedisTemplate<Serializable, Object> redisTemplateObject = new RedisTemplate<Serializable, Object>();
        redisTemplateObject.setConnectionFactory(redisConnectionFactory(jedisPoolConfig(),db));
        setSerializer(redisTemplateObject);
        redisTemplateObject.afterPropertiesSet();
        return redisTemplateObject;
        
    }

    private void setSerializer(RedisTemplate<Serializable, Object> template) {
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    }
    public RedisTemplate<Serializable, Object> getRedisTemplate(int db){
        return redisTemplateMap.get(db);
    }

    public RedisTemplate<Serializable, Object> getRedisTemplate(){
        return redisTemplateMap.get(defaultDb);
    }


    /**
     * 连接池配置
     * @return
     */
    private JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 最大连接数
        poolConfig.setMaxIdle(maxIdl);
        // 最小空闲连接数
        poolConfig.setMinIdle(minIdl);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setNumTestsPerEvictionRun(10);
        poolConfig.setTimeBetweenEvictionRunsMillis(60000);
        // 当池内没有可用的连接时，最大等待时间
        poolConfig.setMaxWaitMillis(10000);
        // ------其他属性根据需要自行添加-------------
        return poolConfig;
    }

    /**
     * jedis连接工厂
     *
     * @param jedisPoolConfig
     * @return
     */
    public RedisConnectionFactory redisConnectionFactory(JedisPoolConfig jedisPoolConfig, int db) {
        // 单机版jedis
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        // 设置redis服务器的host或者ip地址
        redisStandaloneConfiguration.setHostName(hostName);
        // 设置默认使用的数据库
        redisStandaloneConfiguration.setDatabase(db);
        // 设置密码
        redisStandaloneConfiguration.setPassword(RedisPassword.of(passWord));
        // 设置redis的服务的端口号
        redisStandaloneConfiguration.setPort(port);

        // 获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢)
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb = (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration
                .builder();
        // 指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
        jpcb.poolConfig(jedisPoolConfig);
        // 通过构造器来构造jedis客户端配置
        JedisClientConfiguration jedisClientConfiguration = jpcb.build();
        // 单机配置 + 客户端配置 = jedis连接工厂
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    }



}

2-3：测试的方法：

    //redis 数据结构配置
    @Autowired
    private redisDbConfig redisDb;

    /**
     * 添加字符串
     *
     * @param key
     */
    @GetMapping("/hi")
    @ResponseBody
    public void demo03(String key) {
        //配置结构 表示你想配置切换的db几 getRedisTemplate(1) 如果不写默认为db0
         redisDb.getRedisTemplate(1).opsForValue().set("k2",key);
        System.out.println(key);
    }

 

 //此信息部分参考这位大佬  https://ld246.com/article/1594863004207

//3-现在我们介绍第三种方式 也是最简单 最直接的方法

// 还有直接用yml 文件切换 database 1  就这样直接切换db1了

spring:
  thymeleaf:
    cache: false
  redis:
    #REDIS 数据库索引（默认为0） 分片想存在那里就存在那里 0-15
    database: 1
    #redis服务地址
    host: 127.0.0.1
    #redis服务连接端口
    port: 6379
    #redis密码（没有密码默认为空）
    password:
    #连接池最大连接数（使用负值表示没有限制）
    jedis:
      pool:
        max-active: 8
    lettuce:
      pool:
        #连接池最大堵塞等待时间（使用负值表示没有限制）
        max-wait: -1
        #连接池最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 0
        #连接超时时间（毫秒）
    timeout: 5000

 //我们来演示一下

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

   /**
     * 添加字符串
     *
     * @param key
     */
    @RequestMapping("/haha")
    @ResponseBody
    public void demo01(String key) {
       stringRedisTemplate.opsForValue().set("K3", key);
        System.out.println(key);
    }