Spring Boot + Lettuce连接 Redis 集群（单机/主备/ProxyCluster）

1. 项目依赖

在项目 pom.xml 中添加必要的依赖项：


   
    
    
     org.springframework.boot
    
    
    
     spring-boot-starter-web
    
   
   
    
    
     org.springframework.boot
    
    
    
     spring-boot-starter-data-redis

2. Redis 配置

在 application.properties 文件中配置 Redis 连接信息：

spring.redis.host=host
spring.redis.database=0
spring.redis.password=pwd
spring.redis.port=port
# 连接超时时间
spring.redis.timeout=1000

3. Redis 连接池配置

为了提高连接效率，建议使用连接池：

# 连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=50
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=5
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=50
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.pool.max-wait=5000
# 间隔时间（毫秒）进行连接池的空闲连接清理
spring.redis.lettuce.pool.time-between-eviction-runs=2000

4. Redis 连接配置类

创建自定义的 Redis 连接配置类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.LettuceConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedisConfiguration {
    @Autowired
    private LettuceConnectionFactory lettuceConnectionFactory;
    @Bean
    public RedisTemplate
   
     redisTemplate() {
        RedisTemplate
    
      template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory);
        // 使用 Jackson2JsonRedisSerializer 替换默认的序列化方式
        Jackson2JsonRedisSerializer

5. Redis 操作工具类

创建一个 Redis 操作工具类：

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class RedisUtil {
    private RedisTemplate
   
     redisTemplate;
    public RedisUtil(RedisTemplate
    
      redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

6. 测试控制器

创建一个测试控制器类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloRedisController {
    @Autowired
    private RedisUtil redisUtil;
    @RequestMapping("/set")
    @ResponseBody
    public String setParams(String name) {
        redisUtil.set("name", name);
        return "success";
    }
    @RequestMapping("/get")
    @ResponseBody
    public String getParams(String name) {
        System.out.println("获取数据 - " + name);
        return redisUtil.get(name).toString();
    }
}

7. Redis 集群配置

在 application.properties 中添加集群配置：

spring.redis.cluster.nodes=host:port
spring.redis.cluster.max-redirects=3
spring.redis.password=pwd
# 自动刷新时间（秒）
spring.redis.lettuce.cluster.refresh.period=60
# 开启自适应刷新
spring.redis.lettuce.cluster.refresh.adaptive=true
# 连接超时时间（秒）
spring.redis.timeout=60

8. Redis 集群连接配置类

创建一个自定义的 Redis 集群连接配置类：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.LettuceConnectionFactory;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class RedisClusterConfiguration {
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory(
            String clusterNodes,
            String password,
            Integer maxRedirects,
            Integer period,
            Integer timeout) {
        List
   
     listNodes = new ArrayList<>();
        String[] nodes = clusterNodes.split(",");
        for (String node : nodes) {
            String[] ipPort = node.split(":");
            RedisNode redisNode = new RedisNode(ipPort[0], Integer.parseInt(ipPort[1]));
            listNodes.add(redisNode);
        }
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration();
        clusterConfig.setClusterNodes(listNodes);
        clusterConfig.setPassword(password);
        clusterConfig.setMaxRedirects(maxRedirects);
        ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                .enablePeriodicRefresh(Duration.ofSeconds(period))
                .enableAllAdaptiveRefreshTriggers()
                .build();
        ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
                .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(timeout)))
                .topologyRefreshOptions(topologyRefreshOptions)
                .build();
        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(timeout))
                .readFrom(ReadFrom.REPLICA_PREFERRED)
                .clientOptions(clusterClientOptions)
                .build();
        LettuceConnectionFactory factory = new LettuceConnectionFactory(clusterConfig, clientConfig);
        return factory;
    }
}

9. Redis 集群操作工具类

创建一个 Redis 集群操作工具类：

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class RedisClusterUtil {
    private RedisTemplate
   
     redisTemplate;
    public RedisClusterUtil(RedisTemplate
    
      redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}