SpringBoot（十九）集成Redis

最新推荐文章于 2024-06-12 09:10:36 发布
最新推荐文章于 2024-06-12 09:10:36 发布
阅读量1k 收藏 1
点赞数 3
分类专栏： Spring Boot 文章标签： redis spring boot boot整合redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45606067/article/details/108158783
版权

SpringBoot 集成 Redis 主要就是使用 RedisTemplate 类来进行各种操作。可以很多人没有注意到，在 SpringBoot 2.x 之后，底层访问redis 已经不再使用 jedis，而是 lettuce。

至于 jedis 和 lettuce 有什么区别呢，对我们有什么影响呢？

jeids：采用的直连redis server，在多个线程之间共用一个 jedis 实例时，是线程不安全的，如果想要避免线程不安全的，使用 jedis pool 连接池，这样每个线程单独使用一个 jedis 实例。由此带来的问题是，如果线程数过多，带来redis server的负载加大。有点类似于 BIO 模式。

lettuce：采用 netty 连接 redis server，实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数量，在特殊情况下，lettuce 也可以使用多个实例。有点类似于 NIO 模式。

整合测试

1、新建一个 SpringBoot 项目

2、引入 spring-boot-starter-data-redis 的坐标

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

3、配置redis连接

# Redis 服务地址
spring.redis.host=127.0.0.1
# Reds 服务连接端口
spring.redis.port=6379

3、测试使用

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        // 操作不同的数据类型，api和我们的命令是一样的
        redisTemplate.opsForValue();//操作字符串
        redisTemplate.opsForHash();//操作hash
        redisTemplate.opsForList();//操作list
        redisTemplate.opsForSet();//操作set
        redisTemplate.opsForZSet();//操作有序set

        // 除了基本的操作，我们常用的方法可以直接通过redisTemplate 操作，比如事务，和基本的CRUD

        // 获取redis 的连接对象
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushAll();
        connection.flushDb();
    }

    @Test
    public void contextLoads2(){
        redisTemplate.opsForValue().set("mykey","zhangsan");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

}

源码分析

查看一下源码：RedisAutoConfiguration 自动配置类

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate") // 我们可以自己定义一个RedisTemplate 来替换这个默认的
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		// 默认的 RedisTemplate 没有过多的设置，redis对象都是需要序列化的
		// 两个泛型都是<Object, Object> 类型，我们后面使用需要强制转换<String, String>
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
	
	@Bean
	@ConditionalOnMissingBean  // 由于String 是redis 是最常使用的类型，所以丹玉提出来一个bean。
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}
}

点进去查看：RedisProperties 配置文件

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
	private int database = 0; 	// 使用的0号数据库，默认是16个	
	private String url;	// url地址
	private String host = "localhost";	
	private String password;	// 密码
	private int port = 6379;	// 端口
	private boolean ssl;	// 是否开启安全连接
	private Duration timeout;	// 超时等待
	private String clientName;	// 客户端名字
	private Sentinel sentinel;	// 哨兵模式
	private Cluster cluster;	// 集群
	private final Jedis jedis = new Jedis();
	private final Lettuce lettuce = new Lettuce();
}

继续探索源码：RedisTemplate

在这里插入图片描述
往下看继续看，在这里插入图片描述
通过源码可以看出，SpringBoot 自动帮我们在容器中生成了一个 RedisTemplate 和一个 StringRedisTemplate。

但是，这个 RedisTemplate 的泛型是 <Obejct,Object> ，写代码不方便，需要写好多类型转换的代码，我们需要一个泛型为<String,Object> 形式的 RedisTemplate。

而且，这个 RedisTemplate 没有设置数据存在 Redis 时，key 及 value 的系列化方式。

Spring Data Redis 提供了 RedisSerializer 接口，同时提供了多个实现该接口的系列化工具，如 JdkSerializationRedisSerializer，Jackson2JsonRedisSerializer 和 GenericToStringSerializer 等。通过调用其实例的 serialize 和 deserialize 进行序列化和反序列化。

关于对象的保存

1、新建一个User类

@Component
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String name;
    private int age;

}

2、插入测试

@Test
public void contextLoads3() throws JsonProcessingException {
    // 真实的开发中一般使用json来传递对象
    User user = new User("蛋蛋", 3);
//        String jsonUser = new ObjectMapper().writeValueAsString(user);
    redisTemplate.opsForValue().set("user",user);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

发现报错，原因是实体类没有序列化。

在这里插入图片描述
此时我们把User类 实现 Serializable 类，重新测试即可。

看到这个 ConditionalOnMissingBean 注解后，就知道如果 Spring 容器有了 RedisTemplate 对象了，这个自动配置的 RedisTemplate 不会实例化。因此我们可以直接自己写一个配置类，配置 RedisTemplate 。

3、既然自动配置不好用，就重新配置一个 RedisTemplate

@Configuration
public class RedisConfig {

    // 编写自己的 RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
            throws UnknownHostException {
        // 我们为了自己开发方便，一般使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String的序列化
        StringRedisSerializer stringRedisSerializer =new StringRedisSerializer();

        // key 采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的key 也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value 序列化方式采用 Jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 value序列化方式采用 Jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

}

重新测试插入数据，可以看到 redis中 没有转义字符。

4、写一个 Redis 工具类（直接用 RedisTemplate 操作redis，需要很多行代码，可以直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils 交给Spring 容器实例化，使用时直接注解注入）

@Component
public final class RedisUtil {

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    /**
     * 指定缓存失效时间
     * @param key  键
     * @param time 时间（秒）
     * @return
     */
    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;
        }
    }

    /**
     * 根据 key 获取过期时间
     * @param key 键  不能为null
     * @return 时间（秒）返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key 是否存在
     * @param key 键
     * @return true 存在 false 不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值  或多个
     */
    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));
            }
        }
    }

    /**
     * 普通缓存获取
     * @param key
     * @return
     */
    public Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存存入
     * @param key  键
     * @param value  值
     * @return  true 成功  false 失败
     */
    public boolean set(String key, Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        } catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间（秒） time要大于 0 如果time 小于等于0 将设置无限期
     * @return  true 成功  false 失败
     */
    public boolean set(String key ,Object value ,long time){
        try {
            if (time > 0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else{
                set(key,value);
            }
            return true;
        } catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几（大于0）
     * @return
     */
    public long incr(String key,long delta){
        if (delta < 0 ){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几（小于0）
     * @return
     */
    public long decr(String key,long delta){
        if (delta < 0 ){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return
     */
    public Object hget(String key, String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey 对应的所有键值
     * @param key
     * @return
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return
     */
    public boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间（秒）
     * @return true 成功  false 失败
     */
    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;
        }
    }

    /**
     * 向一张hash 表中放入数据，如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功  false 失败
     */
    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;
        }
    }

    /**
     * 删除hash 表中的值
     * @param key 键 不能为null
     * @param item 项 可以是多个  不能为null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 可以是多个  不能为null
     * @return
     */
    public boolean hHashKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key,item);
    }

    /**
     * hash 递增  如果不存在，就不创建一个  并不新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几（大于0）
     * @return
     */
    public double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash 递增
     * @param key 键
     * @param item 项
     * @param by 要减少几（小于0）
     * @return
     */
    public double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    /**
     * 根据 key 获取Set中的所有值
     * @param key
     * @return
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

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

    /**
     * 将数据存放入set缓存
     * @param key 键
     * @param values 值，可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values){
        try {
            return redisTemplate.opsForSet().add(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据存入缓存
     * @param key 键
     * @param time 时间（秒）
     * @param values 值 可以是多个
     * @return 成功个数
     */
    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;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key
     * @param values
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values){
        try {
            Long count =redisTemplate.opsForSet().remove(key, values);
            return count;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取list缓存的内容
     * @param key
     * @param start
     * @param end 结束 0 到 -1 代表所有值
     * @return
     */
    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;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引获取list中的值
     * @param key
     * @param index
     * @return 索引index>= 0时 0表头，1 第二个元素
     */
    public Object IGetIndex(String key, long index){
        try{
            return redisTemplate.opsForList().index(key,index);
        } catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list 放入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean lSet(String key, Object value){
        try {
            redisTemplate.opsForList().rightPush(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean lSet(String  key, List<Object> value){
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key
     * @param value
     * @param time
     * @return
     */
    public boolean lSet(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;
        }
    }

    /**
     * 感觉索引修改list 中的某条数据
     * @param key
     * @param index
     * @param value
     * @return
     */
    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;
        }
    }

    /**
     * 移除N个值为value
     * @param key
     * @param count
     * @param value
     * @return
     */
    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;
        }
    }

}

编写完工具类， 以后再调用就变得尤其的简单了。

如果有收获！！！ 希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客
七月J
关注
专栏目录
springboot redis 断线重连_Redis(9)——史上最强【集群】入门实践教程
weixin_39755853的博客
11-22 1401
一、Redis 集群概述Redis 主从复制到 目前 为止，我们所学习的 Redis 都是 单机版 的，这也就意味着一旦我们所依赖的 Redis 服务宕机了，我们的主流程也会受到一定的影响，这当然是我们不能够接受的。所以一开始我们的想法是：搞一台备用机。这样我们就可以在一台服务器出现问题的时候切换动态地到另一台去：幸运的是，两个节点数据的同步我们可以使用 Redis 的 主从同步 功能帮助到我们，...
调研Redis高可用两种方案
weixin_45583158的博客
05-14 301
导读：Redis是被广泛使用的基础软件之一。对于工程师和,架构师，运维人员来说，了解Redis的高可用方案和背后的原理，是必备的基础知识。本文作者深入分析了Redis高可...
SpringCache加Redis做缓存
weixin_43795939的博客
02-09 346
Redis + SpringCache 1. 添加依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- spring2.X集成redis所需common-poo
redis 主从_Redis复制：主从同步
weixin_39542850的博客
12-08 218
一、概述 在高并发服务当中，如果使用单个Redis实例，由于Redis采用单进程单线程处理所有请求的方式，即每次只有一个请求在处理，后面的请求排队，如果前面请求执行时间长了，则会影响后面所有请求。所以可以拓展到多个Redis实例，采用主从机制，一个master和多个slave，master和多个slave包含相同的数据，master负责处理写请求，slave负责读请求。Redis主从同步即是实现这...
6k+点赞的SpringBoot+Netty分布式即时通讯系统！爱了爱了！
singwhatiwanna
09-15 431
最近公司开发需要用到 IM 系统，自己开发的话需要耗费较多时间和精力。于是我们考虑在开源项目的基础上二次开发，我们对比了较多开源方案之后，选择了 CIM[1] 。项目简介CIM（...
Springboot整合redis抛IO异常：主机中断了一个连接
m0_50981357的博客
11-10 664
springboot整合redis抛IO异常:主机中断连接
springBoot集成redis
03-03
本文将详细介绍如何在Spring Boot项目中集成Redis和MyBatis，以实现数据缓存和数据库操作。 首先，为了在Spring Boot项目中引入Redis，我们需要在`pom.xml`文件中添加Spring Data Redis依赖： ```xml <groupId>...
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
商城秒杀项目，基于springboot开发，使用redis和rocketmq技术增加高并发能力
02-16
《基于SpringBoot的商城秒杀系统：Redis与RocketMQ在高并发下的应用》 商城秒杀项目是一项技术挑战性极高的任务，它需要系统具备处理大量并发请求的能力，以确保在短时间内顺利完成用户的秒杀操作。在这个项目中，...
springboot集成测试里的redis
08-26
SpringBoot 集成测试中的 Redis 在 SpringBoot 项目中，集成测试是一个非常重要的步骤，它可以确保我们的应用程序在不同的场景下都能正常工作。在这个过程中，Redis 是一个非常重要的组件，因为它可以作为缓存层、...
Spring Boot Redis 集成配置详解
08-30
本篇文章主要介绍了Spring Boot Redis 集成配置详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot +shiro+redis实现session共享（方案二）1
08-08
Shiro 是一个功能强大且灵活的权限控制框架，可以与 Spring Boot 集成以实现权限控制。在本方案中，Shiro 将用于实现登录 session 的统一。 6. Session 共享 通过使用 Redis 作为 Session 存储，多个应用服务器...
redis高可用原理及demo
05-14 154
示例代码 https://github.com/Abradat/redis-sentinel 原理 原文：https://www.codedump.info/post/20190409-redis-sentinel/ redis中为了实现高可用（High Availability，简称HA），采用了如下两个方式： 主从复制数据。 采用哨兵监控数据节点的运行情况，一旦主...
springboot redis 断线重连_Redis复制：部分同步PSYNC详解
weixin_39958025的博客
12-08 304
概述在Redis2.8之前，如果从服务器在主从复制的过程中，出现了断线，重连之后需要全量同步一次主服务器上面的数据，即从服务器发送SYNC命令给主服务器，请求进行全量同步，但是断线重连之后，从服务器只是可能落后主服务器断线期间的写入或者如果断线时间非常短，主从之间数据还是一致的，故如果简单地进行全量同步，则会造成主从服务器之间CPU，内存，网络带宽方面的浪费。故在Redis2.8及其之后版本，对于...
使用 Spring Boot 结合断点续传技术和自动重连机制实现考试系统网络不稳定性的应对策略
最新发布
wjianwei666的专栏
06-12 838
断点续传（Resumable Download/Upload）技术广泛用于文件传输，可以在数据传输的过程中记录文件的传输位置（断点），中断后重新恢复传输时从断点继续。这种机制同样适用于网络通信，可以在网络恢复时重新发送或接收未完成的数据，从而确保任务的完整性。通过Spring Boot结合断点续传技术和自动重连机制可以显著提高在线考试系统的健壮性和用户体验。本文详细介绍了使用Spring Boot实现考试进度的保存和恢复、数据一致性验证以及防止考试作弊的策略。
SpringBoot配置Redis连接池
热门推荐
u010473656的专栏
12-18 3万+
spring boot 配置Redis 连接池
Redis学习笔记6：基于springboot的Lettuce redis客户端ConnectionWatchdog断线重连时间ExponentialDelay延迟策略
OceanSky的专栏
10-28 1079
lettuce断线重连监视器ConnectionWatchdog#scheduleReconnect方法中的延迟重连时间是根据io.lettuce.core.resource.Delay策略来决定，默认是采用ExponentialDelay延迟策略，即2的幂次方，即时间是PT0.001S、PT0.002S、PT0.004S一直到最大PT30S。一个对springboot redis框架进行重写，支持lettuce、jedis、连接池、同时连接多个集群、多个redis数据库、开发自定义属性配置的开源SDK。
Redis的主从复制是如何做的？复制过程中也会产生各种问题？
资料免费分享，点击名片
07-08 352
如果Redis的读写请求量很大，那么单个实例很有可能承担不了这么大的请求量，如何提高Redis的性能呢？你也许已经想到了，可以部署多个副本节点，业务采用读写分离的方式，把读请求分担到多个副本节点上，提高访问性能。要实现读写分离，就必须部署多个副本，每个副本需要实时同步主节点的数据。 Redis也提供了完善的主从复制机制，使用非常简单的命令，就可以构建一个多副本节点的集群。 同时，当主节点故障宕机时，我们可以把一个副本节点提升为主节点，提高Redis的可用性。可见，对于故障恢复，也依赖Redis的主从复制，它
springboot redis 断线重连_redis主从复制
nizhongli37的博客
07-20 669
https://blog.csdn.net/weixin_39811842/article/details/111020517
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值