springboot redis使用

最新推荐文章于 2024-09-20 09:18:43 发布
最新推荐文章于 2024-09-20 09:18:43 发布
阅读量67 收藏
点赞数
文章标签： redis java python mysql 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24281575/article/details/109112812
版权
本文介绍了如何在SpringBoot项目中整合并使用Redis，包括Maven添加依赖、application.yml配置、Redis配置类的编写以及Redis操作工具类的实现。虽然未进行完整测试，但提供了基本的使用流程。
摘要由CSDN通过智能技术生成
  1. maven导包
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- 对象池，使用redis时必须引入 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.application.yml配置

spring:
  redis:
    host: localhost
    port: 6379
    # 连接超时时间
    timeout: 10000ms
    # Redis默认情况下有16个分片，这里配置具体使用的分片
    database: 0
    lettuce:
      pool:
        # 连接池最大连接数（使用负值表示没有限制） 默认 8
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
        max-wait: -1ms
        # 连接池中的最大空闲连接 默认 8
        max-idle: 8
        # 连接池中的最小空闲连接 默认 0
        min-idle: 0
  cache:
    # 一般来说是不用配置的，Spring Cache 会根据依赖的包自行装配
    type: redis

3.redis配置类

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis客户端配置
 *
 * @author archie
 * @date 2020-10-13
 */
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
@EnableCaching
public class RedisConfig {

    private final StringRedisSerializer srs = new StringRedisSerializer();
    private final Jackson2JsonRedisSerializer<Object> jsonRedisSerializer =
            new Jackson2JsonRedisSerializer<>(Object.class);

    /**
     * 配置key,value的序列化方式
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(srs);
        template.setHashKeySerializer(srs);
        template.setDefaultSerializer(jsonRedisSerializer);
        return template;
    }

    /**
     * 配置使用注解的时候缓存配置，默认是序列化反序列化的形式，加上此配置则为 json 形式
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
        RedisCacheConfiguration redisCacheConfiguration = config.serializeKeysWith(RedisSerializationContext
                .SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(
                        RedisSerializationContext.SerializationPair
                                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(factory).cacheDefaults(redisCacheConfiguration).build();
    }
}

4.redis操作工具类
ps:没有全部测过

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

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

/**
 * redis操作工具类
 *
 * @author linaq
 * @date 2020-10-13
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    //- - - - - - - - - - - - - - - - - - - - -  公共方法 - - - - - - - - - - - - - - - - - - - -

    /**
     * 给一个指定的 key 值附加过期时间
     *
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time) {
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 根据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 boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除keys
     *
     * @param keys
     * @return
     */
    public boolean deleteKeys(Collection<String> keys) {
        return redisTemplate.delete(keys) == keys.size();
    }

    /**
     * 删除key like
     *
     * @param key
     * @return
     */
    public boolean deleteKeyLike(String key) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        Set<String> keys = redisTemplate.keys(key + "*");
        if(keys.isEmpty()){
            return false;
        }
        return deleteKeys(keys);
    }


    //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 根据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);
    }

    //- - - - - - - - - - - - - - - - - - - - -  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(key);
    }

    /**
     * 获取变量中值的长度
     *
     * @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);
    }


    //- - - - - - - - - - - - - - - - - - - - -  hash类型 - - - - - - - - - - - - - - - - - - - -

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

    /**
     * 加入缓存
     *
     * @param key
     * @param key1
     * @return
     */
    public void add(String key, String key1, Object value) {
        redisTemplate.opsForHash().put(key, key1, value);
    }

    /**
     * 获取 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的值
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public Object getMap(String key, String key2) {
        return redisTemplate.opsForHash().get(key, key2);
    }

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

    /**
     * 删除指定 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);
    }

    //- - - - - - - - - - - - - - - - - - - - -  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(key, index);
    }

    /**
     * 获取指定区间的值。
     *
     * @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, Object... values) {
        redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void leftPushAll(String key, Collection<Object> 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().rightPushAll(key, values);
    }

    /**
     * 向左边批量添加参数元素。
     *
     * @param key
     * @param values
     * @return
     */
    public void rightPushAll(String key, Collection<Object> values) {
        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 void rightPop(String key, long timeout, TimeUnit unit) {
        redisTemplate.opsForList().rightPop(key, timeout, unit);
    }
}
qq_24281575
关注
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
springboot2.x使用redis作为缓存（使用fastjson序列化的方式，并调试反序列化异常）
qq_33999844的博客
08-29 1万+
1.redis是内存数据库，可以单独作为数据库（有持久化方案），也可以作为缓存（一般为MySQL搭配）        1.1 可以通过jedis，代码的方式手动将其传入redis作为缓存；        1.2 也可以通过注解的方式，和spring boot整合，通过@cacheable...的方式自动存入redis（本文的探讨方式） 2.springboot2.x与1.x版本用法相差较大 ...
SpringBoot——缓存(注解的使用，整合Redis，自定义CacheManager）
努力找工作呀
07-31 3380
1.JSR107 Java Caching定义了5个核心接口： CachingProvider：定义了创建，配置，获取，管理和控制多个CacheManager。一个应用可以在运行期间访问多个CachingProvider。 CacheManager：定义了创建，配置，获取和控制多个Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有 Cache：一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache
SpringBoot Redis使用fastjson进行序列化
大树叶 技术专栏
07-27 2790
在使用spring-data-redis,默认情况下是使用org.springframework.data.redis.serializer.JdkSerializationRedisSerializer这个类来做序列化,Jackson redis序列化是spring中自带的.我们使用jackson方式 @Bean(name="redisTemplate") public RedisTemplate<String, Object> redisTemplate() {
【实践篇】4.12 SpringBoot Redis 使用Lettuce和Jedis配置哨兵模式
日拱一卒无有尽，功不唐捐终入海
07-24 4256
在Spring Boot 中配置Redis哨兵模式，可以使用 Lettuce 或 Jedis 配置 Redis 哨兵模式，实现高可用的 Redis 集群。因为在Spring Boot中已经实现了两种客户端链接方式，我们选择其中一种就可以。在 Spring Boot 中，可以通过 RedisConnectionFactory 来连接 Redis。
springboot使用Redis
yxixiOvo的博客
05-28 1257
这里选择在linux安装redis，因为Windows的redis版本比较低，并且后面学习学习部署等也会用到linux，所以建议安装一个虚拟机。别急还有反转 还有另一个大佬因为觉得很麻烦但是又不想掏钱 就写了一个脚本只要上面的大佬一更新，就自动更新 主打一个自己动手丰衣足食。4.因为前面允许了任何地址都可以访问，这样就不安全了，所以我们需要开启一个密码。解压到当前目录 注意我是进入了当前文件的 所以可以直接就解压。因为redis是由C语言编写的，所以需要由cgg的环境。
Springboot Redis使用pipeline进行批量插入数据优化
进步让人兴奋
08-24 3839
一、前言 之前做一个业务，需要把缓存数据存到redis中，一开始使用了for循环，检测后发现数据量一大，就会很慢，1w条数据就需要快2分钟。 原始的代码如下： LOG.info("开始写入新增数据缓存"); for (int i = 0; i < addCompList.size(); i++) { AddDataCacheVo addDataCacheVo = new AddDataCacheVo(); CompanyImportVo companyImportVo = addCom
springboot使用redis
qq_49044908的博客
12-12 4万+
springboot使用redis redis-service.exe : 服务端,启动后不要关闭 redis-cli.exe : 客户端,访问redis中的数据 redisclient-win32.x86_64.2.0.jar : redis的图形界面客户端,执行方式是在这个文件的目录执行 java -jar redisclient-win32.x86_64.2.0.jar 或者在这个jar包的目录下点击即可直接执行 点击server,点击add,设置端口号就可以访问redis了 springboot
springboot redis使用lettuce配置多数据源
conquer的博客
02-20 2200
目前项目上需要连接两个redis数据源，一个redis数据源是单机模式，一个redis数据源是分片集群模式，这里将具体配置列一下。 项目用的springboot版本为 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ve
SpringBoot Redis使用scan扫描keys出前诡异的乱码前缀
齐格的技术博客
04-22 661
在使用SpringBoot Redis里的scan方法扫描匹配的keys时出现了诡异的乱码前缀，类似如下截图： 字符串如下： ��t�online-token-eyJhbGciOiJIUzUxMiJ9.eyJqdGkiOiIwOWM1MDVkM2ZlMjE0OGVmYTk5MmQwNjhlOGVkYzNmMCIsInVzZXIiOiJhZG1pbiIsInN1YiI6ImFkbWluIn0.fB8T1s1tK6Z4SM9nGu1Dot9EXmdOoxcDaBIhcMur00RQy5PZk0fADRSf0
SpringBoot Redis配置Fastjson进行序列化和反序列化实现
10-16
在Spring Boot应用中，我们经常使用Redis作为缓存或消息队列来提升应用程序的性能。在处理Java对象与Redis之间的转换时，序列化和反序列化是必不可少的步骤。本篇将详细介绍如何在Spring Boot中配置Fastjson进行序列...
【SpringBoot】50、SpringBoot为Redis的key统一加上前缀
热门推荐
Asurplus
08-12 21万+
我们在实际的项目应用中，Redis一般都是用来缓存热点数据，一台服务器可能部署了多个应用，应用直接的 Redis 数据需要加上前缀区分开来，我们可以使用序列化的方式，统一为所有的 key 加上前缀 一、关于在 SpringBoot 中整合 Redis https://lizhou.blog.csdn.net/article/details/98358258 二、关于在 SpringBoot 中整合 Redis 实现序列化存储Java对象 https://lizhou.blog.csdn.net/artic
如何使用 maxwell 同步到 redis?
小丁的博客
09-19 708
接下来，你需要一个消费者程序来监听消息队列（如Kafka），读取Maxwell发送的变更事件，并将这些事件同步到Redis。这个消费者程序可以用Java编写，使用相应的消息队列客户端库（如Kafka的Java客户端）来读取消息，并使用Jedis或Lettuce等Redis客户端库来与Redis交互。，简称CDC）的工具，它可以将MySQL的binlog事件转换成JSON格式，并发送到消息系统中，如Kafka、RabbitMQ等。Maxwell可以将捕获的变更事件发送到消息队列系统，如Kafka。
Spring Boot 集成 Redisson 实现消息队列
大橘的博客
09-10 930
【代码】Spring Boot基于Redisson的RBlockingQueue实现简单的消息队列，适用于简单队列应用。有普通队列与延迟队列实现。
Redis的Key的过期策略是怎样实现的？
daydayup
09-19 541
在学习Redis时，我们知道可以设置Key的过期时间，我们还知道，Redis一大特点–。那么当Redis中的数据量起来时，如果直接遍历所有的Key，那么对于Key过期时间的校验应该很费时间，那么Redis究竟是怎样做的呢？本文就来探讨关于Redis中的Key的过期册策略。Redis中的过期策略有两种。
Redis 篇- 实战项目中使用 Redis 实现经典功能（异步秒杀商品、点赞功能、共同关注的好友、投喂功能）
小扳手
09-11 1940
查看消息的时候，按照时间来查看，从最新的时间到最旧的时间的顺序来进行查看，比如说，朋友圈，打开朋友圈最先看到的是最新的好友信息，用户查询自己的收件箱，比如像朋友圈，按照时间来排序好友发布的信息，而查看好友的朋友圈的时候，从上至下，来查看好友的消息。从用户集合中查询信息也不难，在实现的时候不就是直接去查看当前用户的收件箱，其实不然，需要考虑的细节还挺多的。
实战Redis与MySQL双写一致性的缓存模式
最新发布
不惑
09-20 566
​Redis和MySQL都是常用的数据存储系统，它们各自有自己的优缺点。在实际应用中，我们可能需要将它们结合起来使用，比如将Redis作为缓存，MySQL作为持久化存储。在这种情况下，我们需要保证Redis和MySQL的数据一致性，也就是当数据在Redis中进行修改时，也要相应地在MySQL中进行修改，反之亦然。
Redis（主从复制、哨兵模式、集群）概述及部署测试
pangdongqiqi的博客
09-14 1379
3、Master机器收到Slave端机器的连接后，将其完整的数据文件发送给Slave端机器，如果Mater同时收到多个Slave发来的同步请求，则Master会在后台启动一个进程以保存数据文件，然后将其发送给所有的Slave端机器，确保所有的Slave端机器都正常。2、自动故障转移：当主节点不能正常工作时，哨兵会开始自动故障转移操作，它会将失效主节点的其中一个从节点升级为新的主节点，并让其它从节点改为复制新的主节点。且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。
Redis 集群策略详解
lssffy的博客
09-16 722
为了应对这些问题，Redis 提供了**Redis 集群（Redis Cluster）**方案，通过将数据分片存储在多个节点上，实现高可用性和水平扩展。：Redis 集群具有自动故障转移机制，当集群中的某个主节点发生故障时，从节点会自动接替故障主节点，并成为新的主节点。：在 Redis 集群中，某些节点作为主节点负责处理读写请求，而其他节点作为从节点，保存主节点的数据副本。这意味着在某些场景下，从节点的数据可能会与主节点稍有不同，但经过一段时间后，从节点的数据会与主节点保持一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值