Spring Boot 整合 Redis 集群详解

最新推荐文章于 2024-06-14 23:41:47 发布
最新推荐文章于 2024-06-14 23:41:47 发布
阅读量3.6k 收藏 25
点赞数 15
分类专栏： 【Redis】 文章标签： spring boot redis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118323/article/details/137402912
版权

前言：

项目中需要使用 Redis 做缓存数据库，本文分享一下 Spring Boot 项目集成 Redis 的过程以及踩过的坑。

Spring Boot 集成 Redis 可以分为三大步，如下：

  • 在 proerties 或者 yml 文件中添加 redis 和 lettuce 配置。
  • 项目 pom.xml 文件中引入 spring-boot-starter-data-redis 依赖。
  • 注入 RedisTemplate 开始使用 Redis，其实这步以及算是使用了，不能算作集成了，但是集成了总归是要使用的，我把这里也算作一步了。

添加 redis 和 lettuce 配置：

//redis 集群地址
spring.redis.cluster.nodes = dev-k8s-redis.eminxing.com:17000
//密码
spring.redis.password = z8_UX7BCi_XYckrM
//在群集上执行命令时重定向的最大数量。
spring.redis.cluster.max-redirects = 3
//连接池最小空闲连接数 负值表示没有限制
spring.redis.lettuce.pool.max-idle = 10
//连接池最大空闲连接数 负值表示没有限制
spring.redis.lettuce.pool.min-idle = 5
//连接池最大活跃连接数 负值表示没有限制
spring.redis.lettuce.pool.max-active = 20
//建立连接最大等待时间，默认1ms，超出该时间会抛异常。设为-1表示无限等待，直到分配成功
spring.redis.lettuce.pool.max-wait = 10000

以上配置，会自动由 Spring Boot 自动装配，不需要再配置类，Spring Boot 会自动把这些配置参数加载后实例化连接池。

项目 pom.xml 文件中引入 spring-boot-starter-data-redis 依赖：

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

注入 RedisTemplate 开始使用 Redis，启动就报错，完美翻车，错误信息如下：

nested exception is java.lang.NoClassDefFoundError: org/apache/commons/pool2/impl/GenericObjectPoolConfig

关于这个错误的解决方案另起了一篇文章进行了详细分析，如下：

解决报错传送门：

传送门告诉我们正确的 Spring Boot 2.0 以上版本集成 Redis 的正确依赖如下：

 <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-pool2</artifactId>
</dependency>

解决启动报错问题，准备开始使用：

测试代码：

@Slf4j
@RestController
@RequestMapping("/api/redis/")
public class RedisDemoController {

    @Autowired
    private RedisUtils redisUtils;

    @ApiOperation(value = "测试redis", produces = "application/json")
    @GetMapping("/test-redis")
    public Result<String> batchCreateOrUpdatePipeline(@RequestParam("key") String key, @RequestParam("value") String value) {
        redisUtils.set(key, value);
        return ResultGenerator.genSuccessResult();
    }
}

这里的 RedisUtils 是我封装的一个工具类，下文会进行分享，这里先分享一下演示结果，Another Redis Desktop Manager 客户端展示如下：

在这里插入图片描述
分析结果，我们发现出现了一串字符串 “\xac\xed\x00\x05t\x00\x10”，这串字符串明显不是我们想要看到的，难道是 Redis 集成又出问题了吗，使用代码获取了缓存字符串，发现并没有这串奇奇怪怪的字符串，那是怎么回事呢？查阅资料得知是序列话的问题。

Redis 序列化与反序列化问题处理，如下：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        //如果不序列化在key value 使用redis客户端工具 直连redis服务器 查看数据时 前面会有一个 \xac\xed\x00\x05t\x00\x05 字符串
        // StringRedisSerializer 来序列化和反序列化 String 类型 redis 的 key value
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);
        // StringRedisSerializer 来序列化和反序列化 hash 类型 redis 的 key value
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

自定义了 RedisTemplate 配置，设置了序列化和反序列化后，再次验证后，如下：
在这里插入图片描述
完美解决问题。

RedisUtils 分享如下：

package com.zt.zteam.main.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName： RedisUtils
 * @Author: zhangyong
 * @Date: 2024/4/1 14:56
 * @Description: redis 工具类
 */

@Component
@Slf4j
public class RedisUtils {


    @Autowired
    public RedisTemplate redisTemplate;


    /**
     * @Description: 设置缓存对象
     * @Date: 2024/4/2 14:18
     */
    public <T> void set(String key, T value) {
        redisTemplate.opsForValue().set(key, value);

    }

    /**
     * @Description: 设置缓存对象，附带设定有效期
     * @Date: 2024/4/2 14:18
     */
    public <T> void set(String key, T value, Integer timeout, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * @Description: 设置缓存对象的有效期
     * @Date: 2024/4/2 14:18
     */
    public <T> void expire(String key, Integer timeout, TimeUnit timeUnit) {
        redisTemplate.expire(key, timeout, timeUnit);
    }


    /**
     * @Description: 获取缓存对象
     * @Date: 2024/4/2 14:18
     */
    public <T> T get(String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }


    /**
     * @Description: 删除缓存对象
     * @Date: 2024/4/2 14:18
     */
    public boolean remove(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * @Description: 从redis缓存中移除指定前缀的所有值
     * @Date: 2024/4/2 14:18
     */
    public void removePrefix(String prefix) {
        Set keys = redisTemplate.keys(prefix + "*");
        redisTemplate.delete(keys);
    }

    /**
     * @Description: 伪批量存入缓存
     * @Date: 2024/4/2 14:18
     */
    public void setBatch(Map<String, String> cachedMap) {
        for (String key : cachedMap.keySet()) {
            set(key, cachedMap.get(key));
        }
    }

    /**
     * @Description: key 是否存在
     * @Date: 2024/4/2 14:18
     */
    public boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * @Description: 根据key 删除 value
     * @Date: 2024/4/2 14:18
     */
    public boolean del(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * @Description: 判断key是否存在
     * @Date: 2024/4/2 14:18
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 指定缓存失效时间
     * @Date: 2024/4/13 8:53
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 获取key 的过期时间
     * @Date: 2024/4/13 8:54
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * @Description: 删除缓存 支持一个到多个
     * @Date: 2024/4/13 8:55
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));

            }
        }
    }

    /**
     * @Description: 增加操作
     * @Date: 2024/4/13 8:55
     */
    public long incr(String key, long count) {
        if (count < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, count);
    }

    /**
     * @Description: 减少操作
     * @Date: 2024/4/13 8:55
     */
    public long decr(String key, long count) {
        if (count < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -count);
    }

    /**
     * @Description: hash get 操作
     * @Date: 2024/4/13 8:55
     */
    public Object hGet(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * @Description: hash mget 操作 获取 key 对应的所有键值
     * @Date: 2024/4/13 8:55
     */
    public Map<Object, Object> hmGet(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * @Description: hash set 操作 批量set
     * @Date: 2024/4/13 8:55
     */
    public boolean hmSet(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: hash set 操作 带过期时间的批量set
     * @Date: 2024/4/13 8:55
     */
    public boolean hmSet(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: hash set 操作 单个set
     * @Date: 2024/4/13 8:55
     */
    public boolean hSet(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: hash set 操作 单个set 带过期时间
     * @Date: 2024/4/13 8:55
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: hash 删除操作 支持当个或多个
     * @Date: 2024/4/13 8:55
     */
    public void hDel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * @Description: hash 判断 key 是否存在
     * @Date: 2024/4/13 8:55
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * @Description: hash 递增操作
     * @Date: 2024/4/13 8:55
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * @Description: hash 递减操作
     * @Date: 2024/4/13 8:55
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * @Description: set  根据key 获取value 值
     * @Date: 2024/4/13 8:55
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @Description: set  判断value是否存在set集合中
     * @Date: 2024/4/13 8:55
     */
    public boolean sHasValue(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: set 添加元素操作 value 可以是一个或多个
     * @Date: 2024/4/13 8:55
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @Description: set 添加元素操作 value 可以是一个或多个 带缓存时间
     * @Date: 2024/4/13 8:55
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @Description: 获取 set 集合的元素个数
     * @Date: 2024/4/13 8:55
     */
    public long sGetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @Description: 删除 set 集合中元素 支持一个或者多个 返回删除的个数
     * @Date: 2024/4/13 8:55
     */
    public long setDel(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @Description: 获取 list 缓存的内容 从start 位置到 end 位置
     * @Date: 2024/4/13 8:55
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @Description: 获取 list 缓存的元素个数
     * @Date: 2024/4/13 8:55
     */
    public long lGetSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * @Description: 通过索引获取list 集合中的元素 类似 list(0)
     * @Date: 2024/4/13 8:55
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * @Description: 像list 集合中添加元素
     * @Date: 2024/4/13 8:55
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 像list 集合中添加元素 带缓存时间
     * @Date: 2024/4/13 8:55
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 像list 集合中添加元素 批量操作
     * @Date: 2024/4/13 8:55
     */
    public boolean lBatchSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 像list 集合中添加元素 批量操作 带过期时间
     * @Date: 2024/4/13 8:55
     */
    public boolean lBatchSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 根据索引修改 list 中的某个元素
     * @Date: 2024/4/13 8:55
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * @Description: 删除 count 个值为value 的元素 返回删除的个数
     * @Date: 2024/4/13 8:55
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}

本篇简单分享了 Spring Boot 项目集成 Redis 过程中可能会需要的一些问题，希望能够帮助到有需要的朋友。

如有错误的地方欢迎指出纠正。

码农爱java
关注
  • 15
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot 连接 redis 集群
皮蛋小粥的博客
02-04 3万+
我的个人刷Java面试题网站:http://www.study-java.cn/ 最近一直在画小程序的界面，感觉自己都快成为一个前端工程师了，尤其是前面做管理后台的时候使用Angular4，让自己有点头大。都快忘记自己是Java开发了。。。上周自己在三台服务器上面搭建了一个redis集群，每台服务器创建三个实例，端口分别是7000，7001，7002.....7008。搭建过程中遇到的一个问题就...
Spring Boot 集成 Redis
yd1628570241的博客
04-21 163
1. Spring Boot 集成 Redis 1.1 依赖导入 Spring Boot 集成 redis 很方便，只需要导入一个 redis 的 starter 依赖即可。如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
springboot整合redis集群过程解析
08-25
主要介绍了springboot整合redis集群过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
如何使用Spring Boot框架整合Redis：超详细案例教程
最新发布
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-14 2766
成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。是用于 Lettuce 连接池配置的依赖。目录下，添加 Redis 连接池的配置。确保你的项目包含了以下依赖。，这里就无需再次添加。类以支持连接池即可。
springboot整合redis集群零配置
07-28
Springboot整合Redis集群,零配置方式;另外用AOP实现了操作缓存的三套自定义注解,有兴趣的小伙伴可以试试看.
Springboot整合Redis集群实战详解
m0_59092234的博客
08-30 4701
Redis Sentinel安装与部署，实现redis的高可用实现了redis的高可用，针对的主要是master宕机的情况，我们发现所有节点的数据都是一样的，那么一旦数据量过大，redis也会效率下降的问题。redis3.0版本正式推出后，有效地解决了Redis分布式方面的需求，当遇到单机内存、并发、流量等瓶颈时，可以采用Cluster架构方法达到负载均衡的目的。...
SpringBoot 配置redis集群
热门推荐
TechnicianWang的博客
04-28 3万+
applcation.yml # redis 配置 redis: server: pattern: cluster nodes: 127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002,127.0.0.1:3003,127.0.0.1:3004,127.0.0.1:3005 password: maxIdle: 8 minIdle: 4 maxTotal: 8 maxWaitMillis: 6000
springboot整合redis集群
m0_68574821的博客
04-01 5981
发现写是写成功了但是出现了乱码的问题（因为springboot默认的序列化会出现乱码，我们要的key要使用string的方式序列化，value要使用json的方式序列化）7.在主启动类上加上@EnableSwagger2注解。11.在RedisConfig配置类上面配置。2.创建测试类（lettuceDemo）4.编辑OrderService业务类。12.再次启动主动类且在插入数据。1.修改pom.xml配置文件。1.修改pom.xml 文件。6.修改Swagger配置类。1.修改pom.xml。
SpringBoot 集成 Redis 集群
种一棵树最好的时间是十年前，其次是现在。
11-17 4564
搭建Redis集群可参考这篇文章：Docker 搭建redis集群-三台机机器、三主三从 首先要确保redis集群正常使用，才能往下走，不然在启动的时候初始化redis连接池，会报异常。 查看redis集群状态是否正常，可以连接上redis后，使用 cluster info 查看： 可以看到: cluster_state 集群状态是 ok ，如果为 fail 则表示集群状态异常。 cluster_size 集群 Master 数量 cluster_know_nodes 集群 节点 数量 这里集成了 Red
Spring boot 与redis 群集
canduecho的专栏
07-07 2164
在上述示例中，我们通过注入`RedisTemplate`对象来操作Redis集群。在`RedisService`中，我们定义了一些常用的操作方法，例如`setValue()`和`getValue()`，用于设置和获取Redis的键值对。在`RedisController`中，我们使用`RedisService`来处理相关的请求，例如通过`/redis/{key}`路径获取Redis中的值。确保你的Redis集群已正确配置，并替换示例代码中的相应信息，如Redis集群节点的主机和端口等。
springboot连接redis集群
程序猿杰哥的博客
03-22 2万+
开启redis服务和客户端 查看下当前redis的进程 [root@localhost ~]# ps -ef | grep redis 启动redis服务 [root@localhost ~]# cd /opt/redis-5.0.4 [root@localhost redis-5.0.4]# redis-server redis.conf 再查看下reids的服务进程 启动redis-cli [root@localhost redis-5.0.4]# redis-cli -h 192.168.2
详解Spring boot使用Redis集群替换mybatis二级缓存
08-30
Spring Boot 使用 Redis 集群替换 MyBatis 二级缓存 Spring Boot 作为当前流行的 Java Web 框架，提供了许多便捷的功能来快速开发 Web 应用程序。其中，缓存机制是 Spring Boot 中一个非常重要的组件，缓存机制...
Spring Boot和Hazelcast使用详解
08-27
Spring Boot和Hazelcast使用详解 Spring Boot和Hazelcast使用详解是指如何将Hazelcast集成到Spring Boot项目中，以提高应用程序的性能。Hazelcast是一个内存分布式计算平台，用于管理数据并并行执行应用程序。它...
详解springboot配置多个redis连接
08-30
Spring Boot为Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自动配置。本文详细介绍了springboot配置多个redis连接，有兴趣的可以了解一下。
详解SpringBoot2 使用Spring Session集群
08-26
详解SpringBoot2 使用Spring Session集群 SpringBoot2 是一个流行的 Java 框架，用于构建基于 Web 的应用程序，而 Spring Session 是一个用于管理会话的框架。本文将详细介绍如何使用 Spring Session 在 SpringBoot...
SpringBoot整合redis集群实现读写分离（哨兵模式）
wy971744839的博客
08-05 4262
服务都运行在我们虚拟机上，我这里的设置的IP地址都为192.168.159.100（根据自己的IP地址定义），端口分别为6380、6381、6382，以6380作为主节点，6381、6382作为从节点。配置文件可在解压后的源码文件根目录中找到，这里以从节点 6381 配置文件为例，其余两个配置文件几乎一致。在整合springboot之前，首先要开放redis集群的防火墙端口，不然连接不上我们的redis服务。服务，分别运行于26380、26381、26382三个端口，同样也需要配置.conf文件运行服务。
SpringBoot+Redis-Cluster集群搭建及调优
Funky_oaNiu的博客
10-08 2122
SpringBoot+Redis-Cluster集群搭建及调优
spring boot 整合Redis集群配置
04-13
好的，关于 Spring Boot 整合 Redis 集群配置，你可以按照以下步骤进行： 1. 配置 Redis 集群 2. 在项目中引入 Redis 相关依赖 3. 配置 RedisTemplate 和 RedisCacheManager 4. 将 Redis 相关的配置信息添加到 application.properties 文件中 如果您需要更具体的信息，可以向我提出更详细的问题，我将尽力为您解答。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值