Redis实战篇--商户查询缓存

最新推荐文章于 2024-08-23 12:37:01 发布
最新推荐文章于 2024-08-23 12:37:01 发布
阅读量166 收藏
点赞数
分类专栏： Redis 文章标签： redis 缓存 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51729037/article/details/128765377
版权

Redis实战篇–商户查询缓存

缓存

缓存就是数据交换的缓冲区(称作Cache [ka])，是存数据的临时地方，一般读写性能较高。
缓存的作用

  • 降低后端负载
  • 提高读写效率
  • 降低响应时间

缓存的成本

  • 数据一致性成本
  • 代码维护成本
  • 运维成本

添加redis缓存

将店铺信息存入redis中
主要流程
在这里插入图片描述业务代码

public Result getShopById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if(!StringUtil.isNullOrEmpty(shopJson)){
            //3.存在 返回商铺信息
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4.不存在根据id在数据库中查询商铺信息
        Shop shop = getById(id);
        //5.不存在 返回错误信息
        if (shop == null) {
            return Result.fail("店铺不存在");
        }
        //6.存在 将商铺信息写入redis中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7.将商铺信息返回
        return Result.ok(shop);
    }

作业

给店铺类型查询业务添加缓存
在这里插入图片描述
主要思路与上面添加店铺信息缓存相同

  • 查询店铺类型在缓存中是否存在

    • 存在 直接返回

    • 不存在 在数据库中查询商铺类型

      • 存在 返回商铺信息列表
      • 不存在 报错
	public List<ShopType> queryShopList() {
        //1.在redis中查询是否存在缓存
        String key = RedisConstants.CACHE_SHOPlIST_KEY;
        List<String> shopList = stringRedisTemplate.opsForList().range(key, 0, -1);
        //2.缓存命中 直接返回shopList
        if (shopList.size() > 0 ) {
            List<ShopType> shopTypeList = shopList.stream().map((list) -> {
                ShopType shopType = JSONUtil.toBean(list, ShopType.class);
                return shopType;
            }).sorted(Comparator.comparing(ShopType::getSort))
            .collect(Collectors.toList());
            return shopTypeList;
        }else {
            //3.缓存未命中 则在数据库中查询shopList
            List<ShopType> typeList = query().orderByAsc("sort").list();
            List<String> strings = typeList.stream().map((shop) -> {
                return JSONUtil.toJsonPrettyStr(shop);
            }).collect(Collectors.toList());
            if(typeList.size() > 0){
                //5.存在 写入redis中
                stringRedisTemplate.opsForList().leftPushAll(key,strings);
            }//6.返回list
            return typeList;
        }
    }

使用缓存与未使用缓存的效果对比
在这里插入图片描述

缓存更新策略

缓存更新策略主要有以下三种

内存淘汰超时剔除主动更新
说明不用自己维护，利用redus的内存淘汰机制，当内存不足时自动淘汰部分数据，下次查询时更新缓存给缓存数据添加TTL时间，到期后自动删除缓存。下次查询时更新缓存。编写业务逻辑，在修改数据库的同时，更新缓存。
一致性差一般好
维护成本无低高

业务场景：

  • 低一致性需求:使用内存淘汰机制。例如店铺类型的查询缓存
  • 高一致性需求:主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

主动更新策略

Cache Aside Pattern
由缓存的调用者，在更新数据库的同时更新缓存。

Read/Write Through Pattern
缓存与数据库整合为一个服务由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题。

Write Behind Caching Pattern
调用者只操作缓存，由其它线程异步的将缓存数据持久化到数据库，保证最终一致。

操作缓存和数据库时有三个问题需要考虑
1，删除缓存还是更新缓存?

  • 更新缓存:每次更新数据库都更新缓存，无效写操作较多
  • 删除缓存:更新数据库时让缓存失效，查询时再更新缓存

2.如何保证缓存与数据库的操作的同时成功或失败?

  • 单体系统，将缓存与数据库操作放在一个事务
  • 分布式系统，利用TCC等分布式事务方案

先操作缓存还是先操作数据库?

  • 先删除缓存，再操作数据库
  • 先操作数据库，再删除缓存

缓存更新策略的最佳实践方案
1.低一致性需求:使用Redis自带的内存淘汰机制
2.高一致性需求:主动更新，并以超时剔除作为兜底方案

  • 读操作:

    • 缓存命中则直接返回
    • 缓存未命中则查询数据库，并写入缓存，设定超时时间

  • 写操作:

    • 先写数据库，然后再删除缓存
    • 要确保数据库与缓存操作的原子性

案例
给查询商铺的缓存添加超时剔除和主动更新的策略

修改ShopController中的业务逻辑，满足下面的需求:

① 根据id查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间

public Result getShopById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if(!StringUtil.isNullOrEmpty(shopJson)){
            //3.存在 返回商铺信息
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //判断命中的是否是空值
        if(shopJson != null){
            return Result.fail("店铺不存在2");
        }
        //4.不存在根据id在数据库中查询商铺信息
        Shop shop = getById(id);
        //5.不存在 返回错误信息
        if (shop == null) {
            return Result.fail("店铺不存在1");
        }
        //6.存在 将商铺信息写入redis中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7.将商铺信息返回
        return Result.ok(shop);
    }

② 根据id修改店铺时，先修改数据库，再删除缓存.

@Transactional
    public Result update(Shop shop) {
        Long id = shop.getId();
        if(id == null){
            return Result.fail("店铺Id不能为空");
        }
        //1.更新数据库
        updateById(shop);
        //2.删除缓存
        stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
        return Result.ok();
    }

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库。

常见的解决方案有两种:

缓存空对象

  • 优点:实现简单，维护方便
  • 缺点:
    • 额外的内存消耗
    • 可能造成短期的不一致

实现流程图
在这里插入图片描述
布隆过滤

  • 优点:内存占用较少，没有多余key
  • 缺点:
    • 实现复杂
    • 存在误判可能

实现流程图
在这里插入图片描述
这里采用 缓存空对象进行实践
流程图
在这里插入图片描述
代码

public Result getShopById(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if(!StringUtil.isNullOrEmpty(shopJson)){
            //3.存在 返回商铺信息
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //判断命中的是否是空值
        if(shopJson != null){
            return Result.fail("店铺不存在2");
        }
        //4.不存在根据id在数据库中查询商铺信息
        Shop shop = getById(id);
        //5.不存在 返回错误信息
        if (shop == null) {
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("店铺不存在1");
        }
        //6.存在 将商铺信息写入redis中
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7.将商铺信息返回
        return Result.ok(shop);
    }

总结
缓存穿透产生的原因是什么?

  • 用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求，给数据库带来巨大压力

缓存穿透的解决方案有哪些?

  • 缓存null值
  • 布隆过滤
  • 增强id的复杂度，避免被猜测id规律
  • 做好数据的基础格式校验
  • 加强用户权限校验
  • 做好热点参数的限流

缓存雪崩

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，:带来巨大压力。
解决方案：

  • 给不同的Key的TTL添加随机值
  • 利用Redis集群提高服务的可用性
  • 给缓存业务添加降级限流策略
  • 给业务添加多级缓存

在这里插入图片描述

缓存击穿

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

常见的解决方案有两种：

  • 互斥锁
  • 逻辑过期
    在这里插入图片描述

基于互斥锁方式解决缓存击穿问题

业务流程
在这里插入图片描述
代码：

    /**
     * 缓存击穿
     *
     * @param id
     * @return
     */
    public Shop queryWithMutex(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if (!StringUtil.isNullOrEmpty(shopJson)) {
            //3.存在 返回商铺信息
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return shop;
        }
        //判断命中的是否是空值
        if (shopJson != null) {
            return null;
        }
        //4.实现缓存重建
        String lockKey = LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
            //4.1获取互斥锁
            boolean isLock = tryLock(lockKey);
            //4.2判断是否成功
            if (!isLock) {
                //4.3失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            //4.4 再次检查缓存是否存在
            String shopJson2 = stringRedisTemplate.opsForValue().get(key);
            if (!StringUtil.isNullOrEmpty(shopJson2)) {
                //4.5 存在 返回商铺信息
                shop = JSONUtil.toBean(shopJson2, Shop.class);
                return shop;
            }
            //查缓存不存在
            //4.6成功根据id在数据库中查询商铺信息
            shop = getById(id);
            //模拟重建延时
            Thread.sleep(200);
            //5.不存在 返回错误信息
            if (shop == null) {
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //6.存在 将商铺信息写入redis中
            stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //7.释放互斥锁
            unLock(lockKey);
        }
        //8.返回
        return shop;
    }
 /**
     * 获取锁
     *
     * @param key
     * @return
     */
    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放锁
     *
     * @param key
     * @return
     */
    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }

基于逻辑过期方式解决缓存穿透问题
业务流程
在这里插入图片描述
代码：


 /**
     * 创建线程池
     */
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    /**
     * 逻辑过期
     *
     * @param id
     * @return
     */
    public Shop queryWithLogicalExpire(Long id) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if (StringUtil.isNullOrEmpty(shopJson)) {
            //3.不存在 直接返回
            return null;
        }
        //4.命中，需要先把json反序列化成对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject data = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5.判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())) {
            //5.1未过期，直接返回店铺信息
            return shop;
        }
        //5.2已过期
        //6.缓存重建
        String lockKye = LOCK_SHOP_KEY + id;
        //6.1获取互斥锁
        //6.2判断是否获取锁成功
        boolean isLock = tryLock(lockKye);
        if (isLock) {
            //6.3成功开启，独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 重建缓存
                    this.saveShop2Redis(id, 20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKye);
                }

            });
        }
        //6.4返回过期店铺信息
        return shop;
    }

封装缓存工具类

基于StringRedisTemplate封装一个缓存工具类，满足下列需求:
方法1:将任意Java对象序列化为ison并存储在string类型的key中，并且可以设置TTL过期时间
方法2:将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
方法3:根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4:根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

package com.hmdp.utils;

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.Shop;
import io.netty.util.internal.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.*;

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate){
        this.stringRedisTemplate = stringRedisTemplate;
    }


    /**
     * 方法1:将任意Java对象序列化为ison并存储在string类型的key中，并且可以设置TTL过期时间
     * 方法2:将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
     * 方法3:根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
     * 方法4:根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
     */

    public void set(String key , Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

    public void setWithLogicalExpire(String key , Object value, Long time, TimeUnit unit){
        //设置逻辑过期
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));

        //写入redis
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * 缓存穿透
     *
     * @param id
     * @return
     */
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        //1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if (!StringUtil.isNullOrEmpty(json)) {
            //3.存在 返回商铺信息
            R r = JSONUtil.toBean(json,type);
            return r;
        }
        //判断命中的是否是空值
        if (json != null) {
            return null;
        }
        //4.不存在根据id在数据库中查询商铺信息
        R r = dbFallback.apply(id);
        //5.不存在 返回错误信息
        if (r == null) {
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        //6.存在 将商铺信息写入redis中  调用方法1
        this.set(key,r,time,unit);

        return r;
    }

    /**
     * 创建线程池
     */
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    /**
     * 逻辑过期
     *
     * @param id
     * @return
     */
    public <R,ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit unit) {
        String key = CACHE_SHOP_KEY + id;
        //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        //2.是否存在
        if (StringUtil.isNullOrEmpty(shopJson)) {
            //3.不存在 直接返回
            return null;
        }
        //4.命中，需要先把json反序列化成对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject data = (JSONObject) redisData.getData();
        R r = JSONUtil.toBean(data, type);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5.判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())) {
            //5.1未过期，直接返回店铺信息
            return r;
        }
        //5.2已过期
        //6.缓存重建
        String lockKye = LOCK_SHOP_KEY + id;
        //6.1获取互斥锁
        //6.2判断是否获取锁成功
        boolean isLock = tryLock(lockKye);
        if (isLock) {
            //6.3成功开启，独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //查询数据库
                    R r1 = dbFallback.apply(id);
                    //写入redis
                    setWithLogicalExpire(key,r1,time,unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKye);
                }

            });
        }
        //6.4返回过期店铺信息
        return r;
    }

    /**
     * 获取锁
     *
     * @param key
     * @return
     */
    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 释放锁
     *
     * @param key
     * @return
     */
    private void unLock(String key) {
        stringRedisTemplate.delete(key);
    }
}

项目源码

https://toscode.gitee.com/wanghuaiyu666/hm-dianping

欢迎大家到我的仓库下载项目源码

格兰芬多的男孩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马redis小作业：给店铺类型查询业务添加缓存
ZZDT099的博客
02-17 309
黑马redis小作业：给店铺类型查询业务添加缓存
redis-windows-7.2.5.zip
05-20
在Windows环境下安装Redis，可以借助于提供的压缩包"redis-windows-7.2.5.zip"进行。以下是关于Redis及其在Windows上的安装和使用的详细知识： 1. **Redis特性** - **键值对存储**：Redis的核心是键值对模型，其中...
【黑马点评】给店铺类型查询业务添加缓存【业务实现】
qq_45721579的博客
06-18 1159
【黑马点评】给店铺类型查询业务添加缓存【业务实现】
RedisTemplate常用方法总结
热门推荐
feeling good
04-10 10万+
很多公司都将redisTemplate进行了封装，封装成业务所需要的RedisUtil工具类方便进行调用，本篇文章总结了redisTemplate常用的一些工具类。 Redis最为常用的数据类型： String Hash List Set zSet Sorted set String ...
redis实现缓存查询（商铺信息缓存为例）
weixin_46674772的博客
07-11 1194
缓存就是数据交换的缓冲区，是存贮数据的临时地方，一般读写性能较高。
黑马redis实战篇-商铺缓存
温涛的博客
04-25 913
黑马redis实战篇-商铺缓存笔记，包含有jmeter下载
Redis项目实战--商户查询缓存
wjf83902的博客
05-13 729
1、解决缓存空对象的缺点的方式：每次新增数据时，主动的将数据插入到redis缓存中，覆盖之前的null。2、布隆过滤器中存放的是一个个字节，并非真正的数据。1、判断String类型是否为空：StrUtil.isNotBlank(shopJson)。当shopJson为null、""、" "是均返回false。1、需求：修改根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题2、注意：这里的互斥锁不是我们平常用的synolize锁或者lock锁：这种锁，我们拿到了可以执行代码，没有拿到则继续等待。
redis-实战篇（2）商户查询缓存
weixin_52661752的博客
06-17 1142
前言什么是缓存?就像自行车,越野车的避震器举个例子:越野车,山地自行车,都拥有"避震器",防止车体加速后因惯性,在酷似"U"字母的地形上飞跃,硬着陆导致的损害,像个弹簧一样;同样,实际开发中,系统也需要"避震器",防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪;这在实际开发中对企业讲,对产品口碑,用户评价都是致命的;所以企业非常重视缓存技术;缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据。
Redis项目实战——商户查询缓存
weixin_46838605的博客
08-29 877
部分热点key（被高并发访问且缓存重建业务较复杂的key）在缓存中失效或过期，如果第一次请求未命中，会去数据库查询并写入缓存，但若在此期间有大量同样的请求涌入，就会有大量请求涌到数据库要求查询，给数据库造成巨大压力。客户端请求的数据在缓存和数据库中都没有，无法建立缓存，如果多次请求这个不存在的数据，这些请求就会全部打到数据库，给数据库造成压力。大量redis缓存中的key同时失效或过期，或者redis服务器宕机，大量请求直接到达数据库，给数据库造成巨大压力。宕机一个redis还有其他redis。
Redis学习笔记【实战篇--商户查询缓存】
qq_42192253的博客
05-31 1026
前言什么是缓存?举个例子:越野车,山地自行车,都拥有"避震器",防止车体加速后因惯性,在酷似"U"字母的地形上飞跃,硬着陆导致的损害,像个弹簧一样;同样,实际开发中,系统也需要"避震器",防止过高的数据访问猛冲系统,导致其操作线程无法及时处理信息而瘫痪;这在实际开发中对企业讲,对产品口碑,用户评价都是致命的;所以企业非常重视缓存技术;缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据。
redis分布式缓存实战-redis事务
02-24
　redis事务没有隔离级别的概念：队列中的命令没有提交之前都不会实际的被执行，因为事务提交前任何指令都不会被实际执行，也就不存在“事务内的查询看到事务里的更新，在事务外查询不能看到”。　redis事务不保证...
redis校验工具redis-full-check
05-27
**Redis 全面检查工具：redis-full-check** Redis 是一款高性能的键值存储系统，广泛应用于缓存、数据库和消息中间件等场景。在实际应用中，为了确保 Redis 的稳定性和数据一致性，需要定期对 Redis 实例进行健康...
redis++使用说明,windows下编译redis-plus-plus
06-13
"Redis++使用说明，windows下编译Redis-Plus-Plus" 在这篇文章中，我们将详细介绍如何在Windows平台下编译Redis++，包括编译hiredis.lib和Win32_Interop.lib静态库文件的过程，然后安装Cmake并编译Redis++，最后...
Another-Redis-Desktop-Manager.1.6.1
09-23
《Redis桌面管理器Another-Redis-Desktop-Manager详解》 Redis，全称为Remote Dictionary Server，是一种高性能的键值存储系统，常被用作数据库、缓存和消息中间件。其简洁的数据结构和丰富的数据类型使其在分布式...
SpringBoot依赖之Spring Data Redis一有序集合Sorted Set
ahauedu的专栏
08-19 1000
​ 通过上述步骤，我们成功在 Spring Boot 项目中使用 Spring Data Redis 实现了对 Redis 有序集合（Sorted Set）类型的操作。您可以使用这些方法来处理排行榜、定时任务和延时队列的数据结构需求。​ 这是基本的有序集合Sorted Set相关操作，还是要结合具体的业务选择具体的存储类型，这样对于项目后期的迭代具有事半功倍的效果。所以项目前期的技术选型也很重要，不容忽视。可以关注我一起学习，一起为程序员职业生涯蓄能。
【Redis】Redis数据结构——Hash 哈希
最新发布
zxj20041003的博客
08-23 407
⼏乎所有的主流编程语⾔都提供了哈希（hash）类型，它们的叫法可能是哈希、字典、关联数组、映射。在 Redis 中，哈希类型是指值本⾝⼜是⼀个键值对结构，形如 key = “key”，value = { {field1, value1 }, …, {fieldN, valueN } }，Redis 键值对和哈希类型⼆者的关系可以⽤图 2-15 来表⽰。
【Redis】集合类型详解及实际应用场景分析：从命令操作到内部编码
Hsusan的博客
08-20 440
如果 set1 和 set2 中都有一个 1，此时让 set1 的 1 移动到 set2 中，最终返回值是 1，即移动成功，set1 的 1 不见了，set2 的 1 也还在。注意，由于 set 内的元素是⽆序的，所以取出哪个元素实际是未定义⾏为，即随机删除，这里是真随机，而不是伪随机。这里的无序，是指变换一下元素的顺序，集合还是一样的集合，而不是说顺序逆序的无序。获取⼀个 set 的基数（cardinality），即 set 中的元素个数。获取⼀个 set 中的所有元素，注意，元素间的顺序是⽆序的。
Redis7基础篇（四）
m0_73476251的博客
08-19 276
redis管道
Redis实战：Key-Value存储系统详解
"Redis实战电子书，这是一本关于Redis的初稿，旨在介绍这个流行的Key-value存储系统，包括其NoSQL特性和多种数据类型的操作。书中提供了Redis的快速入门指南，涵盖了安装、配置和基本操作，以及适用于不同场景的应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值