SpringBoot2整合Redis Cluster

最新推荐文章于 2024-08-09 17:26:23 发布
最新推荐文章于 2024-08-09 17:26:23 发布
阅读量761 收藏 3
点赞数
分类专栏： SpringBoot Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jushisi/article/details/109485255
版权

PS：此处用jedis连接池，也可以选择lettuce连接池，参考链接：springboot2.x 整合redis集群的几种方式

一、修改pom文件，加入redis相关依赖

<!--redis相关-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<!-- 排除lettuce包 spring boot 2.X 默认用的lettuce客户端，spring boot 1.X 默认用的jedis客户端 -->
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>3.1.0</version>
</dependency>
<!--redis相关-->

二、在application.properties中添加redis相关配置

# redis相关 cluster
spring.redis.password=123456
spring.redis.timeout=5000
spring.redis.cluster.nodes=192.168.164.101:6379,192.168.164.101:6380,192.168.164.102:6379,192.168.164.102:6380,192.168.164.103:6379,192.168.164.103:6380
# redis相关 jedis连接池方式
spring.redis.jedis.pool.max-active=1000
spring.redis.jedis.pool.max-wait=-1ms
spring.redis.jedis.pool.max-idle=10
spring.redis.jedis.pool.min-idle=5

三、连接池注入配置信息

/**
 * @author jushisi
 * @description 连接池注入配置信息
 */
@Configuration
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory factory;

    /**
     * @description RedisTemplate 对五种数据结构分别定义了操作

        redisTemplate.opsForValue(); // 操作字符串

        redisTemplate.opsForHash(); // 操作hash

        redisTemplate.opsForList(); // 操作list

        redisTemplate.opsForSet(); // 操作set

        redisTemplate.opsForZSet(); // 操作有序set

     * @author jushisi
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     * @description StringRedisTemplate 是 RedisTemplate<K, V>  子类
     * StringRedisTemplate 只能对 key=String，value=String 的键值对进行操作，RedisTemplate 可以对任何类型的 key-value 键值对操作。
     * @author jushisi
     */
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

}

配置完后就可以使用redisTemplate对redis进行操作了，如下：

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

四、redis操作工具类

新建下面的RedisUtils类后，就可以直接使用了，如下 ：

   @Autowired
   private RedisUtils redisUtils;

/**
 * @author jushisi
 * @description Redis操作工具类
 */
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate ;

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public  boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public  boolean expire(final String key, final long timeout, final TimeUnit unit) {
        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public long getTime(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 查询key是否存在
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 移除指定key 的过期时间
     *
     * @param key
     * @return
     */
    public boolean persist(String key) {
        return redisTemplate.boundValueOps(key).persist();
    }

    /**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value);
        }
    }

    /**
     * 批量添加 key (重复的键会覆盖)
     *
     * @param keyAndValue
     */
    public void batchSet(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSet(keyAndValue);
    }

    /**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     *
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String, String> keyAndValue) {
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     *
     * @param key
     * @param number
     */
    public Long increment(String key, long number) {
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     *
     * @param key
     * @param number
     */
    public Double increment(String key, double number) {
        return redisTemplate.opsForValue().increment(key, number);
    }


    /**
     * 删除单个key
     *
     * @param key 键
     * @return true=删除成功；false=删除失败
     */
    public  boolean delKey(final String key) {
        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }

    /**
     * 删除多个key
     *
     * @param keys 键集合
     * @return 成功删除的个数
     */
    public  long delKeys(final Collection<String> keys) {
        Long ret = redisTemplate.delete(keys);
        return ret == null ? 0 : ret;
    }

    // --------------------------------------------------存储Hash相关--------------------------------------------------

    /**
     * 删除Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash对象集合
     */
    public  long hashDeleteKeys(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key,hKey);
    }


    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public  void hashPut(final String key, final String hKey, final Object value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 加入缓存
     *
     * @param key 键
     * @param map 键
     * @return
     */
    public void add(String key, Map<String, String> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }


    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public  List<Object> hashMultiGet(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获取 key 下的 所有  hashkey 和 value
     *
     * @param key 键
     * @return
     */
    public Map<Object, Object> getHashEntries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 验证指定 key 下 有没有指定的 hashkey
     *
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 获取指定key的值string
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public String getMapString(String key, String key2) {
        return redisTemplate.opsForHash().get("map1", "key1").toString();
    }

    /**
     * 获取指定的值Int
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public Integer getMapInt(String key, String key2) {
        return (Integer) redisTemplate.opsForHash().get("map1", "key1");
    }

    /**
     * 弹出元素并删除
     *
     * @param key 键
     * @return
     */
    public String popValue(String key) {
        return redisTemplate.opsForSet().pop(key).toString();
    }

    /**
     * 删除指定 hash 的 HashKey
     *
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */
    public Long delete(String key, String... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey, long number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Double increment(String key, String hashKey, Double number) {
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 获取 key 下的 所有 hashkey 字段
     *
     * @param key
     * @return
     */
    public Set<Object> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * 获取指定 hash 下面的 键值对 数量
     *
     * @param key
     * @return
     */
    public Long hashSize(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    // --------------------------------------------------存储Set相关操作--------------------------------------------------

    /**
     * 将数据放入set缓存
     *
     * @param key 键
     * @return
     */
    public void sSet(String key, String value) {
        redisTemplate.opsForSet().add(key, value);
    }

    /**
     * 获取变量中的值
     *
     * @param key 键
     * @return
     */
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 随机获取变量中指定个数的元素
     *
     * @param key   键
     * @param count 值
     * @return
     */
    public void randomMembers(String key, long count) {
        redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 随机获取变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object randomMember(String key) {
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 弹出变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object pop(String key) {
        return redisTemplate.opsForSet().pop("setValue");
    }

    /**
     * 获取变量中值的长度
     *
     * @param key 键
     * @return
     */
    public long size(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 检查给定的元素是否在变量中。
     *
     * @param key 键
     * @param obj 元素对象
     * @return
     */
    public boolean isMember(String key, Object obj) {
        return redisTemplate.opsForSet().isMember(key, obj);
    }

    /**
     * 转移变量的元素值到目的变量。
     *
     * @param key     键
     * @param value   元素对象
     * @param destKey 元素对象
     * @return
     */
    public boolean move(String key, String value, String destKey) {
        return redisTemplate.opsForSet().move(key, value, destKey);
    }

    /**
     * 批量移除set缓存中元素
     *
     * @param key    键
     * @param values 值
     * @return
     */
    public void remove(String key, Object... values) {
        redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 通过给定的key求2个set变量的差值
     *
     * @param key     键
     * @param destKey 键
     * @return
     */
    public Set<Object> difference(String key, String destKey) {
        return redisTemplate.opsForSet().difference(key, destKey);
    }

    // --------------------------------------------------存储ZSet相关操作--------------------------------------------------

    /**
     * 往ZSet中存入数据
     *
     * @param key Redis键
     * @param values 值
     * @return 存入的个数
     */
    public  long zsetSet(final String key, final Set<ZSetOperations.TypedTuple<Object>> values) {
        Long count = redisTemplate.opsForZSet().add(key, values);
        return count == null ? 0 : count;
    }
    /**
     * 获取所有zset数据
     * @param key Redis键
     */
    public Set<ZSetOperations.TypedTuple<Object>> zgetSetAll(final String key) {
        return redisTemplate.opsForZSet().rangeWithScores(key,0,-1);
    }
    /**
     * 获取指定区间的元素,注意是区间不是score
     * @param start 开始位置
     * @param end 结束位置
     * @param key Redis键
     */
    public  Set<ZSetOperations.TypedTuple<Object>> zgetSet(final String key,long start,long end) {
        return redisTemplate.opsForZSet().rangeWithScores(key,start,end);
    }

    /**
     * 通过score区间获取zset数据
     * @param min 最小分数
     * @param max 最大分数
     * @param key Redis键
     */
    public  Set<ZSetOperations.TypedTuple<Object>> zgetSetbyScore(final String key,double min, double max) {
        return redisTemplate.opsForZSet().rangeByScoreWithScores(key,min,max);
    }
    /**
     * 删除ZSet中的数据
     *
     * @param key Redis键
     * @param values 值
     * @return 移除的个数
     */
    public  long zsetDel(final String key, Object... values) {
        Long count = redisTemplate.opsForZSet().remove(key, values);
        return count == null ? 0 : count;
    }

    // --------------------------------------------------存储List相关操作--------------------------------------------------

    /**
     * 在变量左边添加元素值
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPush(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 获取集合指定位置的值。
     *
     * @param key
     * @param index
     * @return
     */
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index("list", 1);
    }

    /**
     * 获取指定区间的值。
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 把最后一个参数值放到指定集合的第一个出现中间参数的前面，
     * 如果中间参数值存在的话。
     *
     * @param key
     * @param pivot
     * @param value
     * @return
     */
    public void leftPush(String key, String pivot, String value) {
        redisTemplate.opsForList().leftPush(key, pivot, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void leftPushAll(String key, String... values) {
        redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 向集合最右边添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void leftPushAll(String key, String value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void rightPushAll(String key, String... values) {
        //redisTemplate.opsForList().leftPushAll(key,"w","x","y");
        redisTemplate.opsForList().rightPushAll(key, values);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @param value
     * @return
     */
    public void rightPushIfPresent(String key, Object value) {
        redisTemplate.opsForList().rightPushIfPresent(key, value);
    }

    /**
     * 向已存在的集合中添加元素。
     *
     * @param key
     * @return
     */
    public long listLength(String key) {
        return redisTemplate.opsForList().size(key);
    }

    /**
     * 移除集合中的左边第一个元素。
     *
     * @param key
     * @return
     */
    public void leftPop(String key) {
        redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public void leftPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().leftPop(key, timeout, unit);
    }

    /**
     * 移除集合中右边的元素。
     *
     * @param key
     * @return
     */
    public void rightPop(String key) {
        redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
     *
     * @param key
     * @return
     */
    public Object rightPop(String key, long timeout, TimeUnit unit) {
        return redisTemplate.opsForList().rightPop(key, timeout, unit);
    }
}
jushisi
关注
专栏目录
【微服务】springboot整合redis哨兵集群使用详解
congge
08-02 5206
springboot整合redis哨兵集群使用详解
springboot2与redis整合
二月初二
04-05 4065
Redis，对于大家来说应该不陌生，是经常使用的开发技术之一。原始的RDBMS关系型数据库，能够存储海量的数据，但是在某些特殊的情况下，性能并不是特别的好，例如热点数据的读写，数据缓存等。Redis作为NoSQL中的一员，基于内存数据存储，支持多种数据结构，单线程处理，是一款高性能的可持久化key-value数据库。对于Redis就不做过多介绍了，相信大家或多或少都了解过，下面重点描述Spring...
SpringBoot2.X整合redis连接lettuce增强版本，支持多数据库切换，主从集群，哨兵
03-22
基于`SpringBoot2.X + Lettuce`实现Redis集成和多库实时切换是一个非常实用的项目。以下是对该项目的一些重点说明: 1. **项目概述** 该项目的主要目标是在`SpringBoot`应用中集成`Lettuce`作为Redis客户端,实现对Redis的高效访问和操作。同时,通过自定义配置和注入不同的`RedisTemplate`实例,可以轻松实现多库切换,满足不同场景下的需求。 2. **技术栈** 项目采用了当前流行的`SpringBoot 2.X`版本作为基础框架,并且集成了`Lettuce`作为Redis客户端。`Lettuce`是一个高性能的Redis客户端,基于Netty框架,提供了同步、异步和响应式的操作方式,可以显著提高Redis操作的性能和并发支持。 3. **Redis连接配置** 项目中通过`application.properties`或`application.yml`文件配置Redis连接信息,如主机地址、端口号、密码等。可以配置多个Redis实例,用于实现多库切换。
7.spring-boot2 ------redis cluster
Berg的学习历程
08-11 307
1.修改pom文件,添加redis依赖: &lt;!--redis 使用--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;...
实战 Springboot2 集成Redis 哨兵模式、集群模式、缓存管理、Lettuce拓扑刷新
最新发布
minjun的博客
08-09 570
SpringBoot Redis 使用Lettuce和Jedis配置哨兵模式、集群以及集群自适应集群拓扑刷新和动态刷新；缓存管理
15-SpringBoot之Redis(二)——Redis Cluster
HJ的技术博客
11-21 384
SpringBoot之Redis（二）——Redis Cluster 与整合单机Redis相比，SpringBoot整合Redis Cluster只需修改application.yml配置文件如下： spring: redis: cluster: nodes: 172.28.65.111:7001,172.28.65.112:7003,172.28.65.113:7006 ...
springboot2.x 集成 redis cluster
qq_38946877的博客
08-09 384
springboot2.x 集成 redis cluster 1，添加依赖 <?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 ht
springboot2集成redis
chenyidong521的博客
04-03 3985
首先在pom文件中添加节点 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-redis&lt;/artifactId&gt; &lt;version&gt;1.3.8....
SpringBoot整合Redis集群（JedisCluster）
HuanBuXingDeXingXing的博客
11-13 1445
简单SpringBoot项目的搭建：https://blog.csdn.net/HuanBuXingDeXingXing/article/details/109670434 Pom.xml文件添加Maven依赖： 这里由于parent中已经包含版本号了，此处不应该再指定版本号 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <arti.
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
springboot整合redis,springboot连接redis集群
04-08
在Spring Boot框架中整合Redis和连接Redis集群是一项常见的任务，特别是在构建高性能、高并发的Web应用时。Redis是一个开源的、基于内存的数据结构存储系统，常被用作数据库、缓存和消息中间件。Spring Boot提供了对...
Springboot2.X集成redis集群(Lettuce)连接的方法
08-27
主要介绍了Springboot2.X集成redis集群(Lettuce)连接的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot篇】二十二. springboot整合Redis集群
TheNew_One的博客
04-09 331
springboot整合Redis集群**中国加油，武汉加油！**篇幅较长，配合目录观看案例准备1. 新建Springboot项目springboot-redis-sentinel2. 编写yml3. Test4. 停掉主服务器 （6380）在Test一边(可能需要一点时间) 中国加油，武汉加油！ 篇幅较长，配合目录观看 案例准备 本案例基于liunx篇】 十二. Redis集群概念和Redis...
SpringBoot2.x整合Redis集群
qq_37163392的博客
02-19 253
SpringBoot2.x整合Redis集群 添加依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- 连接池 --> <dependency&gt
springboot2整合redis集群（lettuce连接池）
qq_33334411的博客
10-22 1030
springboot2整合redis集群（lettuce连接池）引入相关jar包配置==application.yml==文件添加配置类测试 引入相关jar包 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.6.RELEASE&lt
springboot2.x整合redis缓存
热门推荐
王大人的博客
05-08 1万+
1.引入pom&lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt;2.application.ymlspring: ...
Spring boot2.x整合redis 或者 集群
zgz15515397650的博客
02-27 785
一、搭建单机版的redis 1.pom.xml Spring boot 2.0以上的redis都是使用 lettuce来进行链接的，不过这里用的是jedis &lt;!--redis--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
SpringBoot2.x整合Redis 分布式集群_01
Gblfy_Blog
04-19 612
文章目录一、节点分布总览二、实战2.1. 搭建redis单机模式2.2. 集群配置2.3. 启动集群2.4. 节点握手 Redis 分布式集群能解决的问题 集群 概念 解决现有系统单节点并发压力和物理上限问题 通过添加服务器的数量，提供相同的服务，从而让服务器达到一个稳定、高效的状态 一、节点分布总览 演示案例 3主3从 横向扩展 服务器 端口 节点说明 192...
Redis集群搭建（单机环境），Springboot 2.x 集成 Redis 集群
大西瓜的博客
06-30 1438
Springboot 2.x 集成 Redis 集群 1、Redis集群搭建（单机） 1、创建文件夹 2、进入env目录执行 echo -e "port 7001\ncluster-enabled yes\ndir /data/tfd/7001\ncluster-config-file nodes-7001.conf\npidfile "/data/tfd/7001/redis-7001.pid"\nlogfile "/data/tfd/7001/redis-7001.log"\nappendonly
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值