Redis知识-实战篇(6)

最新推荐文章于 2023-12-14 10:09:59 发布
最新推荐文章于 2023-12-14 10:09:59 发布
阅读量553 收藏 2
点赞数
分类专栏： NoSQL 文章标签： redis 数据库 java 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52781902/article/details/126996194
版权

详细代码在我的Github上，地址：
https://github.com/CodeTeng/RedisCase
感兴趣的朋友可以去我的语雀平台进行查看更多的知识。
https://www.yuque.com/ambition-bcpii/muziteng

6. 秒杀优化

6.1 异步秒杀思路

首先回顾下下单流程

当用户发起请求，此时会请求nginx，nginx会访问到tomcat，而tomcat中的程序，会进行串行操作，分成如下几个步骤

  1. 查询优惠卷
  2. 判断秒杀库存是否足够
  3. 查询订单
  4. 校验是否是一人一单
  5. 扣减库存
  6. 创建订单

image-20220921210521896

在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行， 这样就会导致我们的程序执行的很慢，所以我们需

要异步程序执行，那么如何加速呢？

在这里笔者想给大家分享一下课程内没有的思路，看看有没有小伙伴这么想，比如，我们可以不可以使用异步编排来做，或者说我开启N多线程，N多个线程，一个线程执行查询优惠卷，一个执行判断扣减库存，一个去创建订单等等，然后再统一做返回，这种做法和课程中有哪种好呢？答案是课程中的好，因为如果你采用我刚说的方式，如果访问的人很多，那么线程池中的线程可能一下子就被消耗完了，而且你使用上述方案，最大的特点在于，你觉得时效性会非常重要，但是你想想是吗？并不是，比如我只要确定他能做这件事，然后我后边慢慢做就可以了，我并不需要他一口气做完这件事，所以我们应当采用的是课程中，类似消息队列的方式来完成我们的需求，而不是使用线程池或者是异步编排的方式来完成这个需求。

优化方案：我们将耗时比较短的逻辑判断放入到redis中，比如是否库存足够，比如是否一人一单，这样的操作，只要这种逻辑可以完

成，就意味着我们是一定可以下单完成的，我们只需要进行快速的逻辑判断，根本就不用等下单逻辑走完，我们直接给用户返回成功，

再在后台开一个线程，后台线程慢慢的去执行queue里边的消息即可

image-20220921220102000

整体思路：当用户下单之后，判断库存是否充足只需要导redis中去根据key找对应的value是否大于0即可，如果不充足，则直接结束，如

果充足，继续在redis中判断用户是否可以下单，如果set集合中没有这条数据，说明他可以下单，如果set集合中没有这条记录，则将

userId和优惠卷存入到redis中，并且返回0，整个过程需要保证是原子性的，我们可以使用lua来操作。

image-20220921220402350

6.2 Redis完成秒杀资格判断

需求：

  • 新增秒杀优惠券的同时，将优惠券信息保存到Redis中

  • 基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功

  • 如果抢购成功，将优惠券id和用户id封装后存入阻塞队列

  • 开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

image-20220921220546421

Lua脚本

-- 1. 参数列表
-- 1.1 优惠卷id
local voucherId = ARGV[1]
-- 1.2 用户id
local userId = ARGV[2]

-- 2. 数据key
-- 2.1 库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2 订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3. 脚本业务
-- 3.1 判断库存是否充足
if (tonumber(redis.call('GET', stockKey)) <= 0) then
    -- 3.2 库存不足 返回1
    return 1
end
-- 3.2 判断用户是否下单
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3 存在 重复下单 返回2
    return 2
end
-- 3.4 扣库存
redis.call('incrby', stockKey, -1)
-- 3.5 下单（保存用户）
redis.call('sadd', orderKey, userId)
-- 成功 返回0
return 0

新增秒杀优惠卷改造：

@Transactional(rollbackFor = Exception.class)
public void addSeckillVoucher(Voucher voucher) {
    // 添加优惠卷
    this.save(voucher);
    // 添加秒杀信息
    SeckillVoucher seckillVoucher = new SeckillVoucher();
    seckillVoucher.setVoucherId(voucher.getId());
    seckillVoucher.setStock(voucher.getStock());
    seckillVoucher.setBeginTime(voucher.getBeginTime());
    seckillVoucher.setEndTime(voucher.getEndTime());
    seckillVoucherMapper.insert(seckillVoucher);
    // 保存秒杀库存到redis中
    stringRedisTemplate.opsForValue().set(RedisConstants.SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
}

核心代码：

@Override
public Result seckillVoucher(Long voucherId) {
    //获取用户
    Long userId = UserHolder.getUser().getId();
    long orderId = redisIdWorker.nextId("order");
    // 1.执行lua脚本
    Long result = stringRedisTemplate.execute(
            SECKILL_SCRIPT,
            Collections.emptyList(),
            voucherId.toString(), userId.toString(), String.valueOf(orderId)
    );
    int r = result.intValue();
    // 2.判断结果是否为0
    if (r != 0) {
        // 2.1.不为0 ，代表没有购买资格
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
    }
    //TODO 保存阻塞队列
    // 3.返回订单id
    return Result.ok(orderId);
}

6.3 基于阻塞队列实现秒杀优化

修改下单动作，现在我们去下单时，是通过lua表达式去原子执行判断逻辑，如果判断我出来不为0 ，则要么是库存不足，要么是重复下

单，返回错误信息，如果是0，则把下单的逻辑保存到队列中去，然后异步执行。

核心代码：

@Autowired
private ISeckillVoucherService seckillVoucherService;

@Autowired
private RedisIdWorker redisIdWorker;

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Autowired
private RedissonClient redissonClient;

private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

static {
    SECKILL_SCRIPT = new DefaultRedisScript<>();
    SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
    SECKILL_SCRIPT.setResultType(Long.class);
}

private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024 * 1024);

private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}

private class VoucherOrderHandler implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                // 1. 获取队列中的订单信息
                VoucherOrder voucherOrder = orderTasks.take();
                // 2. 创建订单
                handleVoucherOrder(voucherOrder);
            } catch (Exception e) {
                log.error("处理订单异常", e);
            }
        }
    }
}

private void handleVoucherOrder(VoucherOrder voucherOrder) {
    // 1. 获取用户
    Long userId = voucherOrder.getUserId();
    // 2. 创建锁对象
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    // 3. 获取锁
    boolean isLock = lock.tryLock();
    // 4. 判断是否获取锁成功
    if (!isLock) {
        // 获取锁失败 返回错误或重试
        log.error("不允许重复下单");
    }
    try {
        proxy.createVoucherOrder(voucherOrder);
    } finally {
        // 释放锁
        lock.unlock();
    }
}

private IVoucherOrderService proxy;

@Override
public Result seckillVoucher(Long voucherId) {
    // 1. 执行Lua脚本
    Long userId = UserHolder.getUser().getId();
    Long result = stringRedisTemplate.execute(SECKILL_SCRIPT, Collections.emptyList(), voucherId.toString(), userId.toString());
    // 2. 判断结果是否为0
    int r = result.intValue();
    if (r != 0) {
        // 2.1 不为0 代表没有购买资格
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
    }
    // 2.2 为0 有购买资格 把下单信息(用户id,订单id,优惠卷id)存入阻塞队列
    long orderId = redisIdWorker.nextId("order");
    VoucherOrder voucherOrder = new VoucherOrder();
    // 2.3 订单id
    voucherOrder.setId(orderId);
    // 2.4 用户id
    voucherOrder.setUserId(userId);
    // 2.5 代金券id
    voucherOrder.setVoucherId(voucherId);
    // 2.6 保存阻塞队列
    orderTasks.add(voucherOrder);

    // 3. 获取代理对象
    proxy = (IVoucherOrderService) AopContext.currentProxy();
    // 4. 返回订单id
    return Result.ok(orderId);
}


@Override
@Transactional(rollbackFor = Exception.class)
public void createVoucherOrder(VoucherOrder voucherOrder) {
    // 5. 实现一人一单
    Long userId = voucherOrder.getUserId();
    Long voucherId = voucherOrder.getVoucherId();
    // 5.1 查询订单
    Long count = this.query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    // 5.2 判断是否存在
    if (count > 0) {
        // 用户已经购买过
        log.error("不可再次抢购！");
    }
    // 6. 扣减库存
    boolean isSuccess = seckillVoucherService.update().setSql("stock = stock - 1").eq("voucher_id", voucherId).gt("stock", 0).update();
    if (!isSuccess) {
        log.error("库存不足！");
    }
    // 7 保存订单
    this.save(voucherOrder);
}

小总结：

秒杀业务的优化思路是什么？

  • 先利用Redis完成库存余量、一人一单判断，完成抢单业务
  • 再将下单业务放入阻塞队列，利用独立线程异步下单
  • 基于阻塞队列的异步秒杀存在哪些问题？
    • 内存限制问题
    • 数据安全问题

7. Redis消息队列

7.1 认识消息队列

什么是消息队列：字面意思就是存放消息的队列。最简单的消息队列模型包括3个角色：

  • 消息队列：存储和管理消息，也被称为消息代理（Message Broker）
  • 生产者：发送消息到消息队列
  • 消费者：从消息队列获取消息并处理消息

image-20220921231953931

使用队列的好处在于**解耦：**所谓解耦，举一个生活中的例子就是：快递员(生产者)把快递放到快递柜里边(Message Queue)去，我们(消费

者)从快递柜里边去拿东西，这就是一个异步，如果耦合，那么这个快递员相当于直接把快递交给你，这事固然好，但是万一你不在家，

那么快递员就会一直等你，这就浪费了快递员的时间，所以这种思想在我们日常开发中，是非常有必要的。

这种场景在我们秒杀中就变成了：我们下单之后，利用redis去进行校验下单条件，再通过队列把消息发送出去，然后再启动一个线程去

消费这个消息，完成解耦，同时也加快我们的响应速度。

这里我们可以使用一些现成的mq，比如kafka，rabbitmq等等，但是呢，如果没有安装mq，我们也可以直接使用redis提供的mq方案。

Redis提供了三种不同的方式来实现消息队列：

  • list结构：基于List结构模拟消息队列

  • PubSub：基本的点对点消息模型

  • Stream：比较完善的消息队列模型

7.2 基于List实现消息队列

消息队列（Message Queue），字面意思就是存放消息的队列。而Redis的list数据结构是一个双向链表，很容易模拟出队列效果。

队列是入口和出口不在一边，因此我们可以利用：LPUSH结合RPOP、或者RPUSH结合LPOP来实现。

不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用

BRPOP或者BLPOP来实现阻塞效果。

image-20220921232350888

基于List的消息队列有哪些优缺点？

优点：

  • 利用Redis存储，不受限于JVM内存上限
  • 基于Redis的持久化机制，数据安全性有保证
  • 可以满足消息有序性

缺点：

  • 无法避免消息丢失
  • 只支持单消费者

7.3 基于PubSub的消息队列

PubSub（发布订阅）是Redis2.0版本引入的消息传递模型。顾名思义，消费者可以订阅一个或多个channel，生产者向对应channel发送

消息后，所有订阅者都能收到相关消息。

SUBSCRIBE channel [channel] ：订阅一个或多个频道

PUBLISH channel msg ：向一个频道发送消息

PSUBSCRIBE pattern[pattern] ：订阅与pattern格式匹配的所有频道

image-20220922153917549

基于PubSub的消息队列有哪些优缺点？

优点：

  • 采用发布订阅模型，支持多生产、多消费

缺点：

  • 不支持数据持久化
  • 无法避免消息丢失
  • 消息堆积有上限，超出时数据丢失

7.4 基于Stream的消息队列

Stream 是 Redis 5.0 引入的一种新数据类型，可以实现一个功能非常完善的消息队列。

发送消息的命令：

image-20220922160031352

例如：

image-20220922160043863

读取消息的方式之一：XREAD

image-20220922160058253

在业务开发中，我们可以循环的调用XREAD阻塞方式来查询最新消息，从而实现持续监听队列的效果，伪代码如下

image-20220922160129983

注意：当我们指定起始ID为$时，代表读取最新的消息，如果我们处理一条消息的过程中，又有超过1条以上的消息到达队列，则下次获取

时也只能获取到最新的一条，会出现漏读消息的问题。

STREAM类型消息队列的XREAD命令特点：

  • 消息可回溯
  • 一个消息可以被多个消费者读取
  • 可以阻塞读取
  • 有消息漏读的风险

7.5 基于Stream的消息队列-消费者组

消费者组（Consumer Group）：将多个消费者划分到一个组中，监听同一个队列。具备下列特点：

image-20220922162443373

创建消费者组

XGROUP CREATE key groupName ID [MKSTREAM]

key：队列名称

groupName：消费者组名称

ID：起始ID标示，$代表队列中最后一个消息，0则代表队列中第一个消息

MKSTREAM：队列不存在时自动创建队列

删除指定的消费者组

XGROUP DESTORY key groupName

给指定的消费者组添加消费者

XGROUP CREATECONSUMER key groupname consumername

删除消费者组中的指定消费者

XGROUP DELCONSUMER key groupname consumername

从消费者组读取消息：

XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] ID [ID ...]
  • group：消费者组名称
  • consumer：消费者名称，如果消费者不存在，会自动创建一个消费者
  • count：本次查询的最大数量
  • BLOCK milliseconds：当没有消息时最长等待时间
  • NOACK：无需手动ACK，获取到消息后自动确认，一般不设置
  • STREAMS key：指定队列名称
  • ID：获取消息的起始ID
    • “>”：从下一个未消费的消息开始
    • 其它：根据指定id从pending-list中获取已消费但未确认的消息，例如0，是从pending-list中的第一个消息开始

消费者监听消息的基本思路：

image-20220922163036065

STREAM类型消息队列的XREADGROUP命令特点：

  • 消息可回溯

  • 可以多消费者争抢消息，加快消费速度

  • 可以阻塞读取

  • 没有消息漏读的风险

  • 有消息确认机制，保证消息至少被消费一次

小总结

image-20220922163144391

7.6 基于Redis的Stream结构作为消息队列，实现异步秒杀下单

需求：

  • 创建一个Stream类型的消息队列，名为stream.orders
  • 修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherId、userId、orderId
  • 项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单

修改lua表达式

-- 1. 参数列表
-- 1.1 优惠卷id
local voucherId = ARGV[1]
-- 1.2 用户id
local userId = ARGV[2]
-- 1.3 订单id
local orderId = ARGV[3]

-- 2. 数据key
-- 2.1 库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2 订单key
local orderKey = 'seckill:order:' .. voucherId

-- 3. 脚本业务
-- 3.1 判断库存是否充足
if (tonumber(redis.call('GET', stockKey)) <= 0) then
    -- 3.2 库存不足 返回1
    return 1
end
-- 3.2 判断用户是否下单
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3 存在 重复下单 返回2
    return 2
end
-- 3.4 扣库存
redis.call('incrby', stockKey, -1)
-- 3.5 下单（保存用户）
redis.call('sadd', orderKey, userId)
-- 3.6 发送消息到队列中，XADD stream.orders * k1 v1 k2 v2
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
-- 成功 返回0
return 0

核心代码：

private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

static {
    SECKILL_SCRIPT = new DefaultRedisScript<>();
    SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
    SECKILL_SCRIPT.setResultType(Long.class);
}

private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}

private void handleVoucherOrder(VoucherOrder voucherOrder) {
    // 1. 获取用户
    Long userId = voucherOrder.getUserId();
    // 2. 创建锁对象
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    // 3. 获取锁
    boolean isLock = lock.tryLock();
    // 4. 判断是否获取锁成功
    if (!isLock) {
        // 获取锁失败 返回错误或重试
        log.error("不允许重复下单");
    }
    try {
        proxy.createVoucherOrder(voucherOrder);
    } finally {
        // 释放锁
        lock.unlock();
    }
}

private IVoucherOrderService proxy;

private class VoucherOrderHandler implements Runnable {
    String queueName = "stream.orders";

    @Override
    public void run() {
        while (true) {
            try {
                // 1. 获取消息队列中的订单信息 xreadgroup group g1 c1 count 1 block 2000 streams stream.orders >
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                    StreamOffset.create(queueName, ReadOffset.lastConsumed())
                );
                // 2. 判断消息获取是否成功
                if (list == null || list.isEmpty()) {
                    // 2.1 获取失败，说明没有消息，继续下一次循环
                    continue;
                }
                // 3. 解析消息中的订单信息
                MapRecord<String, Object, Object> record = list.get(0);
                Map<Object, Object> values = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
                // 4. 获取成功 可以下单 创建订单
                handleVoucherOrder(voucherOrder);
                // 5. ACK确认 xack stream.orders g1 id
                stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
            } catch (Exception e) {
                log.error("处理订单异常", e);
                handlePendingList();
            }
        }
    }

    private void handlePendingList() {
        while (true) {
            try {
                // 1. 获取pending-list中的订单信息 xreadgroup group g1 c1 count 1 block 2000 streams stream.orders 0
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1),
                    StreamOffset.create(queueName, ReadOffset.from("0"))
                );
                // 2. 判断消息获取是否成功
                if (list == null || list.isEmpty()) {
                    // 2.1 获取失败，说明pending-list没有异常消息，结束循环
                    break;
                }
                // 3. 解析消息中的订单信息
                MapRecord<String, Object, Object> record = list.get(0);
                Map<Object, Object> values = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
                // 4. 获取成功 可以下单 创建订单
                handleVoucherOrder(voucherOrder);
                // 5. ACK确认 xack stream.orders g1 id
                stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
            } catch (Exception e) {
                log.error("处理pending-list订单异常", e);
            }
        }
    }
}

/**
 * 利用redis消息队列实现
 *
 * @param voucherId 优惠卷id
 */
@Override
public Result seckillVoucher(Long voucherId) {
    // 1. 执行Lua脚本
    Long userId = UserHolder.getUser().getId();
    long orderId = redisIdWorker.nextId("order");
    Long result = stringRedisTemplate.execute(
        SECKILL_SCRIPT,
        Collections.emptyList(),
        voucherId.toString(), userId.toString(), String.valueOf(orderId)
    );
    // 2. 判断结果是否为0
    int r = result.intValue();
    if (r != 0) {
        // 2.1 不为0 代表没有购买资格
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
    }
    // 3. 获取代理对象
    proxy = (IVoucherOrderService) AopContext.currentProxy();
    // 4. 返回订单id
    return Result.ok(orderId);
}

Ambition0823
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RedisTemplate常用集合使用说明-opsForSet(五)
XinhuaShuDiao的博客
08-10 6191
     基础配置介绍已经在前面的《RedisTemplate常用集合使用说明(一)》中已经介绍了，现在我们直接介绍opsForSet()方法的使用：     1、add(K key, V... values)     向变量中批量添加值。   redisTemplate.opsForSet().add("setValue","A","B","C","B","D",&quot
Redis消息队列实现异步秒杀
qq_45813393的博客
11-09 1043
Redis消息队列实现异步秒杀
Redis应用之消息队列-Stream的使用
qq_42861526的博客
05-13 2471
一、概述 众所周知，redis这个强大的中间件经常被用作处理各种分布式的业务，比如分布式锁、消息队列等等，而redis用来处理消息队列的业务时应该使用哪种数据结构呢？ 在学习stream之前，我的第一反应是list，理由如下 list可以采用左进右出的方式保证消息处理的顺序性 list可以采取阻塞读取消息方式，不浪费cpu资源 list可以借助redis对消息进行持久化 综上所述，好像list的确可以作为一种简单的消息队列，但是它具备一种致命的缺陷：没有消息确认机制，容易导致消息丢失。此外，也没有消
黑马点评day05-Redis消息队列
weixin_54161951的博客
07-02 282
内存限制问题数据安全问题 List：双向链表 3、基于Redis的LPubSub结构消息队列（专门的发布订阅机制） PSUBSCRIBE：pattern Redis Stream 提供了消息的持久化和主备复制功能，可以让任何客户端访问任何时刻的数据，并且能记住每一个客户端的访问位置，还能保证消息不丢失。消息读完不会被删除 若block=0 则表示一直阻塞 消费者组方法： 消息确认： 查看指定组里的pendingList，可同时指定消费者 从pendin
RedisTemplate常用方法封装
点滴记录
04-22 1372
【代码】RedisTemplate常用方法封装。
Redis实战篇学习资料
最新发布
06-12
在这个“Redis实战篇学习资料”中，我们可能涵盖以下几个关键知识点： 1. **Redis基础概念**： - Redis的数据类型：包括字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set），...
Redis实战篇的后端代码
10-07
在本项目中，"Redis实战篇的后端代码"是一个以Redis为核心，使用Java语言实现的后端应用程序。Redis是一个高性能的键值数据库，常用于数据缓存、消息队列等场景，因其高效的读写速度和丰富的数据结构而受到开发者...
Redis--参考资料即总结
04-22
标题中的“Redis--参考资料即总结”暗示了这篇博文可能是一个关于Redis的综合教程或学习笔记，旨在帮助读者理解并掌握Redis的核心概念和使用技巧。博主sw1982在iteye博客上分享了他们的理解和实践，可能是基于个人...
Redis实战篇代码，包含前端资源
06-21
在本实战篇中，我们将会深入探讨Redis的使用，并结合前端资源进行实践。 首先，让我们关注Redis的基础知识。Redis支持的数据结构非常丰富，包括字符串(Strings)、哈希(Hashes)、列表(Lists)、集合(Sets)和有序集合...
Redis教程实战篇 点评项目，用于学习Redis实战，实战篇代码已完-hm-dianping.zip
01-30
首先，Redis的基础知识是必不可少的。Redis是一个开源的内存数据结构存储系统，它可以作为数据库、缓存和消息代理使用。其数据结构包括字符串、哈希、列表、集合、有序集合等，这些数据结构为解决各种问题提供了灵活...
Redis6.0系列(16)-RedisTemplate操作Redis之API详解
记录知识、锤炼自我
05-15 1405
StringRedisTemplate 由于存储在Redis中的键和值非常普遍java.lang.String，因此Redis模块提供了RedisConnection和的两个扩展RedisTemplate，分别是StringRedisConnection（及其DefaultStringRedisConnection实现），并且StringRedisTemplate是用于密集型String操作的便捷的一站式解决方案。除了绑定到String键之外，模板和连接还使用StringRedisSerializer下方，
RedisStream队列
彦楠的博客
09-15 447
spring-data-redis 实现RedisStream 队列读取发送 demo package com.game.redis.container.stream; import java.time.Duration; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.concurrent
Spring Boot 整合 Redis
zengshangchun的博客
07-30 391
新建分共项目，编写工具类，打包导入别的项目，方便别的项目调用 一，引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> <version>1.4.5.RELEASE</version> </dependency>
Redis笔记（二）
weixin_44821951的博客
02-05 89
​ 这篇笔记主要讲述在idea中开发时，如何在Java代码中使用Redis。
Redis队列原理解析：让你的应用程序运行更加稳定！
专注java二开部署
12-14 1191
消息队列（Message Queue），字面意思就是存放消息的队列。消息队列：存储和管理消息，也被称为消息代理（Message Broker）生产者：发送消息到消息队列消费者：从消息队列获取消息并处理消息消息队列和阻塞队列的区别：① 消息队列是在 JVM 以外的独立服务，所以不受 JVM 内存的限制② 消息队列不仅仅做数据存储，还需要确保数据安全，存入到消息队列中的所有消息都需要做持久化，这样不管是服务宕机还是重启，数据都不会丢失。
setnx是原子操作吗_Redis基本指令,操作及工具类
weixin_39925413的博客
11-26 1424
redis,远程字典服务,强大的后端必备技能.如何启动redis#redis ==>数据库,缓存,消息中间件#五种数据类型strings / hashs / lists / sets / sorted setsps -ef|grep redis #查看redis进程(在命令行下)#启动redis,首先要知道redis-server位置,还要知道redis.conf位置**使用 l...
利用redis做业务缓存和配置项
dipang1211的博客
01-05 168
利用redis做业务缓存和配置项 来自：https://github.com/018/RedisCache 背景 ​ 从以前的C/S应用到现在的B/S，系统配置项都是必不可少的。一般都有一个SettingUtils类，提供read和write方法，然后就一大堆作为Key的常量。通过这样来实现： String ip = SettingUtils.read(SettingConsts.IP)...
SpringBoot笔记（三）Redis
m0_51448653的博客
03-16 307
一个键值对除了存储一个String类型的值以外，还支持多种常用的数据类型。
排查【Jedis客户端触发 Too many open files 问题】
u012285269的博客
08-09 1245
没有即时关闭链接资源导致文件描述符泄漏问题
Redis入门全解析：从基础到实战，一文通透
本文旨在帮助读者全面理解Redis，从基础知识到高级特性的讲解十分详尽。 1. **Redis简介**： Redis是一个高性能的键值存储系统，它的设计目标是提供快速的数据存取速度，支持多种数据结构，包括字符串、列表、集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ambition0823

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值