SpringBoot整合Redis（单机+集群版）

1、pom引入

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- redis.clients/jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${
   jedis.version}</version>
        </dependency>

2、yml配置

2.1 单机版

spring:
  redis:
    host: 1xx.1xx.xxx.27
    port: 63xx
    password: FxxxxxxxxxxxxL
    timeout: 5000
    jedis:
      pool:
        # 连连接池的最大数据库连接数
        max-active: 1200
        # 连接池中的最大空闲连接
        max-idle: 100
        # 连接池中的最小空闲连接 默认为 0
        min-idle: 10
        # 连接池最大阻塞等待时间(使用负值表示没有限制) 默认为-1
        max-wait: 30000
        timeBetweenEvictionRunsMillis: 60000
        # 向调用者输出“链接”对象时，是否检测它的空闲超时；
        testWhileIdle: true
        # 对于空闲链接检测线程而言，每次检测的链接资源的个数。默认为3.
        numTestsPerEvictionRun: 20

2.2 集群版

spring:
  redis:
    cluster:
      nodes: 10.xx.0.xx1:7000,10.xx.xx.xx9:7001,10.xx.xxx.xx8:7002
    password:
    timeout: 5000
    # 重定向连接数
    max-redirects: 3
    jedis:
      pool:
        # 连连接池的最大数据库连接数
        max-active: 1200
        # 连接池中的最大空闲连接
        max-idle: 100
        # 连接池中的最小空闲连接 默认为 0
        min-idle: 10
        # 连接池最大阻塞等待时间(使用负值表示没有限制) 默认为-1
        max-wait: 30000
        timeBetweenEvictionRunsMillis: 60000
        # 向调用者输出“链接”对象时，是否检测它的空闲超时；
        testWhileIdle: true
        # 对于空闲链接检测线程而言，每次检测的链接资源的个数。默认为3.
        numTestsPerEvictionRun: 20

3、RedisConfig

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.*;
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.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;
import java.util.HashSet;
import java.util.Set;

/**
 * Jedis连接池相关配置
 *
 * @author: zmm
 * @date: 2021/04/01 11:35
 */


@Configuration
@EnableAutoConfiguration(exclude = {
   RedisAutoConfiguration.class, RedisReactiveAutoConfiguration.class}) // 注意exclude
public class RedisConfig {
   

    // redis集群下
    @Value("${spring.redis.cluster.nodes}")
    private String host;

/*    // redis单机
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;*/


    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.timeout}")
    private long timeout;
    @Value("${spring.redis.max-redirects}")
    private int redirects;
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWait;
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;
    @Value("${spring.redis.jedis.pool.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRuns;
    @Value("${spring.redis.jedis.pool.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${spring.redis.jedis.pool.numTestsPerEvictionRun}")
    private int numTestsPer;


    @Bean(name = "redisConnectionFactory")
    public RedisConnectionFactory redisConnectionFactory() {
   
        //redis环境配置：地址、端口、密码
        /*
        // 单机
        RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration();
        standaloneConfiguration.setHostName(host);
        standaloneConfiguration.setPort(port);
        standaloneConfiguration.setPassword(RedisPassword.of(password));
        standaloneConfiguration.setDatabase(0);
        */

        // 集群
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        String[] hosts = host.split(",");
        Set<RedisNode> nodeList = new HashSet<>();
        for (String hostAndPort : hosts) {
   
            String[] hostOrPort = hostAndPort.split(":");
            nodeList.add(new RedisNode(hostOrPort[0], Integer.parseInt(hostOrPort[1])));
        }

        redisClusterConfiguration.setClusterNodes(nodeList);
        redisClusterConfiguration.setPassword(RedisPassword.of(password));
        redisClusterConfiguration