springboot项目同时操作redis服务器的两个库以及操作两个redis实例

关注

原创最新推荐文章于 2026-04-29 09:37:20 发布 3.3k 阅读 AI 写同款· GEO 优化 ›

SpringBoot基本操作（五）——SpringBoot使用Jedis整合Redis（有demo） SpringBoot2.0笔记（一）SpringBoot基本操作——环境搭建及项目创建（有demo）（二）SpringBoot基本操作——使用IDEA打war包发布及测试（三）SpringBoot基本操作——SpringBoot整合SpringDataJpa（有demo）（四）SpringBoot基本操作——SpringBoot使用RedisTemplate整合Redis（有dem... 阅读详情

本文介绍的有两种连接方式：1.操作一个redis实例的不同库。2.操作两个redis实例的库【这种情况相同不同都一样】，两种方法大差不差，基于一个大致的框架上小改即可实现。

先说第一种情况：

一、搭建项目

搭建项目比较简单，idea可以自动生成，这里只放pom.xml【依赖是我项目用到的，根据自己情况改】

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.siemens</groupId>
    <artifactId>gat</artifactId>
    <version>0.0.1</version>
    <name>gat</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.42</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.datatype</groupId>
            <artifactId>jackson-datatype-joda</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-parameter-names</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
            <version>1.3.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

二、application.yml文件配置

server:
  port: 8081

spring:
  datasource:
    name: druid_source
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1：3306/databaseName?characterEncoding=utf8&useSSL=false&serverTimezone=CTT&allowPublicKeyRetrieval=true
    username: xxxx
    password: xxxx

#配置0号库和10号库
redis:
  database:
    db1: 0
    db2: 10
  host: 127.0.0.1
  port: 6379
  timeout: 10000
  pool:
    max-active: 100
    max-idle: 3
    min-idle: 0
    max-wait: -1

三、redis配置类

package com.siemens.gat.config;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisTemplate;

import java.time.Duration;

/**
 * Created by SongShilun on 2020/12/14 10:12
 */
@Configuration
public class RedisConfig {
    @Value("${redis.database.db1}")
    private int db1;

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

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

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

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

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

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

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

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

    @Bean
    public GenericObjectPoolConfig getPoolConfig(){
        // 配置redis连接池
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWait);
        return poolConfig;
    }

    @Bean(name = "redisTemplate1")
    public StringRedisTemplate getRedisTemplate1(){
        return getStringRedisTemplate(db1);
    }

    @Bean(name = "redisTemplate2")
    public StringRedisTemplate getRedisTemplate2(){
        return getStringRedisTemplate(db2);
    }

    private StringRedisTemplate getStringRedisTemplate(int database) {
        // 构建工厂对象
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(host);
        config.setPort(port);
        //config.setPassword(RedisPassword.of(password));
        LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(timeout))
                .poolConfig(getPoolConfig())
                .build();
        LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfig);
        // 设置使用的redis数据库
        factory.setDatabase(database);
        // 重新初始化工厂
        factory.afterPropertiesSet();
        return new StringRedisTemplate(factory);
    }
}

以上就是连接一个redis实例，分别操作一个redis实例的不同的两个库的配置

---------------------------------------------------------------分割线--------------------------------------------------------------

下边说一下，当需要连接两个不同服务器上的redis时，应该怎么配置：
ps:连接两个redis实例和上述的代码很像，只需要做些小小的改动即可：

pom.xml文件不动
application.yml：

server:
  port: 8081

spring:
  datasource:
    name: druid_source
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/databaseName?characterEncoding=utf8&useSSL=false&serverTimezone=CTT&allowPublicKeyRetrieval=true
    username: xxxx
    password: xxxx

#配置两个redis实例，第一个用0号库，用于读取并监控数据变化；第二个用10号库，用来存放数据变化的信息
redis1:
  database:
    db1: 0
  host: 127.0.0.1
  port: 6379
  timeout: 10000
  pool:
    max-active: 100
    max-idle: 3
    min-idle: 0
    max-wait: -1

redis2:
  database:
    db2: 10
  host: xxx.xxx.xx.xx
  port: 6379
  timeout: 10000
  pool:
    max-active: 100
    max-idle: 3
    min-idle: 0
    max-wait: -1

redis配置类

package com.siemens.gat.config;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisTemplate;

import java.time.Duration;

/**
 * Created by SongShilun on 2020/12/14 10:12
 */
@Configuration
public class RedisConfig {
    @Value("${redis1.database.db1}")
    private int db1;

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

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

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

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

    @Value("${redis1.pool.max-active}")
    private int maxActive;

    @Value("${redis1.pool.max-idle}")
    private int maxIdle;

    @Value("${redis1.pool.min-idle}")
    private int minIdle;

    @Value("${redis1.pool.max-wait}")
    private int maxWait;


    @Value("${redis2.host}")
    private String host2;
    @Value("${redis2.port}")
    private int port2;

    @Bean
    public GenericObjectPoolConfig getPoolConfig(){
        // 配置redis连接池
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWait);
        return poolConfig;
    }

    @Bean(name = "redisTemplate1")
    public StringRedisTemplate getRedisTemplate1(){
        return getStringRedisTemplate(db1,host1,port1);
    }

    @Bean(name = "redisTemplate2")
    public StringRedisTemplate getRedisTemplate2(){
        return getStringRedisTemplate(db2,host2,port2);
    }

    private StringRedisTemplate getStringRedisTemplate(int database,String address,int portNum) {
        // 构建工厂对象
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(address);
        config.setPort(portNum);
        //config.setPassword(RedisPassword.of(password));
        LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(timeout))
                .poolConfig(getPoolConfig())
                .build();
        LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfig);
        // 设置使用的redis数据库
        factory.setDatabase(database);
        // 重新初始化工厂
        factory.afterPropertiesSet();
        return new StringRedisTemplate(factory);
    }
}

可以看出来，相比于连接一个redis实例的不同库，连接两个redis实例只多了application的一个配置信息，和对redis配置类的工厂化方法的小改动。一个redis默认有下标为0-15的16个库，连接一个实例的不同库和连接两个实例的相同库，以及连接两个实例的不同库，其原理都是相同的，只要做通一个功能，其余的功能可以基于原有的功能上进行修改。

收录于