SpringBoot Controller多数据库 springboot多数据库切换

Redis客户端

一个Redis连接有16个数据库：0~15，每个数据库都是独立的

• 切换数据库：select num

从数据库3切换到6

• 移动数据：move key num

将user从数据库2移动到3

• 清空数据库：flushdb

在该数据库命令行flushdb，清空该数据库

• 清空当前连接的所有数据库：flushall

配置数据库数目

在redis.conf配置文件中：

databases即设置一个连接中数据库的数目：16

---

springboot中外部化配置

Springboot中关于Redis的配置属性：

其中关于数据库的配置database只是设置我们使用16个数据库中的哪个数据库：

想要同时操作多个数据库或者多个数据源需要外部化配置

操作多个数据库

配置类和SpringBoot的自动装配原理一样

结构：

自定义配置类，该配置类：

• 定义连接redis的6个属性，first表示第一个数据库，second表示第二个数据库，表示一次操作两个数据库，host、password、port、timeout连接属性
• 这两个数据库定义对应的RedisTemplate，封装Lettuce，因为这里仅仅操作String类型数据，就定义StringRedisTemplate

package com.database.database.cofig;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * Author : zfk
 * Data : 8:57
 */

@Configuration
@EnableAutoConfiguration
public class RedisConfig {


    @Value("${redis.database.first}")
    private int firstDatabase;

    @Value("${redis.database.second}")
    private int secondDatabase;

    @Value("${redis.host}")
    private String host;

    @Value("${redis.password}")
    private String password;

    @Value("${redis.port}")
    private int port;

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


    @Bean(name = "firstRedisTemplate")
    public RedisTemplate getFirstRedisTemplate(){

        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();

        connectionFactory.setDatabase(firstDatabase);
        connectionFactory.setHostName(host);
        connectionFactory.setPassword(password);
        connectionFactory.setPort(port);
        connectionFactory.setTimeout(timeout);
        connectionFactory.afterPropertiesSet();			

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(connectionFactory);
        return stringRedisTemplate;
    }


    @Bean(name = "secondRedisTemplate")
    public RedisTemplate getSecondRedisTemplate(){

        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();
        connectionFactory.setDatabase(secondDatabase);
        connectionFactory.setHostName(host);
        connectionFactory.setPassword(password);
        connectionFactory.setPort(port);
        connectionFactory.setTimeout(timeout);
        connectionFactory.afterPropertiesSet();

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(connectionFactory);
        return stringRedisTemplate;
    }

}

application.yml：这里对应配置的value

redis:
  database:
    first: 0
    second: 1
  host: ip地址
  password: 密码
  port: 6379
  timeout: 3000

测试类：

package com.database.database;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

@SpringBootTest
class DatabaseApplicationTests {


    @Autowired
    private RedisTemplate firstRedisTemplate;

    @Autowired
    private RedisTemplate secondRedisTemplate;

    @Test
    void contextLoads() {

        ValueOperations operations = firstRedisTemplate.opsForValue();
        operations.set("age", "25");
        String age = (String) operations.get("age");
        System.out.println("年龄："+age);

        ValueOperations operations2 = secondRedisTemplate.opsForValue();
        operations2.set("address", "beijing");

        String address = (String) operations2.get("address");
        System.out.println("地址："+address);
    }

}

结果：同时操作了两个数据库，一个存放age，一个存放address

操作多个数据源

有时还需要操作多个Redis连接
Jedis、Lettuce都相当于Redis客户端，RedisTemplate封装Jedis/Lettuce，那么我们设置两个RedisTemplate即可操作两个Redis连接

添加一个配置类RedisConfig2：

package com.database.database.cofig;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * Author : zfk
 * Data : 10:46
 */
@Configuration
@EnableAutoConfiguration
public class RedisConfig2 {


    @Value("${redis2.database}")
    private int database = 0;

    @Value("${redis2.host}")
    private String host;

    @Value("${redis2.password}")
    private String password;

    @Value("${redis2.port}")
    private int port;

    @Value("${redis2.timeout}")
    private int timeout;

    @Bean(name = "redisTemplate2")
    RedisTemplate getRedisTemplate2(){
        
        LettuceConnectionFactory factory = new LettuceConnectionFactory();
        factory.setDatabase(database);
        factory.setPort(port);
        factory.setHostName(host);
        factory.setPassword(password);
        factory.setTimeout(timeout);
        factory.afterPropertiesSet();

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(factory);
        return stringRedisTemplate;
    }

}

application.yml连接配置：

## 远程连接
redis:
  database:
    first: 0
    second: 1
  host: ip地址
  password: 密码
  port: 6379
  timeout: 3000
  
## 本地连接
redis2:
  database: 2
  host: 127.0.0.1
  password: 密码
  port: 6379
  timeout: 3000

测试类DatabaseApplicationTests：相比上面添加了个测试方法和注入了RedisTemplate2

package com.database.database;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

@SpringBootTest
class DatabaseApplicationTests {


    @Autowired
    private RedisTemplate firstRedisTemplate;

    @Autowired
    private RedisTemplate secondRedisTemplate;

    @Autowired
    private RedisTemplate redisTemplate2;

    @Test
    void contextLoads() {

        ValueOperations operations = firstRedisTemplate.opsForValue();
        operations.set("age", "25");
        String age = (String) operations.get("age");
        System.out.println("年龄："+age);

        ValueOperations operations2 = secondRedisTemplate.opsForValue();
        operations2.set("address", "beijing");

        String address = (String) operations2.get("address");
        System.out.println("地址："+address);
    }


    @Test
    public void test(){
        //操作本地Redis连接
        ValueOperations valueOperations = redisTemplate2.opsForValue();
        valueOperations.set("age","26");
        System.out.println("本地Redis=> age:"+valueOperations.get("age").toString());

        //操作远程Redis连接
        ValueOperations operations = firstRedisTemplate.opsForValue();
        String age = (String) operations.get("age");
        System.out.println("远程Redis=> age:"+age);

    }
}

测试结果：

两个Redis连接：