【RuoYi-Vue-Plus】学习笔记 33 - Redisson（八）RedissonMapCache 缓存流程分析（上）（Lua 脚本）

最新推荐文章于 2024-05-02 22:13:20 发布
最新推荐文章于 2024-05-02 22:13:20 发布
阅读量1k 收藏 1
点赞数 3
分类专栏： 框架学习 - 若依 / RuoYi-Vue-Plus # Redisson 文章标签： RuoYi-Vue-Plus redisson lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michelle_Zhong/article/details/126384566
版权

文章目录

前言

最近和 狮子大佬 研究讨论了一下 Redisson 集成 Spring Cache 在底层实现的缓存相关操作。

在 上一篇笔记 中，着重点在于前面自动装配流程，对于缓存的相关操作分析的内容比较少（源码分析部分第 4 点有提及），因此再在此基础上深入来分析一下缓存的 Lua 脚本执行流程。

参考目录

提出问题

在缓存带有 TTL 值等相关参数的对象时，Redis 中的对象前面会有一段二进制的信息，例如下图：
在这里插入图片描述
注意，此处如果是 Key-Value 对象，不会有前面的这段信息，例如 OSS 配置信息：
在这里插入图片描述

问题分析

1、为什么只有带有 TTL 等信息的对象值前面会有二进制编码？

这个问题可以在源码中找到答案。

RedissonCache#put
在这里插入图片描述
缓存对象不同，底层操作是不同的方法。方法 mapCache.fastPut() 在底层 Lua 脚本中对数据进行了打包（下面会详细分析脚本）。

RedissonMapCache#fastPutOperationAsync
在这里插入图片描述

2、二进制编码的内容是什么？

从上面的脚本可以看到，前面的参数 maxIdleDelta 实际上就是设置的 TTL。
在这里插入图片描述
一开始没有得到这个答案时，狮子大佬也去 Redisson 提了 issue，得到的答复如下：
在这里插入图片描述
下面来探讨一下这个缓存流程。

测试执行流程说明

1、请求接口

在这里插入图片描述
调用次数：两次

2、请求参数

名称值
CacheNamedemo:cache#60s#10m#2
第一次请求 keytest
第一次请求 valuetest
第二次请求 keytest
第二次请求 valuetest1

3、预想结果

  • 第一次请求 Redis 缓存值为 test - test
  • 第二次请求 Redis 缓存值更新为 test - test1

注：缓存结果实际上是返回值对象 R ，这里简化为 R 中的 data 值。

4、请求结果

第一次请求：
在这里插入图片描述
第二次请求：
在这里插入图片描述
在这里插入图片描述

源码分析

源码主要分析 Lua 脚本部分，即前面提及的 put 方法RedissonMapCache#fastPutOperationAsync。

因为脚本内容比较多，所以会分成两篇进行分析，本篇是 关于对象的保存以及更新操作 。

1、流程简图（非常重要）

为了便于理解，我对完整的脚本执行流程画了流程图，这张图很长，主要是三个部分（已经用线区分开）：

  • 第一部分：计算过期时间，判断是 插入 操作还是 更新 操作
  • 第二部分：对于 超出最大限度的缓存值 的操作
  • 第三部分：打包并缓存，发布订阅消息

在这里插入图片描述
本篇内容主要是第一第三部分的分析，第二部分会在下一篇进行说明。

2、Lua 脚本

local insertable = false; 
local value = redis.call('hget', KEYS[1], ARGV[5]); 
local t, val;
if value == false then 
	insertable = true; 
else 
	t, val = struct.unpack('dLc0', value); 
	local expireDate = 92233720368547758; 
	local expireDateScore = redis.call('zscore', KEYS[2], ARGV[5]); 
	if expireDateScore ~= false then 
		expireDate = tonumber(expireDateScore) 
	end; 
	if t ~= 0 then 
		local expireIdle = redis.call('zscore', KEYS[3], ARGV[5]); 
		if expireIdle ~= false then 
			expireDate = math.min(expireDate, tonumber(expireIdle)) 
		end; 
	end; 
	if expireDate <= tonumber(ARGV[1]) then 
		insertable = true; 
	end; 
end; 

if tonumber(ARGV[2]) > 0 then 
	redis.call('zadd', KEYS[2], ARGV[2], ARGV[5]); 
else 
	redis.call('zrem', KEYS[2], ARGV[5]); 
end; 

if tonumber(ARGV[3]) > 0 then 
	redis.call('zadd', KEYS[3], ARGV[3], ARGV[5]); 
else 
	redis.call('zrem', KEYS[3], ARGV[5]); 
end; 

--// last access time
local maxSize = tonumber(redis.call('hget', KEYS[8], 'max-size')); 
local mode = redis.call('hget', KEYS[8], 'mode'); 
if maxSize ~= nil and maxSize ~= 0 then     
	local currentTime = tonumber(ARGV[1]);     
	local lastAccessTimeSetName = KEYS[6]; 
	
	if mode == false or mode == 'LRU' then 
		redis.call('zadd', lastAccessTimeSetName, currentTime, ARGV[5]); 
	end;     
	
	local cacheSize = tonumber(redis.call('hlen', KEYS[1]));     
	if cacheSize >= maxSize then         
		local lruItems = redis.call('zrange', lastAccessTimeSetName, 0, cacheSize - maxSize);         
		for index, lruItem in ipairs(lruItems) do             
			if lruItem and lruItem ~= ARGV[5] then                 
				local lruItemValue = redis.call('hget', KEYS[1], lruItem);                 
				redis.call('hdel', KEYS[1], lruItem);                 
				redis.call('zrem', KEYS[2], lruItem);                 
				redis.call('zrem', KEYS[3], lruItem);                 
				redis.call('zrem', lastAccessTimeSetName, lruItem);                 
				if lruItemValue ~= false then                 
					local removedChannelName = KEYS[7]; 
					local ttl, obj = struct.unpack('dLc0', lruItemValue);                
					local msg = struct.pack('Lc0Lc0', string.len(lruItem), lruItem, string.len(obj), obj);                
					redis.call('publish', removedChannelName, msg); 
				end;             
			end;         
		end;    
	end; 
	
	if mode == 'LFU' then 
		redis.call('zincrby', lastAccessTimeSetName, 1, ARGV[5]); 
	end; 
end; 

local value = struct.pack('dLc0', ARGV[4], string.len(ARGV[6]), ARGV[6]); 
redis.call('hset', KEYS[1], ARGV[5], value); 
if insertable == true then 
	local msg = struct.pack('Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6]); 
	redis.call('publish', KEYS[4], msg); 
	return 1;
else 
	local msg = struct.pack('Lc0Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6], string.len(val), val); 
	redis.call('publish', KEYS[5], msg); 
	return 0;
end;

脚本调用的方法参数对照表：

脚本参数名Java参数名参数值（第一次；第二次）含义
KEYS[1]name“demo:cache”CacheName
KEYS[2]getTimeoutSetName(name)“redisson__timeout__set:{demo:cache}”TimeoutSet 名称
KEYS[3]getIdleSetName(name)“redisson__idle__set:{demo:cache}”IdleSet 名称
KEYS[4]getCreatedChannelName(name)“redisson_map_cache_created:{demo:cache}”CreatedChannel 名称
KEYS[5]getUpdatedChannelName(name)“redisson_map_cache_updated:{demo:cache}”UpdatedChannel 名称
KEYS[6]getLastAccessTimeSetName(name)“redisson__map_cache__last_access__set:{demo:cache}”LastAccessTimeSet 名称
KEYS[7]getRemovedChannelName(name)“redisson_map_cache_removed:{demo:cache}”RemovedChannel 名称
KEYS[8]getOptionsName(name)“{demo:cache}:redisson_options”OptionsMap 名称
ARGV[1]System.currentTimeMillis()“1660564385882”；“1660564415922”当前系统时间
ARGV[2]ttlTimeout“1660564445882”；“1660564475922”过期时间
ARGV[3]maxIdleTimeout“1660564985882”；“1660565015922”最大空闲过期时间
ARGV[4]maxIdleDelta“600000”最大空闲增量（用于计算过期时间）
ARGV[5]encodeMapKey(key)““test””序列化后的Key
ARGV[6]encodeMapValue(value)“{”@class":“com.ruoyi.common.core.domain.R”,“code”:200,“data”:“test”,“msg”:“\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f”}" ；“{”@class":“com.ruoyi.common.core.domain.R”,“code”:200,“data”:“test1”,“msg”:“\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f”}"序列化后的缓存值

3、Lua 脚本代码分析

说明：

  • 分析注释部分只列出相关的部分的说明，没有说明的部分可以暂时忽略。
  • ## 代表注释说明或者是没有实际执行的请求。
  • ##(数值) 代表第几次请求，后面紧跟着的是底层执行的命令。
local insertable = false; 
local value = redis.call('hget', KEYS[1], ARGV[5]); 
-- "hget" "demo:cache" "\"test\""

local t, val;
-- t：ttl，val：缓存值

-- 判断是否有值
if value == false then 
	insertable = true; 
	-- 没有值：则可插入(insertable)
	
else 
	-- 有值
	t, val = struct.unpack('dLc0', value); 
	-- 获取 ttl 以及 value
	
	local expireDate = 92233720368547758; 
	local expireDateScore = redis.call('zscore', KEYS[2], ARGV[5]); 
	-- 过期时间分值
	-- #2 "zscore" "redisson__timeout__set:{demo:cache}" "\"test\""
	
	-- 判断过期时间分值是否存在
	if expireDateScore ~= false then 
		expireDate = tonumber(expireDateScore) 
		-- 获取过期时间
	end; 
	
	-- 判断 ttl 不为 0
	if t ~= 0 then 
		local expireIdle = redis.call('zscore', KEYS[3], ARGV[5]); 
		-- 过期空闲值
		-- #2 "zscore" "redisson__idle__set:{demo:cache}" "\"test\""
		
		if expireIdle ~= false then 
			expireDate = math.min(expireDate, tonumber(expireIdle)) 
			-- 获取过期时间以及空闲值更小值
		end; 
	end; 
	
	-- 判断过期时间是否小于等于系统时间
	if expireDate <= tonumber(ARGV[1]) then 
		insertable = true; 
		-- 可插入
	end; 
end; 

-- 判断  ttlTimeout 是否大于 0
if tonumber(ARGV[2]) > 0 then 
	redis.call('zadd', KEYS[2], ARGV[2], ARGV[5]); 
	-- 大于 0：加入 ttlTimeout set（redisson__timeout__set）
	-- #1 "zadd" "redisson__timeout__set:{demo:cache}" "1660564445882" "\"test\""
	-- #2 "zadd" "redisson__timeout__set:{demo:cache}" "1660564475922" "\"test\""
	
else 
	redis.call('zrem', KEYS[2], ARGV[5]); 
	-- 小于等于 0：从 set 移除该值
	-- ## "zrem" "redisson__timeout__set:{demo:cache}" "\"test\""
	
end; 

-- 判断 maxIdleTimeout 是否大于 0
if tonumber(ARGV[3]) > 0 then 
	redis.call('zadd', KEYS[3], ARGV[3], ARGV[5]); 
	-- 大于 0：加入 idle set（redisson__idle__set）
	-- #1 "zadd" "redisson__idle__set:{demo:cache}" "1660564985882" "\"test\""
	-- #2 "zadd" "redisson__idle__set:{demo:cache}" "1660565015922" "\"test\""
	
else 
	redis.call('zrem', KEYS[3], ARGV[5]); 
	-- 小于等于 0：从 set 移除该值
	-- ## "zrem" "redisson__idle__set:{demo:cache}" "\"test\""
	
end; 

local maxSize = tonumber(redis.call('hget', KEYS[8], 'max-size')); 
local mode = redis.call('hget', KEYS[8], 'mode'); 

if maxSize ~= nil and maxSize ~= 0 then     
	local currentTime = tonumber(ARGV[1]);     
	local lastAccessTimeSetName = KEYS[6]; 
	
	if mode == false or mode == 'LRU' then 
		redis.call('zadd', lastAccessTimeSetName, currentTime, ARGV[5]); 
	end;     
	
	local cacheSize = tonumber(redis.call('hlen', KEYS[1]));   
	
	if cacheSize >= maxSize then         
		local lruItems = redis.call('zrange', lastAccessTimeSetName, 0, cacheSize - maxSize);         
		
		for index, lruItem in ipairs(lruItems) do          
			if lruItem and lruItem ~= ARGV[5] then        
			
				local lruItemValue = redis.call('hget', KEYS[1], lruItem);                 
				redis.call('hdel', KEYS[1], lruItem);      
				redis.call('zrem', KEYS[2], lruItem);     {demo:cache}" "\"test\""
				redis.call('zrem', KEYS[3], lruItem);        
				redis.call('zrem', lastAccessTimeSetName, lruItem);           
				if lruItemValue ~= false then                 
					local removedChannelName = KEYS[7]; 
					local ttl, obj = struct.unpack('dLc0', lruItemValue);            
					local msg = struct.pack('Lc0Lc0', string.len(lruItem), lruItem, string.len(obj), obj);     
					redis.call('publish', removedChannelName, msg); 
				end;             
			end;         
		end;    
	end; 
	
	if mode == 'LFU' then 
		redis.call('zincrby', lastAccessTimeSetName, 1, ARGV[5]); 
	end; 
end; 

local value = struct.pack('dLc0', ARGV[4], string.len(ARGV[6]), ARGV[6]); 
-- 打包 缓存值（ttl，value）
-- "\x00\x00\x00\x00\x00L\xed@Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"

redis.call('hset', KEYS[1], ARGV[5], value); 
-- 插入缓存  
-- #1 "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AY\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
-- #2 "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AZ\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"

if insertable == true then 
	-- 插入缓存
	
	local msg = struct.pack('Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6]); 
	redis.call('publish', KEYS[4], msg); 
	-- #1 "publish" "redisson_map_cache_created:{demo:cache}" "\x06\x00\x00\x00\"test\"Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
	
	return 1;
else 
	-- 更新缓存
	
	local msg = struct.pack('Lc0Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6], string.len(val), val); 
	redis.call('publish', KEYS[5], msg); 
	-- #2 "publish" "redisson_map_cache_updated:{demo:cache}" "\x06\x00\x00\x00\"test\"Z\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
	
	return 0;
end;

4、Redis 实际执行结果

### 第一次请求：

"demo:cache"  KEYS[1] name
"redisson__timeout__set:{demo:cache}"  KEYS[2] getTimeoutSetName(name)
"redisson__idle__set:{demo:cache}"  KEYS[3] getIdleSetName(name)
"redisson_map_cache_created:{demo:cache}"  KEYS[4] getCreatedChannelName(name)
"redisson_map_cache_updated:{demo:cache}"  KEYS[5] getUpdatedChannelName(name)
"redisson__map_cache__last_access__set:{demo:cache}" KEYS[6] getLastAccessTimeSetName(name)
"redisson_map_cache_removed:{demo:cache}" KEYS[7] getRemovedChannelName(name)
"{demo:cache}:redisson_options" KEYS[8] getOptionsName(name)
"1660564385882" ARGV[1] System.currentTimeMillis()
"1660564445882" ARGV[2] ttlTimeout
"1660564985882" ARGV[3] maxIdleTimeout
"600000" ARGV[4] maxIdleDelta
"\"test\"" ARGV[5] encodeMapKey(key)
"{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}" ARGV[6] encodeMapValue(value)

1660564385.887959 [5 lua] "hget" "demo:cache" "\"test\""
1660564385.888021 [5 lua] "zadd" "redisson__timeout__set:{demo:cache}" "1660564445882" "\"test\""
1660564385.888065 [5 lua] "zadd" "redisson__idle__set:{demo:cache}" "1660564985882" "\"test\""
1660564385.888076 [5 lua] "hget" "{demo:cache}:redisson_options" "max-size"
1660564385.888082 [5 lua] "hget" "{demo:cache}:redisson_options" "mode"
1660564385.888097 [5 lua] "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AY\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564385.888146 [5 lua] "publish" "redisson_map_cache_created:{demo:cache}" "\x06\x00\x00\x00\"test\"Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"

-------------------------------------

### 第二次请求：

"demo:cache"  KEYS[1] name
"redisson__timeout__set:{demo:cache}"  KEYS[2] getTimeoutSetName(name)
"redisson__idle__set:{demo:cache}"  KEYS[3] getIdleSetName(name)
"redisson_map_cache_created:{demo:cache}"  KEYS[4] getCreatedChannelName(name)
"redisson_map_cache_updated:{demo:cache}"  KEYS[5] getUpdatedChannelName(name)
"redisson__map_cache__last_access__set:{demo:cache}" KEYS[6] getLastAccessTimeSetName(name)
"redisson_map_cache_removed:{demo:cache}" KEYS[7] getRemovedChannelName(name)
"{demo:cache}:redisson_options" KEYS[8] getOptionsName(name)
"1660564415922" ARGV[1] System.currentTimeMillis()
"1660564475922" ARGV[2] ttlTimeout
"1660565015922" ARGV[3] maxIdleTimeout
"600000" ARGV[4] maxIdleDelta
"\"test\"" ARGV[5] encodeMapKey(key)
"{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}" ARGV[6] encodeMapValue(value)

1660564415.923910 [5 lua] "hget" "demo:cache" "\"test\""
1660564415.923919 [5 lua] "zscore" "redisson__timeout__set:{demo:cache}" "\"test\""
1660564415.923932 [5 lua] "zscore" "redisson__idle__set:{demo:cache}" "\"test\""
1660564415.923943 [5 lua] "zadd" "redisson__timeout__set:{demo:cache}" "1660564475922" "\"test\""
1660564415.923956 [5 lua] "zadd" "redisson__idle__set:{demo:cache}" "1660565015922" "\"test\""
1660564415.923965 [5 lua] "hget" "{demo:cache}:redisson_options" "max-size"
1660564415.923971 [5 lua] "hget" "{demo:cache}:redisson_options" "mode"
1660564415.923980 [5 lua] "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AZ\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564415.924113 [5 lua] "publish" "redisson_map_cache_updated:{demo:cache}" "\x06\x00\x00\x00\"test\"Z\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"

附文

Redis monitor 模式下控制台输出完整内容

127.0.0.1:6379> monitor
OK
1660564385.875990 [5 127.0.0.1:1397] "GET" "Authorization:login:token:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564385.877948 [5 127.0.0.1:1398] "GET" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564385.879625 [5 127.0.0.1:1399] "PTTL" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564385.880673 [5 127.0.0.1:1392] "SET" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "\"1660564385878\""
1660564385.880832 [5 127.0.0.1:1392] "EVAL" "local result = 0;for j = 1, #KEYS, 1 do local expireSet; if ARGV[2] ~= '' then expireSet = redis.call('pexpire', KEYS[j], ARGV[1], ARGV[2]); else expireSet = redis.call('pexpire', KEYS[j], ARGV[1]); end; if expireSet == 1 then result = expireSet;end; end; return result; " "1" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "84581000" ""
1660564385.880967 [5 lua] "pexpire" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "84581000"
1660564385.887505 [5 127.0.0.1:1391] "EVAL" "local insertable = false; local value = redis.call('hget', KEYS[1], ARGV[5]); local t, val;if value == false then insertable = true; else t, val = struct.unpack('dLc0', value); local expireDate = 92233720368547758; local expireDateScore = redis.call('zscore', KEYS[2], ARGV[5]); if expireDateScore ~= false then expireDate = tonumber(expireDateScore) end; if t ~= 0 then local expireIdle = redis.call('zscore', KEYS[3], ARGV[5]); if expireIdle ~= false then expireDate = math.min(expireDate, tonumber(expireIdle)) end; end; if expireDate <= tonumber(ARGV[1]) then insertable = true; end; end; if tonumber(ARGV[2]) > 0 then redis.call('zadd', KEYS[2], ARGV[2], ARGV[5]); else redis.call('zrem', KEYS[2], ARGV[5]); end; if tonumber(ARGV[3]) > 0 then redis.call('zadd', KEYS[3], ARGV[3], ARGV[5]); else redis.call('zrem', KEYS[3], ARGV[5]); end; local maxSize = tonumber(redis.call('hget', KEYS[8], 'max-size')); local mode = redis.call('hget', KEYS[8], 'mode'); if maxSize ~= nil and maxSize ~= 0 then     local currentTime = tonumber(ARGV[1]);     local lastAccessTimeSetName = KEYS[6]; if mode == false or mode == 'LRU' then redis.call('zadd', lastAccessTimeSetName, currentTime, ARGV[5]); end;     local cacheSize = tonumber(redis.call('hlen', KEYS[1]));     if cacheSize >= maxSize then         local lruItems = redis.call('zrange', lastAccessTimeSetName, 0, cacheSize - maxSize);         for index, lruItem in ipairs(lruItems) do             if lruItem and lruItem ~= ARGV[5] then                 local lruItemValue = redis.call('hget', KEYS[1], lruItem);                 redis.call('hdel', KEYS[1], lruItem);                 redis.call('zrem', KEYS[2], lruItem);                 redis.call('zrem', KEYS[3], lruItem);                 redis.call('zrem', lastAccessTimeSetName, lruItem);                 if lruItemValue ~= false then                 local removedChannelName = KEYS[7]; local ttl, obj = struct.unpack('dLc0', lruItemValue);                local msg = struct.pack('Lc0Lc0', string.len(lruItem), lruItem, string.len(obj), obj);                redis.call('publish', removedChannelName, msg); end;             end;         end;     end; if mode == 'LFU' then redis.call('zincrby', lastAccessTimeSetName, 1, ARGV[5]); end; end; local value = struct.pack('dLc0', ARGV[4], string.len(ARGV[6]), ARGV[6]); redis.call('hset', KEYS[1], ARGV[5], value); if insertable == true then local msg = struct.pack('Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6]); redis.call('publish', KEYS[4], msg); return 1;else local msg = struct.pack('Lc0Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6], string.len(val), val); redis.call('publish', KEYS[5], msg); return 0;end;" "8" "demo:cache" "redisson__timeout__set:{demo:cache}" "redisson__idle__set:{demo:cache}" "redisson_map_cache_created:{demo:cache}" "redisson_map_cache_updated:{demo:cache}" "redisson__map_cache__last_access__set:{demo:cache}" "redisson_map_cache_removed:{demo:cache}" "{demo:cache}:redisson_options" "1660564385882" "1660564445882" "1660564985882" "600000" "\"test\"" "{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564385.887959 [5 lua] "hget" "demo:cache" "\"test\""
1660564385.888021 [5 lua] "zadd" "redisson__timeout__set:{demo:cache}" "1660564445882" "\"test\""
1660564385.888065 [5 lua] "zadd" "redisson__idle__set:{demo:cache}" "1660564985882" "\"test\""
1660564385.888076 [5 lua] "hget" "{demo:cache}:redisson_options" "max-size"
1660564385.888082 [5 lua] "hget" "{demo:cache}:redisson_options" "mode"
1660564385.888097 [5 lua] "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AY\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564385.888146 [5 lua] "publish" "redisson_map_cache_created:{demo:cache}" "\x06\x00\x00\x00\"test\"Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564390.215476 [5 127.0.0.1:1060] "ping"
1660564393.919090 [5 127.0.0.1:1060] "scan" "0" "MATCH" "*" "COUNT" "500"
1660564393.920848 [5 127.0.0.1:1060] "info"
1660564395.507559 [5 127.0.0.1:1060] "type" "demo:cache"
1660564395.518355 [5 127.0.0.1:1060] "ttl" "demo:cache"
1660564395.520778 [5 127.0.0.1:1060] "hlen" "demo:cache"
1660564395.530076 [5 127.0.0.1:1060] "hscan" "demo:cache" "0" "MATCH" "*" "COUNT" "200"
1660564399.210430 [5 127.0.0.1:1060] "ping"
1660564407.741175 [5 127.0.0.1:1391] "PING"
1660564407.741249 [5 127.0.0.1:1393] "PING"
1660564407.741257 [5 127.0.0.1:1395] "PING"
1660564407.741405 [5 127.0.0.1:1394] "PING"
1660564407.741460 [5 127.0.0.1:1392] "PING"
1660564407.741495 [5 127.0.0.1:1396] "PING"
1660564407.741512 [5 127.0.0.1:1397] "PING"
1660564407.742088 [5 127.0.0.1:1398] "PING"
1660564407.742404 [5 127.0.0.1:1399] "PING"
1660564410.211844 [5 127.0.0.1:1060] "ping"
1660564415.916463 [5 127.0.0.1:1394] "GET" "Authorization:login:token:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564415.917887 [5 127.0.0.1:1395] "GET" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564415.920153 [5 127.0.0.1:1396] "PTTL" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY"
1660564415.921689 [5 127.0.0.1:1397] "SET" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "\"1660564415918\""
1660564415.921738 [5 127.0.0.1:1397] "EVAL" "local result = 0;for j = 1, #KEYS, 1 do local expireSet; if ARGV[2] ~= '' then expireSet = redis.call('pexpire', KEYS[j], ARGV[1], ARGV[2]); else expireSet = redis.call('pexpire', KEYS[j], ARGV[1]); end; if expireSet == 1 then result = expireSet;end; end; return result; " "1" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "84550000" ""
1660564415.921819 [5 lua] "pexpire" "Authorization:login:last-activity:eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpblR5cGUiOiJsb2dpbiIsImxvZ2luSWQiOiJzeXNfdXNlcjoxIiwicm5TdHIiOiJVRzNpaFBZc1hiUGx3NzdjM2hUZFd5UGNHYkJYcmQ1TyJ9.X5b9I9ZNIucfwyEMWSvB99oabna9nvMM7QK6xBBcPtY" "84550000"
1660564415.923539 [5 127.0.0.1:1398] "EVAL" "local insertable = false; local value = redis.call('hget', KEYS[1], ARGV[5]); local t, val;if value == false then insertable = true; else t, val = struct.unpack('dLc0', value); local expireDate = 92233720368547758; local expireDateScore = redis.call('zscore', KEYS[2], ARGV[5]); if expireDateScore ~= false then expireDate = tonumber(expireDateScore) end; if t ~= 0 then local expireIdle = redis.call('zscore', KEYS[3], ARGV[5]); if expireIdle ~= false then expireDate = math.min(expireDate, tonumber(expireIdle)) end; end; if expireDate <= tonumber(ARGV[1]) then insertable = true; end; end; if tonumber(ARGV[2]) > 0 then redis.call('zadd', KEYS[2], ARGV[2], ARGV[5]); else redis.call('zrem', KEYS[2], ARGV[5]); end; if tonumber(ARGV[3]) > 0 then redis.call('zadd', KEYS[3], ARGV[3], ARGV[5]); else redis.call('zrem', KEYS[3], ARGV[5]); end; local maxSize = tonumber(redis.call('hget', KEYS[8], 'max-size')); local mode = redis.call('hget', KEYS[8], 'mode'); if maxSize ~= nil and maxSize ~= 0 then     local currentTime = tonumber(ARGV[1]);     local lastAccessTimeSetName = KEYS[6]; if mode == false or mode == 'LRU' then redis.call('zadd', lastAccessTimeSetName, currentTime, ARGV[5]); end;     local cacheSize = tonumber(redis.call('hlen', KEYS[1]));     if cacheSize >= maxSize then         local lruItems = redis.call('zrange', lastAccessTimeSetName, 0, cacheSize - maxSize);         for index, lruItem in ipairs(lruItems) do             if lruItem and lruItem ~= ARGV[5] then                 local lruItemValue = redis.call('hget', KEYS[1], lruItem);                 redis.call('hdel', KEYS[1], lruItem);                 redis.call('zrem', KEYS[2], lruItem);                 redis.call('zrem', KEYS[3], lruItem);                 redis.call('zrem', lastAccessTimeSetName, lruItem);                 if lruItemValue ~= false then                 local removedChannelName = KEYS[7]; local ttl, obj = struct.unpack('dLc0', lruItemValue);                local msg = struct.pack('Lc0Lc0', string.len(lruItem), lruItem, string.len(obj), obj);                redis.call('publish', removedChannelName, msg); end;             end;         end;     end; if mode == 'LFU' then redis.call('zincrby', lastAccessTimeSetName, 1, ARGV[5]); end; end; local value = struct.pack('dLc0', ARGV[4], string.len(ARGV[6]), ARGV[6]); redis.call('hset', KEYS[1], ARGV[5], value); if insertable == true then local msg = struct.pack('Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6]); redis.call('publish', KEYS[4], msg); return 1;else local msg = struct.pack('Lc0Lc0Lc0', string.len(ARGV[5]), ARGV[5], string.len(ARGV[6]), ARGV[6], string.len(val), val); redis.call('publish', KEYS[5], msg); return 0;end;" "8" "demo:cache" "redisson__timeout__set:{demo:cache}" "redisson__idle__set:{demo:cache}" "redisson_map_cache_created:{demo:cache}" "redisson_map_cache_updated:{demo:cache}" "redisson__map_cache__last_access__set:{demo:cache}" "redisson_map_cache_removed:{demo:cache}" "{demo:cache}:redisson_options" "1660564415922" "1660564475922" "1660565015922" "600000" "\"test\"" "{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564415.923910 [5 lua] "hget" "demo:cache" "\"test\""
1660564415.923919 [5 lua] "zscore" "redisson__timeout__set:{demo:cache}" "\"test\""
1660564415.923932 [5 lua] "zscore" "redisson__idle__set:{demo:cache}" "\"test\""
1660564415.923943 [5 lua] "zadd" "redisson__timeout__set:{demo:cache}" "1660564475922" "\"test\""
1660564415.923956 [5 lua] "zadd" "redisson__idle__set:{demo:cache}" "1660565015922" "\"test\""
1660564415.923965 [5 lua] "hget" "{demo:cache}:redisson_options" "max-size"
1660564415.923971 [5 lua] "hget" "{demo:cache}:redisson_options" "mode"
1660564415.923980 [5 lua] "hset" "demo:cache" "\"test\"" "\x00\x00\x00\x00\x80O\"AZ\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
1660564415.924113 [5 lua] "publish" "redisson_map_cache_updated:{demo:cache}" "\x06\x00\x00\x00\"test\"Z\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test1\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}Y\x00\x00\x00{\"@class\":\"com.ruoyi.common.core.domain.R\",\"code\":200,\"data\":\"test\",\"msg\":\"\xe6\x93\x8d\xe4\xbd\x9c\xe6\x88\x90\xe5\x8a\x9f\"}"
MichelleChung
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
RuoYi-Vue-Plus 是重写 RuoYi-Vue 针对 分布式集群与多租户 场景全方位升级(不兼容原框架)
06-02
RuoYi-Vue-Plus 是重写 RuoYi-Vue 针对 分布式集群与多租户 场景全方位升级(不兼容原框架)
ruoyi-vue-pro开发指南PDF下载
03-07
ruoyi-vue-pro开发指南PDF下载 包含各种组件开发指南
缓存的使用（Redis、Redisson、SpringCache）
最新发布
weixin_43188446的博客
05-02 1002
spring:cache:#指定缓存类型为redisredis:///指定redis中的过期时间为1h@Bean//指定缓存序列化方式为json//下面的逻辑是复制过来的//设置配置文件中的各项配置，如过期时间= null) {= null) {if (!if (!
若依ruoyi ruoyi-vue ruoyi-cloud 微服务全网最全视频教程网盘资源
12-25
若依ruoyi ，ruoyi-vue， ruoyi-cloud， 微服务全网最全视频教程网盘资源 RuoYi-Cloud 微服务版本视频课程目录 ├──01 项目概述.mp4 20.77M ├──02 微架构概念.mp4 20.99M ├──03 微架构及选型.mp4 21.19M ├──04 目录文件介绍.mp4 17.16M ├──05 项目运行.mp4 108.31M ├──06 构建发布到Linux.mp4 70.13M ├──07 开发环境运行.mp4 82.35M ├──08 服务网关介绍.mp4 23.32M ├──09 使用服务网关.mp4 35.82M ├──10 网关路由规则.mp4 27.60M ├──11 网关路由配置.mp4 15.71M ├──12 网关限流配置.mp4 34.21M ├──13 网关熔断降级.mp4 30.85M ├──14 网关跨域配置.mp4 35.81M ├──15 网关黑名单配置.mp4 10.88M ├
redis缓存优化—SpringCache
MRhan6的博客
07-05 360
问题：所有数据从数据库MySQL直接查询，可能会存在问题：解决方法：通过Redis缓存技术缓存优化思路：Spring Cache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能，大大简化我们在业务中操作缓存的代码。Spring Cache只是提供了一层抽象，底层可以切换不同的cache实现。具体就是通过CacheManager接口来统一不同的缓存技术。CacheManager是Spring提供的各种缓存技术抽象接口。针对不同的缓存技术需要实现不同的CacheManager： 注
Redisson实现简单消息队列：优雅解决缓存清理冲突
修己xj的博客
07-24 1343
Redisson是一个功能强大的Java库，基于Redis构建，它提供了分布式数据结构和服务，以及异步处理的解决方案。其中，消息队列是Redisson提供的一项强大功能，用于在多个模块之间实现高效的消息传递和处理。通过Redisson的消息队列功能，我们成功实现了一个简单而高效的缓存清理解决方案。该方案有效解决了多个模块同时发布工单导致缓存清理冲突的问题，提高了应用程序的性能和稳定性。适用场景：多个模块在短时间内发布工单，并需要清理同一个接口的缓存。
【RuoYi-Vue-Plus】学习笔记 34 - Redisson（九）RedissonMapCache 缓存流程分析（下）（Lua 脚本）
MichelleChung的星球
08-17 1316
RedissonMapCache 缓存流程分析（下），Cache Put 操作超过 maxSize 执行分析。
从头开始学Redisson--------分布式集合之映射缓存(MapCache)
热门推荐
大宇的博客，欢迎访问
04-01 1万+
一、缓存映射（MapCache） Redisson的分布式的RMapCacheJava对象在基于RMap的前提下实现了针对单个元素的淘汰机制。同时仍然保留了元素的插入顺序。映射缓存(MapCache)它能够保留插入元素的顺序，并且可以指明每个元素的过期时间（专业一点叫元素淘汰机制）。另外还为每个元素提供了监听器，提供了4种不同类型的监听器。有：添加、过期、删除、更新四大事件。 ...
Redisson中MapCache导致OGC内存泄露问题
cyh0107的博客
07-07 661
发现mapcache对每一个键值对都会设置一个本地的定时任务，在过期时间到了之后，再对redis中的mapcache键值对删除
咖啡汪推荐————使用Redisson组件，缓存映射MapCache进行短信验证码失效验证
weixin_42994251的博客
09-06 1896
（一）开篇，本汪先讲使用Redisson的MapCache的优点 1.Redisson组件，缓存映射MapCache 可以很好地解决DB负载过高的问题,每次进行校验，只需从缓存中查询，不需再查数据库。 2.可以解决定时任务处理不及时的问题，通过实现ApplicationRunner, Ordered两个接口，可以在应用启动和运行期间，不间断监听，并执行我们所需的业务逻辑代码。 3.解决了批次查询的数据量可能过大占用过多的缓存的问题 我们使用纯sql加定时器进行短信验证码失效验证和使用redis进行短信验证码
基于redisson的Redis分布式缓存(一)
zl_momomo的博客
08-16 9517
Redisson提供了将Redis无缝整合到Spring框架的能力。Redisson依照Spring Cache标准提供了基于Redis的Spring缓存实现。 每个缓存（Cache）实例都提供了了两个重要的可配置参数：过期时间（ttl）和最长空闲时间（maxIdleTime），如果这两个参数都未指定或值为0，那么实例管理的数据将永久保存。 Jar包  &lt;!-- JDK 1.8+ co...
ruoyi-vue-pro yudao 项目报表设计器 积木报表模块启用及相关SQL脚本
08-20
ruoyi-vue-pro yudao 项目报表设计器 积木报表模块启用及相关SQL脚本, 模块开启可以参考博文
传输加解密 RuoYi-Vue-PLus 4.x
10-17
传输加解密 RuoYi-Vue-PLus 4.x
从头开始学Redisson--------分布式集合之本地缓存映射(RLocalCachedMap)
大宇的博客，欢迎访问
03-25 7919
一、RLocalCachedMap本地缓存映射 都说存在就是合理，上一节的分布式集合映射(RMap)已经实现了分布式情况下类似于Redis的hash功能。那为什么现在又冒出来一个本地缓存映射(RLocalCacheMap)呢？从代码的角度来看，本地缓存映射RLocalCacheMap继承了映射RMap，因此就具备了RMap的所有功能。 public interface RL...
Redis系列（8）-Redisson2（使用）
编程是一门实践技术
05-09 1068
Redis系列（8）-Redisson2（使用）
Redisson结合SpringCache优雅的使用缓存
weixin_59850019的博客
10-12 371
Redisson结合SpringCache优雅的使用缓存
优秀！这个开源项目中基于Redisson封装了CacheManager的缓存实现
BASK2311的博客
08-16 372
RuoYi-Vue-Plus 是针对 RuoYi-Vue 进行了相关的重写，针对分布式集群场景全方位升级(不兼容原框架)的一个后端快速开发框架。RuoYi-Vue-Plus项目目前也加入了dromara开源社区。为啥我想介绍这个后端快速开发平台呢？在项目根目录下的ruoyi-framework工程下的src的源码包com.ruoyi.framework.manager中，存在这样一个类：ini复制代码。
【浅学Redis】Spring Cache的基础使用
qq_52276036的博客
02-11 394
用Spring Cache 操作redis来缓存数据，真的方便太多了
Spring Boot 系列: 集成 Redis 数据库 分布式工具 Redisson 缓存 Spring Cache
weixin_46812727的博客
05-24 647
Spring Boot 集成 Redis 数据库 分布式工具 Redisson 缓存 Spring Cache
ruoyi-vue-plus和ruiyi-vue区别
05-27
Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上进行了功能扩展和性能优化的版本，它增加了一些新的功能模块，如数据权限管理、在线用户监控、Redis 缓存管理等，同时也对原有功能进行了优化和改进。另外，Ruoyi-Vue-Plus 还添加了一些实用的工具类和代码生成器模板，使开发人员能够更快捷地进行开发。 总的来说，Ruoyi-Vue-Plus 是在 Ruoyi-Vue 的基础上做了一些增强和改进，功能更加完善，性能更加优化，同时也提供了更多的实用工具和模板，方便开发人员进行快速开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MichelleChung

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

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

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

打赏作者

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

抵扣说明：

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

余额充值