【承】Redis 原理篇——关于 Redis 中的事务

最新推荐文章于 2022-06-20 20:29:28 发布
最新推荐文章于 2022-06-20 20:29:28 发布
阅读量282 收藏 2
点赞数
分类专栏： Redis Java 运维 文章标签： redis java nosql 面试 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42669785/article/details/107388729
版权
Java 同时被 3 个专栏收录
48 篇文章 1 订阅
订阅专栏
运维
27 篇文章 0 订阅
订阅专栏
Redis
18 篇文章 1 订阅
订阅专栏

前言

关于 Redis 的“起承转合”，我前面已经用五个篇章的长度作了一个 Redis 基础篇——“起”篇的详细阐述，相信大家无论之前有没有接触过 Redis，都能从中学到不少东西。基础篇的内容顾名思义，只是个基础，主要说了 Redis 的发展以及 Redis 的基本数据类型，内容跟平时使用关联会比较大，难度不算大，希望大家能好好消化。
这里送上基础篇的飞机票：
【起】Redis 概述篇——带你走过 Redis 的前世今生
【起】Redis 基础篇——基本数据结构之String，Hash
【起】Redis 基础篇——基本数据结构之 List，Set
【起】Redis 基础篇——基本数据结构之 ZSet，Bitmap…
【起】Redis 基础篇——基本数据结构之总结篇

在“承”篇中，我会围绕 Redis 的原理来阐述，讲一些相对比较高级的特性，比如本篇章要讲到的 pub/sub（发布/订阅）模式，持久化机制，高性能特性，事务，内存回收机制等等，在接下来的篇章中，我会为大家穿针引线，把每个篇章的内容都串起来，这里就先不占用大家的前言篇章。

那话归正题，我们今天来看一下关于 Redis 的发布/订阅模式。

正文

Redis 事务

先看官网
https://redis.io/topics/transactions/
http://redisdoc.com/topic/transaction.html

为什么要用事务

我们知道 Redis 的单个命令是原子性的（比如 get set mget mset），如果涉及到多个命令的时候，需要把多个命令作为一个不可分割的处理序列，就需要用到事务。

例如我们之前说的用 setnx实现分布式锁，我们先 set，然后设置对 key 设置 expire，防止 del 发生异常的时候锁不会被释放，业务处理完了以后再 del，这三个动作我们就希望它们作为一组命令执行。

Redis 的事务有两个特点：

  1. 按进入队列的顺序执行；

  2. 不会受到其他客户端的请求的影响；

Redis 的事务涉及到四个命令：multi（开启事务），exec（执行事务），discard（取消事务），watch（监视）

事务的用法

案例场景：tom 和 mic 各有 1000 元，tom 需要向 mic 转账 100 元。

tom 的账户余额减少 100 元，mic 的账户余额增加 100 元。

127.0.0.1:6379> set tom 1000
OK
127.0.0.1:6379> set mic 1000
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby tom 100
QUEUED
127.0.0.1:6379> incrby mic 100
QUEUED
127.0.0.1:6379> exec
1) (integer) 900
2) (integer) 1100
127.0.0.1:6379> get tom
"900"
127.0.0.1:6379> get mic
"1100"

通过 multi 的命令开启事务。事务不能嵌套，多个 multi 命令效果一样。

multi 执行后，客户端可以继续向服务器发送任意多条命令， 这些命令不会立即被执行， 而是被放到一个队列中， 当 exec 命令被调用时， 所有队列中的命令才会被执行。

通过 exec 的命令执行事务。如果没有执行 exec，所有的命令都不会被执行。如果中途不想执行事务了，怎么办？

可以调用 discard 可以清空事务队列，放弃执行。

multi
set k1 1
set k2 2
set k3 3
discard

watch 命令

在 Redis 中还提供了一个 watch 命令。

它可以为 Redis 事务提供 CAS 乐观锁行为（ Check and Set / Compare and Swap），也就是多个线程更新变量的时候，会跟原值做比较，只有它没有被其他线程修改的情况下，才更新成新的值。

我们可以用 watch 监视一个或者多个 key，如果开启事务之后，至少有一个被监视 key 键在 exec 执行之前被修改了， 那么整个事务都会被取消（key 提前过期除外）。可以用 unwatch 取消。

client 1client 2
127.0.0.1:6379> set balance 1000
OK
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incrby balance 100
QUEUED		-
-127.0.0.1:6379> decrby balance 100
(integer) 900
127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get balance
“900”		-

事务可能遇到的问题

我们把事务执行遇到的问题分成两种，一种是在执行 exec 之前发生错误，一种是在执行 exec 之后发生错误。

在执行 exec 之前发生错误

比如：入队的命令存在语法错误，包括参数数量，参数名等等（编译器错误）。

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set ck 666
QUEUED
127.0.0.1:6379> hset ck 2673
(error) ERR wrong number of arguments for 'hset' command
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors.

在这种情况下事务会被拒绝执行，也就是队列中所有的命令都不会得到执行。

在执行 exec 之后发生错误

比如，类型错误，比如对 String 使用了 Hash 的命令，这是一种运行时错误。

127.0.0.1:6379> flushall
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 1
QUEUED
127.0.0.1:6379> hset k1 a b
QUEUED
127.0.0.1:6379> exec
1) OK
2) (error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> get k1
"1"

最后我们发现 set k1 1的命令是成功的，也就是在这种发生了运行时异常的情况下，只有错误的命令没有被执行，但是其他命令没有受到影响。

这个显然不符合我们对原子性的定义，也就是我们没办法用 Redis 的这种事务机制来实现原子性，保证数据的一致。

思考：

  • 为什么在一个事务中存在错误，Redis 不回滚？

这个问题我们必须从 Redis 的设计开始说起，用过关系型数据库的朋友们应该会感到奇怪，为啥 Redis 不支持事务回滚？我们先看看，Redis 有没有必要支持回滚。
我们知道，Redis 的命令执行失败只有在语法错误的情况下（在将这个命令放入事务队列期间，Redis能够发现此类问题），这个问题一般不会发生在生产环境中。
而且事务回滚并不能解决任何程序错误。例如，如果某个查询会将一个键的值递增2，而不是1，或者递增错误的键，那么事务回滚机制是没有办法解决这些程序问题的。
另外就是，Redis已经在系统内部进行功能简化，这样可以确保更快的运行速度，因为Redis不需要事务回滚的能力。

Lua 脚本

Lua/ˈluə/是一种轻量级脚本语言，它是用 C 语言编写的，跟数据的存储过程有点类似。

使用 Lua 脚本来执行 Redis 命令的好处：

  1. 一次发送多个命令，减少网络开销。

  2. Redis 会将整个脚本作为一个整体执行，不会被其他请求打断，保持原子性。

  3. 对于复杂的组合命令，我们可以放在文件中，可以实现程序之间的命令集复用。

在 Redis 中调用 Lua 脚本

使用 eval /ɪ’væl/ 方法，语法格式：

redis> eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....]

  • eval 代表执行 Lua 语言的命令。

  • lua-script 代表 Lua 语言脚本内容。

  • key-num 表示参数中有多少个 key，需要注意的是 Redis 中 key 是从 1 开始的，如果没有 key 的参数，那么写 0。

  • [key1 key2 key3…]是 key 作为参数传递给 Lua 语言，也可以不填，但是需要和 key-num 的个数对应起来。

  • [value1 value2 value3 ….]这些参数传递给 Lua 语言，它们是可填可不填的。

示例，返回一个字符串，0 个参数：

redis> eval "return 'Hello World'" 0

在 Lua 脚本中调用 Redis 命令

使用 redis.call(command, key [param1, param2…])进行操作。语法格式：

redis> eval "redis.call('set',KEYS[1],ARGV[1])" 1 lua-key lua-value

  • command 是命令，包括 set、get、del 等。

  • key 是被操作的键。

  • param1,param2…代表给 key 的参数。

注意跟 Java 不一样，定义只有形参，调用只有实参。

Lua 是在调用时用 key 表示形参，argv 表示参数值（实参）。

设置键值对

在Redis 中调用 Lua 脚本执行 Redis 命令

redis> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 ck 2673 
redis> get ck

以上命令等价于 set ck 2673。

在 redis-cli 中直接写 Lua 脚本不够方便，也不能实现编辑和复用，通常我们会把脚本放在文件里面，然后执行这个文件。

在 Redis 中调用 Lua 脚本文件中的命令，操作 Redis

创建 Lua 脚本文件：

cd /usr/local/soft/redis5.0.5/src
vim ck.lua

Lua 脚本内容，先设置，再取值：

redis.call('set','ck','lua666')
return redis.call('get','ck')

在 Redis 客户端中调用 Lua 脚本

cd /usr/local/soft/redis5.0.5/src
redis-cli --eval ck.lua 0

得到返回值：

[root@localhost src]# redis-cli --eval ck.lua 0
"lua666"
案例：对 IP 进行限流

需求：在 X 秒内只能访问 Y 次。

设计思路：用 key 记录 IP，用 value 记录访问次数。

拿到 IP 以后，对 IP+1。
如果是第一次访问，对 key 设置过期时间（参数 1）。
否则判断次数，超过限定的次数（参数 2），返回 0。
如果没有超过次数则返回 1。
超过时间， key 过期之后，可以再次访问。

KEY[1]是 IP， ARGV[1]是过期时间 X，ARGV[2]是限制访问的次数 Y。

–ip_limit.lua

–IP 限流，对某个 IP 频率进行限制 ，6 秒钟访问 10 次

local num=redis.call('incr',KEYS[1])
if tonumber(num)==1 
	then redis.call('expire',KEYS[1],ARGV[1]) 
	return 1
elseif tonumber(num)>tonumber(ARGV[2]) 
	then return 0
else 
	return 1
end

6 秒钟内限制访问 10 次，调用测试（连续调用 10 次）：

./redis-cli --eval	"ip_limit.lua" app:ip:limit:192.168.8.111 , 6 10
  • app:ip:limit:192.168.8.111 是 key 值 ，后面是参数值，中间要加上一个空格 和一个逗号，再加上一个空格。

即：./redis-cli –eval [lua 脚本] [key…]空格,空格[args…]

  • 多个参数之间用一个 空格 分割 。

代码：LuaTest.java

缓存 Lua 脚本
  • 为什么要缓存

在脚本比较长的情况下，如果每次调用脚本都需要把整个脚本传给 Redis 服务端，会产生比较大的网络开销。为了解决这个问题，Redis 提供了 EVALSHA 命令，允许开发者通过脚本内容的 SHA1 摘要来执行脚本。

  • 如何缓存

Redis 在执行 script load 命令时会计算脚本的 SHA1 摘要并记录在脚本缓存中，执行 EVALSHA 命令时 Redis 会根据提供的摘要从脚本缓存中查找对应的脚本内容，如果找到了则执行脚本，否则会返回错误："NOSCRIPT No matching script. Please use EVAL."

127.0.0.1:6379> script load "return 'Hello World'"
"470877a599ac74fbfda41caa908de682c5fc7d4b"
127.0.0.1:6379> evalsha "470877a599ac74fbfda41caa908de682c5fc7d4b" 0 "Hello World"

自乘案例

Redis 有 incrby 这样的自增命令，但是没有自乘，比如乘以 3，乘以 5。

我们可以写一个自乘的运算，让它乘以后面的参数：

local curVal = redis.call("get", KEYS[1])
if curVal == false then
	curVal = 0
else
	curVal = tonumber(curVal)
end
	curVal = curVal * tonumber(ARGV[1])
	redis.call("set", KEYS[1], curVal)
	return curVal

把这个脚本变成单行，语句之间使用分号隔开

local curVal = redis.call("get", KEYS[1]); if curVal == false 	then curVal = 0 else 	curVal = tonumber(curVal) end; curVal=curVal *tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal

script load ‘命令’

127.0.0.1:6379> script load 'local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal * tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal'
"be4f93d8a5379e5e5b768a74e77c8a4eb0434441"

调用：

127.0.0.1:6379> set num 2
OK
127.0.0.1:6379> evalsha be4f93d8a5379e5e5b768a74e77c8a4eb0434441 1 num 6 
(integer) 12
脚本超时

Redis 的指令执行本身是单线程的，这个线程还要执行客户端的 Lua 脚本，如果 Lua 脚本执行超时或者陷入了死循环，是不是没有办法为客户端提供服务了呢？

eval 'while(true) do end' 0

为了防止某个脚本执行时间过长导致 Redis 无法提供服务， Redis 提供了 lua-time-limit 参数限制脚本的最长运行时间，默认为 5 秒钟。

lua-time-limit 5000（redis.conf 配置文件中）

当脚本运行时间超过这一限制后，Redis 将开始接受其他命令但不会执行（以确保脚本的原子性，因为此时脚本并没有被终止），而是会返回“BUSY”错误。

Redis 提供了一个 script kill 的命令来中止脚本的执行。新开一个客户端：

script kill

如果当前执行的 Lua 脚本对 Redis 的数据进行了修改（SET、DEL 等），那么通过 script kill 命令是不能终止脚本运行的。

127.0.0.1:6379> eval "redis.call('set','ck','666') while true do end" 0

因为要保证脚本运行的原子性，如果脚本执行了一部分终止，那就违背了脚本原子性的要求。最终要保证脚本要么都执行，要么都不执行。

127.0.0.1:6379> script kill
(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the script termination or kill the server in a hard way using the SHUTDOWN NOSAVE command.

遇到这种情况，只能通过 shutdown nosave 命令来强行终止 redis。

shutdown nosave 和 shutdown 的区别在于 shutdown nosave 不会进行持久化操作，意味着发生在上一次快照后的数据库修改都会丢失。

总结：如果我们有一些特殊的需求，可以用 Lua 来实现，但是要注意那些耗时的操作。

By the way

有问题？可以给我留言或私聊
有收获？那就顺手点个赞呗~

当然，也可以到我的公众号下「6曦轩」，

回复“学习”，即可领取一份
【Java工程师进阶架构师的视频教程】~

回复“面试”，可以获得：
【本人呕心沥血整理的 Java 面试题】

回复“MySQL脑图”，可以获得
【MySQL 知识点梳理高清脑图】

还有【阿里云】【腾讯云】的购买优惠噢~具体请联系我

曦轩我是科班出身的程序员，php，Android以及硬件方面都做过，不过最后还是选择专注于做 Java，所以有啥问题可以到公众号提问讨论（技术情感倾诉都可以哈哈哈），看到的话会尽快回复，希望可以跟大家共同学习进步，关于服务端架构，Java 核心知识解析，职业生涯，面试总结等文章会不定期坚持推送输出，欢迎大家关注~~~

在这里插入图片描述

6曦轩
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis——Redis Cluster集群原理
庄小焱
03-14 4553
摘要 我们平时习惯于使用 Rabbitmq 和 Kafka 作为消息队列中间件，来给应用程序之间增加异步消息传递功能。这两个中间件都是专业的消息队列中间件，特性之多超出了大多数人的理解能力。使用过 Rabbitmq 的同学知道它使用起来有多复杂，发消息之前要创建 Exchange，再创建 Queue，还要将 Queue 和 Exchange 通过某种规则绑定起来，发消息的时候要指定 routingkey，还要控制头部信息。消费者在消费消息之前也要进行上面一系列的繁琐过程。但是绝大多数情况下，虽然我们的消息
redis中的事务
weixin_30271335的博客
03-04 90
首先明白在java中线程和进程的区别： 1.什么是多线程？是指一个应用程序同时执行多个任务，一般来说一个任务就是一个线程 ，而一个应用程序有一个以上的线程我们称之为多线程。2.什么是进程？进程是一个正在执行的程序 ，比如QQ，迅雷等 一个进程的运行会向CPU申请在内存中开辟一个内存块。他是向CPU申请资源的，进程之间数据相互独立，一个进程至少有一个线程。3.什么是线程？线程...
redis的incr操作 + 设置时间 并保证原子性
weixin_38230961的博客
01-28 1万+
$key = 'foo_key'; $setTmout = 3600; $redis = new Redis(); $redis->connect('127.0.0.1', 6379); $ttl = $redis->ttl($key); $result = false; if ($ttl <= 0) { //开始事务，防止竞争，保证原子性 $redis...
redis 的incr 高并发 原子性计数器
红星小学扛把子！
07-10 2万+
前言：6月底 公司录单的人比较多，由于先前的系统用的同步锁 ，我们是多服务实例，导致出现重复单号的问题，我想到的解决办法有两种 ，第一种是 Redis锁 第二种是自增key，下面实现的是用第二种方法 自增key 1.Redis自增key 的好处 原子性（atomicity）：一个事务是一个不可分割的最小工作单位，事务中包括的诸操作要么都做，要么都不做。 Redis所有单个命令的执行都是原子性的，这与它的单线程机制有关； Redis命令的原子性使得我们不用考虑并发问题，可以方便的利用原子性自增操作 简单.
使用redis incr处理并发问题
大道至简
05-06 3万+
一、背景    最近公司某个短信接口因为没有加验证码限制被恶意调用，最好的解决办法是做在发送短信请求前做一个验证码验证通过后再调用短信接口。但是由于需要立马改动，借此使用了一下 “缓兵之计”--redis计数器限制二、使用redis计数器引入黑名单机制   incr是redis中一个递增函数手册是这样介绍的Redis Incr 命令将 key 中储存的数字值增一。 如果 key 不存在，那么 k...
Redis INCR命令
花飘万家雪
05-24 1万+
路人甲：嘿，兄弟，知不知道redis的incr命令怎么用？路人丙：啥？你这都不知道，不就是将key值增1嘛？路人甲：可以一直一直一直加吗？路人丙：……下图是Redis命令参考网站给出的incr命令的使用方法：大家肯定都知道incr按照1递增，但是又有谁关注过incr的最大值？肯定不少人在看文档的时候把蓝色背景的文字漏了吧。这是一个针对字符串的操作，因为 Redis 没有专用的整数类型，所以 key...
redis基础篇——数据一致性
石灰聪的博客
12-01 3245
数据一致性 缓存使用场景 针对读多写少的高并发场景，我们可以使用缓存来提升查询速度。 当我们使用Redis作为缓存的时候，一般流程是这样的： 如果数据在Redis存在，应用就可以直接从Redis拿到数据，不用访问数据库。 应用新增了数据，只保存在数据库中，这个时候Redis没有这条数据。 如果Redis里面没有，先到数据库查询，然后写入到Redis，再返回给应用。 一致性问题的定义 因为数据最终是以数据库为准的（这是我们的原则），如果Redis没有数据，就不存在这个问题。当Redi
redis基础篇——Redis客户端（Jedis，Lettuce，Redisson）
石灰聪的博客
12-01 1189
Redis客户端 通信协议 Redis监听默认6379的端口号，可以通过TCP方式建立连接。 服务端约定了一种特殊的消息格式，每个命令都是以rn（CRLF回车+换行）结尾。这种编码格式我们之前在AOF文件里面见到了，叫做Redis Serialization Protocol（RESP，Redis序列化协议），发消息或者响应消息需要按这种格式编码，接收消息需要按这种格式解码。Redis设计这种格式的原因：容易实现、解析快、可读性强。Redis6.0新特性里面说的RESP协议升级到了3.0版本，其实就是
redis基础篇——发布订阅模式、事务（没多大用）
石灰聪的博客
11-27 217
发布订阅模式 通过队列的rpush和blpop可以实现消息队列，没有任何元素可以弹出的时候，连接会被阻塞。但是基于list实现的消息队列，不支持一对多的消息分发，相当于只有一个消费者。如果要实现一对多的消息分发就需要发布订阅模式。 消息的生产者和消费者是不同的客户端，连接到同一个Redis的服务。Redis的模型中是通过channel（频道）把生产者和消费者关联起来的。订阅者可以订阅一个或者多个channel，消息的发布者可以给指定的channel发布消息。只要有消息到达了channel，所有订阅了这
redis基础篇——高并发问题（缓存雪崩，缓存穿透）
石灰聪的博客
12-01 613
高并发问题（缓存雪崩，缓存穿透） 在Redis存储的所有数据中，有一部分是被频繁访问的。有两种情况可能会导致热点问题的产生，一个是用户集中访问的数据，比如抢购的商品，明星结婚和明星出轨的微博。还有一种就是在数据进行分片的情况下，负载不均衡，超过了单个服务器的承受能力。热点问题可能引起缓存服务的不可用，最终造成压力堆积到数据库。 出于存储和流量优化的角度，我们必须要找到这些热点数据。 热点数据发现 首先，Redis的缓存淘汰机制，能够留下那些热点的key，不管是LRU还是LFU 除了自动的缓存淘汰机制
使用redis incr处理并发，存在死锁问题
涛哥是个大帅比
07-27 1万+
使用redis incr处理并发，存在死锁问题，当正常情况没有问题，但是当计数器设置成功后，服务出现异常，那么这个key会永远存在，redisTemplate.opsForValue().increment(key, 1);这样肯定不行。将redis版本升级到2.1以上redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.SECONDS)
Redis爬坑记（一）：incr命令和expire命令的误区
热门推荐
区块链之美
06-08 4万+
要实现的功能：限制用户的每分钟的访问次数一个有严重bug的代码：每次访问来了，就执行代码块二，当第一次访问，就走else语句，设置当前用户的次数为1，且设置该key的有效期是一分钟。在一分钟之内，第二次来访问了，就走if语句了，因为redis存在这个key了，就实现自增一，然后取出来判断是否超过了设定的阈值。逻辑上看似看似没什么问题。代码块一：Long maxAllowedTimes = 100L...
Redis INCR key
weixin_33800463的博客
10-27 920
2019独角兽企业重金招聘Python工程师标准>>> ...
redis使用事务-踩坑
Evelyn_Jone的博客
11-01 2326
现象 使用get请求，incrment请求，返回结果一直为null 业务代码 org.springframework.transaction.support.TransactionTemplate transactionTemplate.execute(t -> { ... // 在事务里进行了redis的操作，且需要获取数据 Long incr = redisTemplate...
Redis客户端之Jedis（Key、String、Set、List、pub/sub、cluster、pool、pipleline）
技术改变生活
07-15 2万+
原文链接：http://blog.csdn.net/xyang81/article/details/51918129环境： OS：CentOS7 64位 server版本：Redis 3.2.0 client 版本：Jedis 2.8.0在Maven中引用jedis的jar：<dependencies> <dependency> <groupId>jun
【Redis学习】Transaction事务管理
lmb55的专栏
04-25 1335
1、相关命令：(1)MULTI标记一个事务块的开始。事务块内的多条命令会按照先后顺序被放进一个队列当中，最后由 EXEC 命令原子性(atomic)地执行。返回值：总是返回 OK 。redis> MULTI # 标记事务开始 OKredis> INCR user_id # 多条命令按顺序入队 QUEUEDredis> INCR user_id QUEUEDredis>
循序渐进 Redis 分布式锁（以及何时不用它）
lyl54545的博客
06-20 280
假设我们有个批处理服务，实现逻辑大致是这样的：流程如图：现在我们单独看看上图中虚线框中的内容（3~6）：批处理服务从数据库拉取任务列表投递到消息队列。生产环境中，为了高可用，都会部署至少两台批处理服务器，也就是说至少有两个进程在执行虚线框中的流程。有什么问题呢？假设这两个进程同时去查任务表（这是很有可能的），它俩很可能会得到同一批任务列表，于是这批任务都会入列两次。上图虚线框中那段逻辑在并发原语中有个专门名称叫“临界区”——我们要做的就是让多个操作者（进程、线程、协程）必须一个一个地（而不能一窝蜂地）去执行
Redis执行lua脚本，key不存在的返回值
weixin_30733003的博客
06-28 2283
Redis执行lua脚本，如果key不存在，则对应返回值为 false(boolean) local val = redis.call('get', KEYS[1])print(val) Redis 到 Lua 的转换表。 Redis integer reply -> Lua number / Redis 整数转换成 Lua 数字 Redis bulk r...
【小项目】Spring boot基于Redis缓存商城分类，商品信息（含源码下载）
不羁鱼|Karle
10-13 6977
商品分类：数据唯一，且一次性全部拿取，使用Set（集合）进行缓存 商品列表：数据具备排序支持，使用SortedSet（有序集合）进行缓存 商品详情：准确定位获取数据信息，使用Hash（哈希表）进行缓存
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值