Redis 支持的 Lau 脚本之 SpringBoot 使用
第一部分：Lua 脚本简介
当涉及 Lua 编程时，以下是对前述 12 个关键概念的详细说明，附带 Lua 代码示例以帮助你更深入了解这门编程语言：
注释：
注释在 Lua 中用于添加说明和注解。单行注释以 -- 开始，多行注释则使用 --[[ ... ]]。
-- 这是一条单行注释
--[[
这是一个多行注释
可以跨越多行
]]变量：
变量在 Lua 中无需显式声明类型。使用 local 关键字创建局部变量，全局变量直接声明。
local age = 30 name = "John" -- 全局变量
数据类型：
基本数据类型包括整数、浮点数、字符串、布尔值和 nil。
表是一种非常灵活的数据结构。
local num = 42
local str = "Hello, Lua!"
local flag = true
local empty = nil
local person = { name = "John", age = 30 }控制结构：
条件语句：使用 if、else 和 elseif 来实现条件分支。
if age < 18 then
print("未成年")
elseif age >= 18 and age < 65 then
print("成年")
else
print("老年")
end循环结构：Lua 支持 for 循环、while 循环和 repeat...until 循环。
for i = 1, 5 do
print(i)
end
local count = 0
while count < 3 do
print("循环次数: " .. count)
count = count + 1
end
repeat
print("至少执行一次")
until count > 5函数：
函数在 Lua 中使用 function 关键字定义，可以接受参数并返回值。
function add(a, b)
return a + b
end
local result = add(5, 3)
print("5 + 3 = " .. result)表（table）：
表是 Lua 的核心数据结构，用花括号{}定义。
表可以包含键值对，键和值可以是任何数据类型。
local person = { name = "John", age = 30, hobbies = {"Reading", "Gaming"} }
print("姓名：" .. person.name)
print("年龄：" .. person.age)模块：
Lua 支持模块化编程，允许将相关功能封装在独立的模块中，并通过 require 关键字加载它们。示例略显复杂，请参考 Lua 模块的标准用法以获得详细示例。
字符串操作：
Lua 提供了许多字符串处理函数，例如 string.sub 用于截取子串，string.find 用于查找字符串中的子串等。
local text = "Lua programming"
local sub = string.sub(text, 1, 3)
print(sub) -- 输出 "Lua"错误处理：
错误处理通常使用 pcall 函数来包裹可能引发异常的代码块，关注公众号：码猿技术专栏，回复关键词：1111 获取阿里内部 Java 性能调优手册！以捕获并处理错误。这通常与 assert 一起使用。
local success, result = pcall(function()
error("出错了！") end)
if success then
print("执行成功")
else
print("错误信息: " .. result)
end标准库：
Lua 标准库包含丰富的功能，如文件操作、网络编程、正则表达式、时间处理等。你可以通过内置的模块来使用这些功能，如 io、socket 等。
总之，Lua 是一种灵活的编程语言，其简洁性和强大的表格数据结构使其在各种应用中具有广泛的用途。这些示例代码应该有助于更好地理解 Lua 的基本概念和语法。
第二部分：为什么选择 Lua 脚本
Lua 脚本在 Redis 中的使用有许多优势，使其成为执行复杂操作的理想选择。以下是一些主要原因：
- 性能：
Lua 脚本在 Redis 中执行，避免了多次的客户端与服务器之间的通信。这可以减少网络开销，提高性能，特别是在需要执行多个 Redis 命令以完成一个操作时。原子性：Redis 保证 Lua 脚本的原子性执行，无需担心竞态条件或并发问题。
- 事务：
Lua 脚本可以与 Redis 事务一起使用，确保一系列命令的原子性执行。这允许你将多个操作视为一个单一的事务，要么全部成功，要么全部失败。
- 复杂操作：
Lua 脚本提供了一种在 Redis 中执行复杂操作的方法，允许你在一个脚本中组合多个 Redis 命令。这对于处理复杂的业务逻辑非常有用，例如计算和更新分布式计数器、实现自定义数据结构等。
- 原子锁：
使用 Lua 脚本，你可以实现复杂的原子锁，而不仅仅是使用 Redis 的 SETNX（set if not exists）命令。这对于分布式锁的实现非常重要。
- 减少网络开销：
对于大批量的数据处理，Lua 脚本可以减少客户端和服务器之间的往返次数，从而显著减少网络开销。
- 减少服务器负载：
通过将复杂的计算移至服务器端，可以减轻客户端的负担，降低服务器的负载。
- 原生支持：
Redis 天生支持 Lua 脚本，因此不需要额外的插件或扩展。
- 可读性和维护性：
Lua 脚本是一种常见的脚本语言，易于编写和维护。将复杂逻辑封装在脚本中有助于提高代码的可读性。
总之，Lua 脚本在 Redis 中的优势在于它可以原子性地执行复杂操作、减少网络通信、提高性能、减轻服务器负载，以及提高代码的可读性。这使得它成为执行一系列复杂操作的理想选择，尤其是在分布式系统中需要高性能和可伸缩性的场景下。通过 Lua 脚本，Redis 不仅成为一个键值存储，还能执行复杂的数据操作。
第三部分：lua 脚本的应用场景
Lua 脚本在 Redis 中有广泛的应用场景，以下是一些示例场景，展示了 Lua 脚本的实际用途：
1. 缓存更新：
场景：在缓存中存储某些数据，但需要定期或基于条件更新这些数据，同时确保在更新期间不会发生并发问题。
示例：使用 Lua 脚本，你可以原子性地检查数据的新鲜度，如果需要更新，可以在一个原子性操作中重新计算数据并更新缓存。
local cacheKey = KEYS[1] -- 获取缓存键
local data = redis.call('GET', cacheKey) -- 尝试从缓存获取数据
if not data then
-- 数据不在缓存中，重新计算并设置
data = calculateData()
redis.call('SET', cacheKey, data)
end
return data2. 原子操作：
场景：需要执行多个 Redis 命令作为一个原子操作，确保它们在多线程或多进程环境下不会被中断。
示例：使用 Lua 脚本，你可以将多个命令组合成一个原子操作，如实现分布式锁、计数器、排行榜等。
local key = KEYS[1] -- 获取键名
local value = ARGV[1] -- 获取参数值
local current = redis.call('GET', key) -- 获取当前值
if not current or tonumber(current) < tonumber(value) then
-- 如果当前值不存在或新值更大，设置新值
redis.call('SET', key, value)
end3. 数据处理：
场景：需要对 Redis 中的数据进行复杂的处理，如统计、筛选、聚合等。
示例：使用 Lua 脚本，你可以在 Redis 中执行复杂的数据处理，而不必将数据传输到客户端进行处理，减少网络开销。
local keyPattern = ARGV[1] -- 获取键名的匹配模式
local keys = redis.call('KEYS', keyPattern) -- 获取匹配的键
local result = {}
for i, key in ipairs(keys) do
local data = redis.call('GET', key) -- 获取每个键对应的数据
-- 处理数据并添加到结果中
table.insert(result, processData(data))
end
return result4. 分布式锁：
场景：实现分布式系统中的锁机制，确保只有一个客户端可以执行关键操作。
示例：使用 Lua 脚本，你可以原子性地尝试获取锁，避免竞态条件，然后在完成后释放锁。
local lockKey = KEYS[1] -- 获取锁的键名
local lockValue = ARGV[1] -- 获取锁的值
local lockTimeout = ARGV[2] -- 获取锁的超时时间
if redis.call('SET', lockKey, lockValue, 'NX', 'PX', lockTimeout) then
-- 锁获取成功，执行关键操作
-- ...
redis.call('DEL', lockKey) -- 释放锁
return true
else
return false -- 无法获取锁这些场景只是 Lua 脚本在 Redis 中的应用之一。Lua 脚本允许你在 Redis 中执行更复杂的操作，而无需进行多次的网络通信，从而提高性能和可伸缩性，同时确保数据的一致性和原子性。这使得 Lua 成为 Redis 的强大工具，用于处理各种分布式系统需求。
第四部分：Lua 脚本在 Spring Boot 中的实现
使用 redisson
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--redisson-->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
</dependency>配置类
在这之前已经正常配置配置文件和使用 RedisTemplate，如下是不影响原 RedisTemplate 的配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author Wang WenLei
* @date 2026/1/4 14:59
* @since 1.0
*/
@Configuration
public class RedisLuaConfig {
@Bean(name = "luaStringRedisTemplate")
public StringRedisTemplate luaStringRedisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(factory);
// StringRedisTemplate 默认就是 StringRedisSerializer
// 这里显式写出来，增强可读性
StringRedisSerializer stringSerializer = new StringRedisSerializer();
template.setKeySerializer(stringSerializer);
template.setValueSerializer(stringSerializer);
template.setHashKeySerializer(stringSerializer);
template.setHashValueSerializer(stringSerializer);
template.afterPropertiesSet();
return template;
}
@Bean(name = "presenceScript")
public DefaultRedisScript<String> presenceScript() {
DefaultRedisScript<String> script = new DefaultRedisScript<>();
script.setResultType(String.class);
// 输入都是字符串，需要数字使用 `tonumber()` 转回数字
script.setScriptText(
"local last = redis.call('GET', KEYS[1])\n" +
"if not last then\n" +
" redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[2]))\n" +
" return 'INIT'\n" +
"end\n" +
"if last ~= ARGV[1] then\n" +
" redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[2]))\n" +
" return last .. '->' .. ARGV[1]\n" +
"end\n" +
"return 'NO_CHANGE'"
);
return script;
}
}使用
引入
@Autowired
@Qualifier("luaStringRedisTemplate")
private StringRedisTemplate redisTemplate;
@Autowired
@Qualifier("presenceScript")
private DefaultRedisScript<String> humanScript;方法里执行
注意输入都是字符串
String result = redisTemplate.execute(humanScript, Collections.singletonList(cacheKey), "1", "120");使用 Lettuce 或 Jedis
在 Spring Boot 中实现 Lua 脚本的执行主要涉及 Spring Data Redis 和 Lettuce（或 Jedis）客户端的使用。以下是编写、加载和执行 Lua 脚本的步骤和示例：
- 添加依赖：
首先，在 Spring Boot 项目的 pom.xml 中，添加 Spring Data Redis 和 Lettuce（或 Jedis）的依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>io.lettuce.core</groupId>
<artifactId>lettuce-core</artifactId> <!-- 或使用Jedis -->
</dependency>- 配置 Redis 连接：
在 application.properties 或 application.yml 中配置 Redis 连接属性，包括主机、端口、密码等。
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=yourPassword- 创建 Lua 脚本：
创建一个 Lua 脚本，以执行你需要的操作。将脚本保存在 Spring Boot 项目的合适位置。
例如，假设你有一个 Lua 脚本文件 myscript.lua，它实现了一个简单的计算：
local a = tonumber(ARGV[1])
local b = tonumber(ARGV[2])
return a + b- 编写 Java 代码：
在 Spring Boot 应用中，编写 Java 代码以加载和执行 Lua 脚本。使用 Spring Data Redis 提供的 StringRedisTemplate 或 LettuceConnectionFactory。
提供两种不同的示例来执行 Lua 脚本，一种是直接运行 Lua 脚本字符串，另一种是运行脚本文件。
以下是这两种示例：
- 运行 Lua 脚本字符串：
@Service
public class LuaScriptService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
public Integer executeLuaScriptFromString() {
String luaScript = "local a = tonumber(ARGV[1])\nlocal b = tonumber(ARGV[2])\nreturn a + b";
RedisScript<Integer> script = new DefaultRedisScript<>(luaScript, Integer.class);
String[] keys = new String[0]; // 通常情况下，没有KEYS部分
Object[] args = new Object[]{10, 20}; // 传递给Lua脚本的参数
Integer result = stringRedisTemplate.execute(script, keys, args);
return result;
}
}- 运行 Lua 脚本文件：
首先，将 Lua 脚本保存到文件，例如 myscript.lua。
然后，创建一个 Java 类来加载和运行该脚本文件：
@Service
public class LuaScriptService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private ResourceLoader resourceLoader;
public Integer executeLuaScriptFromFile() {
Resource resource = resourceLoader.getResource("classpath:myscript.lua");
String luaScript;
try {
luaScript = new String(resource.getInputStream().readAllBytes());
} catch (Exception e) {
throw new RuntimeException("Unable to read Lua script file.");
}
RedisScript<Integer> script = new DefaultRedisScript<>(luaScript, Integer.class);
String[] keys = new String[0]; // 通常情况下，没有KEYS部分
Object[] args = new Object[]{10, 20}; // 传递给Lua脚本的参数
Integer result = stringRedisTemplate.execute(script, keys, args);
return result;
}
}通过这两种示例，你可以选择要执行 Lua 脚本的方式，是直接在 Java 代码中定义脚本字符串，还是从文件中读取脚本。
- 运行应用程序：
启动 Spring Boot 应用程序，然后可以调用 LuaScriptService 中的 executeLuaScript 方法来执行 Lua 脚本。
这个示例中，我们首先注入了 StringRedisTemplate，然后创建了一个 RedisScript 对象，传递 Lua 脚本和期望的结果类型。在 execute 方法中，我们传递了 Lua 脚本中需要的参数。这个方法将加载并执行 Lua 脚本，并返回结果。
通过这些步骤，你可以在 Spring Boot 应用程序中实现 Lua 脚本的编写、加载和执行。这使你能够在 Redis 中执行自定义操作，从而更好地控制和扩展你的应用程序。
第五部分：Lua 脚本来提高 Spring Boot 应用程序的性能
使用 Lua 脚本可以显著提高 Spring Boot 应用程序的性能，尤其是在与 Redis 交互方面。以下是如何使用 Lua 脚本来实现性能优化的几种方法：
1. 减少网络开销：
Redis 是内存数据库，数据存储在内存中，而网络通信通常是 Redis 操作的性能瓶颈之一。通过使用 Lua 脚本，你可以将多个操作组合成一个原子操作，从而减少了多次的网络往返次数。这对于需要执行多个 Redis 命令以完成一个操作的情况非常有用。
2. 原子操作：
Lua 脚本的执行是原子的，这意味着在 Lua 脚本执行期间，没有其他客户端可以插入其他操作。这使得 Lua 脚本在实现诸如分布式锁、计数器、排行榜等需要原子操作的情况下非常有用。
例如，考虑一个计数器的场景，多个客户端需要原子性地增加计数。使用 Lua 脚本，你可以实现原子递增：
local key = KEYS[1]
local increment = ARGV[1]
return redis.call('INCRBY', key, increment)3. 复杂操作：
Lua 脚本允许你在 Redis 服务器端执行复杂的数据处理。这减少了将数据传输到客户端进行处理的开销，并允许你在 Redis 中执行更复杂的逻辑，从而提高性能。
例如，你可以使用 Lua 脚本来处理存储在多个键中的数据并返回聚合结果：
local total = 0
for _, key in ipairs(KEYS) do
local value = redis.call('GET', key)
total = total + tonumber(value)
end
return total4. 事务：
与 Lua 脚本一起使用事务可以确保一系列 Redis 命令的原子性执行。这对于需要一组操作要么全部成功，要么全部失败的情况非常重要。
例如，你可以使用 Lua 脚本在事务中执行一系列更新操作，如果其中一个操作失败，整个事务将回滚：
local key1 = KEYS[1]
local key2 = KEYS[2]
local value = ARGV[1]
redis.call('SET', key1, value)
redis.call('INCRBY', key2, value)
-- 如果这里的任何一步失败，整个事务将回滚总之，使用 Lua 脚本可以大大提高 Spring Boot 应用程序与 Redis 之间的性能。它减少了网络开销，允许执行原子操作，执行复杂操作并实现事务，这些都有助于提高应用程序的性能和可伸缩性。因此，Lua 脚本是在与 Redis 交互时实现性能优化的有力工具。
第六部分：错误处理和安全性
处理 Lua 脚本中的错误和确保安全性在与 Redis 交互时非常重要。以下是如何处理这些问题的一些建议：
错误处理：
错误返回值： Lua 脚本在执行期间可能会遇到错误，例如脚本本身存在语法错误，或者在脚本中的某些操作失败。Redis 执行 Lua 脚本后，会返回脚本的执行结果。你可以检查这个结果以查看是否有错误，通常返回值是一个特定的错误标识。例如，如果脚本执行成功，返回值通常是 OK，否则会有相应的错误信息。
异常处理： 在 Spring Boot 应用程序中，你可以使用异常处理来捕获 Redis 执行脚本时可能抛出的异常。Spring Data Redis 提供了一些异常类，如
RedisScriptExecutionException，用于处理脚本执行期间的错误。你可以使用try-catch块来捕获这些异常并采取相应的措施，例如记录错误信息或执行备用操作。
安全性：
参数验证： 在执行 Lua 脚本之前，始终验证传递给脚本的参数。确保参数是合法的，并且不包含恶意代码。避免将不受信任的用户输入直接传递给 Lua 脚本，因为它可能包含恶意的 Lua 代码。
限制权限： 在 Redis 服务器上配置适当的权限，以限制对 Lua 脚本的执行。确保只有授权的用户能够执行脚本，并且不允许执行具有破坏性或不安全操作的脚本。
白名单： 如果你允许动态加载 Lua 脚本，确保只有受信任的脚本可以执行。你可以创建一个白名单，只允许执行白名单中的脚本，防止执行未经审核的脚本。
沙盒模式： 一些 Redis 客户端库支持将 Lua 脚本运行在沙盒模式下，以限制其访问和执行权限。在沙盒模式下，脚本无法执行危险操作，如文件访问。
监控日志： 记录 Redis 执行 Lua 脚本的相关信息，包括谁执行了脚本以及执行的脚本内容。这有助于跟踪执行情况并发现潜在的安全问题。
总之，处理 Lua 脚本中的错误和确保安全性是非常重要的。通过适当的错误处理和安全措施，你可以确保 Lua 脚本在与 Redis 交互时不会引入潜在的问题，并提高应用程序的稳定性和安全性。
第七部分：最佳实践和建议
在 Spring Boot 项目中成功使用 Lua 脚本来实现 Redis 功能，以下是一些最佳实践和建议：
维护文档和注释：
- 保持 Lua 脚本和相关代码的文档和注释清晰明了。这有助于其他开发人员理解脚本的目的和用法。
参数验证：
- 始终验证传递给 Lua 脚本的参数。确保它们是合法的、安全的，并不包含恶意代码。
白名单：
- 如果可能，建议创建一个白名单，只允许执行经过审核的脚本。这有助于防止执行未经授权的脚本。
错误处理：
- 针对 Lua 脚本的执行，实施恰当的错误处理机制。捕获和处理执行期间可能出现的异常，以便记录错误信息或采取适当的措施。
测试：
- 在实际应用之前，务必对 Lua 脚本进行彻底的单元测试。确保脚本按预期执行，并在各种情况下具有预期的行为。
权限控制：
- 在 Redis 服务器上实施适当的权限控制，限制对 Lua 脚本的执行。只允许授权用户或应用程序执行脚本，并避免执行危险操作。
性能优化：
- 使用 Lua 脚本来减少网络开销，执行原子操作，处理复杂操作以提高性能。确保脚本有效地减少了与 Redis 服务器的交互次数。
版本管理：
- 对 Lua 脚本实施版本管理，以便能够轻松地追踪和回滚脚本的更改。
监控和日志：
- 在 Redis 执行 Lua 脚本时，记录相关信息并监控执行情况。这有助于跟踪性能和安全问题。
备份方案：
- 针对关键操作，考虑实现备份和容错方案，以防止脚本执行失败或 Redis 故障。
合理使用 Lua 脚本：
- Lua 脚本是一种强大的工具，但不应该被滥用。只在需要原子性、性能优化或复杂操作时使用它。
学习 Lua 编程：
- 如果你不熟悉 Lua 编程语言，建议学习 Lua 的基础知识，以便更好地编写和理解 Lua 脚本。
通过遵循这些最佳实践和建议，你可以更安全、高效地使用 Lua 脚本来实现 Redis 功能，并确保你的 Spring Boot 项目与 Redis 的交互是可靠和可维护的。