Golang 操作 Redis：eval/functions 执行 lua script 脚本操作用法 - go-redis 使用指南

在上一篇文章中，我们探讨了 Redis 的 Pipeline 操作及其在高效处理大量命令时的应用。今天，我们将深入了解 Redis 的脚本功能，包括如何在 Go 语言中使用 go-redis 库执行脚本。我们将介绍 Redis 的脚本功能、eval 和 function 操作的常见场景，并详细讲解 go-redis 中相关的方法及示例代码。

👉 点击查看 go-redis 使用指南目录

在《go-redis 使用指南》系列文章中，我们将详细介绍如何在 Golang 项目中使用 redis/go-redis 库与 Redis 进行交互。以下是该系列文章的全部内容：

Redis script 脚本操作：eval 和 function 简介

Redis 提供了强大的脚本功能，允许用户使用 Lua 脚本在 Redis 服务器端执行复杂的操作。这些脚本可以大大简化客户端与 Redis 之间的数据交换，并提升操作效率。Redis 的脚本功能主要包括两大类：eval 和 function。

eval: 允许用户直接在 Redis 服务器上执行 Lua 脚本。它支持多种操作，如对数据进行计算、更新或条件判断。
function: 从 Redis 7.0 开始引入的功能，允许用户定义和使用更复杂的 Lua 函数。这些函数可以被加载到 Redis 服务器中，并用于执行复杂的操作。

Redis script 脚本使用场景

eval:
- 执行复杂的原子操作，避免多次网络往返。
- 处理需要服务器端逻辑的数据更新和计算。
- 快速实现特定逻辑而无需在客户端实现。
function:
- 定义可重用的服务器端函数，提高脚本执行的灵活性。
- 支持脚本的版本管理和异步处理。

go-redis 中 script 操作的方法

以下是 go-redis 提供的与 script 相关的操作方法：

Eval - 执行 Lua 脚本
EvalSha - 根据脚本的 SHA1 值执行 Lua 脚本
EvalRO - 执行只读的 Lua 脚本（需要 Redis 7.0 以上版本）
EvalShaRO - 根据 SHA1 值执行只读的 Lua 脚本（需要 Redis 7.0 以上版本）
ScriptExists - 检查脚本是否已经存在于 Redis 中
ScriptFlush - 清除所有脚本缓存
ScriptKill - 杀死当前正在执行的脚本
ScriptLoad - 将脚本加载到 Redis 并返回 SHA1 值
FunctionLoad - 加载 Redis Function
FunctionLoadReplace - 替换已存在的 Redis Function
FunctionDelete - 删除指定的 Redis Function
FunctionFlush - 清除所有已加载的 Redis Functions
FunctionKill - 杀死当前正在执行的 Function
FunctionFlushAsync - 异步清除 Redis Functions
FunctionList - 列出当前所有加载的 Redis Functions
FunctionDump - 导出 Redis Functions
FunctionRestore - 恢复导出的 Redis Functions
FunctionStats - 获取 Redis Functions 的统计信息
FCall - 执行指定的 Redis Function
FCallRo - 执行只读的 Redis Function

go-redis script 操作方法详细讲解及示例代码

go-redis Eval 脚本操作示例代码

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/redis/go-redis/v9"
)

func main() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6380",
	})

	// 清除所有脚本缓存
	if _, err := rdb.ScriptFlush(ctx).Result(); err != nil {
		log.Fatalf("Error flushing scripts: %v", err)
	}

	// 设置初始键值
	rdb.Set(ctx, "key1", 10, 0)
	rdb.Set(ctx, "key2", 20, 0)

	// Lua 脚本，计算两个键值的和并返回
	script := `
    local val1 = redis.call("GET", KEYS[1])
    local val2 = redis.call("GET", KEYS[2])
    val1 = tonumber(val1) or 0
    val2 = tonumber(val2) or 0
    return val1 + val2
    `
	keys := []string{"key1", "key2"}
	args := []interface{}{}

	// 将脚本加载到 Redis 并获取 SHA1 值
	sha1, err := rdb.ScriptLoad(ctx, script).Result()
	if err != nil {
		log.Fatalf("Error loading script: %v", err)
	}
	fmt.Printf("Loaded script SHA1: %s\n", sha1)

	// 检查脚本是否已经存在
	exists, err := rdb.ScriptExists(ctx, sha1).Result()
	if err != nil || !exists[0] {
		log.Fatalf("Script does not exist: %v", err)
	}
	fmt.Println("Script exists in Redis")

	// 执行脚本
	result, err := rdb.Eval(ctx, script, keys, args...).Result()
	if err != nil {
		log.Fatalf("Error executing script: %v", err)
	}
	fmt.Printf("Result of Eval: %v\n", result)

	// 根据 SHA1 值执行脚本
	resultSha, err := rdb.EvalSha(ctx, sha1, keys, args...).Result()
	if err != nil {
		log.Fatalf("Error executing script by SHA1: %v", err)
	}
	fmt.Printf("Result of EvalSha: %v\n", resultSha)

	// 执行只读的 Lua 脚本 (需要 Redis 7.0 以上)
	resultRO, err := rdb.EvalRO(ctx, script, keys, args...).Result()
	if err != nil {
		log.Fatalf("Error executing read-only script: %v", err)
	}
	fmt.Printf("Result of EvalRO: %v\n", resultRO)

	// 根据 SHA1 值执行只读的 Lua 脚本 (需要 Redis 7.0 以上)
	resultShaRO, err := rdb.EvalShaRO(ctx, sha1, keys, args...).Result()
	if err != nil {
		log.Fatalf("Error executing read-only script by SHA1: %v", err)
	}
	fmt.Printf("Result of EvalShaRO: %v\n", resultShaRO)

	// 杀死当前正在执行的脚本（若有）
	if err := rdb.ScriptKill(ctx).Err(); err != nil && err != redis.Nil {
		log.Fatalf("Error killing script: %v", err)
	}
	fmt.Println("Killed running script (if any)")
}

执行代码，输出：

Loaded script SHA1: 4f542ba45ede2410735a8a396120ade717f1a142
Script exists in Redis
Result of Eval: 30
Result of EvalSha: 30
Result of EvalRO: 30
Result of EvalShaRO: 30
2024/08/26 18:27:49 Error killing script: NOTBUSY No scripts in execution right now.
exit status 1

go-redis Function 脚本操作示例代码

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/redis/go-redis/v9"
)

func main() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6380",
	})

	// 清除所有已加载的 Redis Functions
	if _, err := rdb.FunctionFlush(ctx).Result(); err != nil {
		log.Fatalf("Error flushing functions: %v", err)
	}

	// 加载一个纯读取操作的 Redis Function
	functionCode := `#!lua name=mylib
    redis.register_function('get_sum', function(keys, args)
        local sum = 0
        for i, key in ipairs(keys) do
            sum = sum + tonumber(redis.call("GET", key))
        end
        return sum
    end)
    `
	if _, err := rdb.FunctionLoad(ctx, functionCode).Result(); err != nil {
		log.Fatalf("Error loading function: %v", err)
	}
	fmt.Println("Function 'get_sum' loaded successfully")

	// 列出所有已加载的 Redis Functions
	functions, err := rdb.FunctionList(ctx, redis.FunctionListQuery{}).Result()
	if err != nil {
		log.Fatalf("Error listing functions: %v", err)
	}
	fmt.Printf("Loaded functions: %v\n", functions)

	// 执行加载的 Redis Function
	result, err := rdb.FCall(ctx, "get_sum", []string{"key1", "key2"}).Result()
	if err != nil {
		log.Fatalf("Error executing function: %v", err)
	}
	fmt.Printf("Result of FCall 'get_sum': %v\n", result)

	// 替换已存在的 Redis Function
	newFunctionCode := `#!lua name=mylib
    redis.register_function('get_sum', function(keys, args)
        return "xxx"
    end)
    `
	if _, err := rdb.FunctionLoadReplace(ctx, newFunctionCode).Result(); err != nil {
		log.Fatalf("Error replacing function: %v", err)
	}
	fmt.Println("Function 'get_sum' replaced successfully")

	// 导出 Redis Functions
	dump, err := rdb.FunctionDump(ctx).Result()
	if err != nil {
		log.Fatalf("Error dumping functions: %v", err)
	}
	fmt.Println("Functions dumped successfully")

	// 删除 Redis Function
	if _, err := rdb.FunctionDelete(ctx, "mylib").Result(); err != nil {
		log.Fatalf("Error deleting function: %v", err)
	}
	fmt.Println("Function 'get_sum' deleted successfully")

	// 异步清除 Redis Functions
	if _, err := rdb.FunctionFlushAsync(ctx).Result(); err != nil {
		log.Fatalf("Error flushing functions asynchronously: %v", err)
	}
	fmt.Println("Functions flushed asynchronously")

	// 恢复导出的 Redis Functions
	if _, err := rdb.FunctionRestore(ctx, dump).Result(); err != nil {
		log.Fatalf("Error restoring functions: %v", err)
	}
	fmt.Println("Functions restored successfully")

	// 获取 Redis Functions 的统计信息
	stats, err := rdb.FunctionStats(ctx).Result()
	if err != nil {
		log.Fatalf("Error getting function stats: %v", err)
	}
	fmt.Printf("Function stats: %v\n", stats)

	// 杀死当前正在执行的 Function（若有）
	if err := rdb.FunctionKill(ctx).Err(); err != nil && err != redis.Nil {
		log.Fatalf("Error killing function: %v", err)
	}
	fmt.Println("Killed running function (if any)")
}

执行代码，输出结果：

Function 'get_sum' loaded successfully
Loaded functions: [{mylib LUA [{get_sum  []}] }]
Result of FCall 'get_sum': 30
Function 'get_sum' replaced successfully
Functions dumped successfully
Function 'get_sum' deleted successfully
Functions flushed asynchronously
Functions restored successfully
Function stats: {[{LUA 1 1}] false { [] 0} []}
2024/08/26 20:46:27 Error killing function: NOTBUSY No scripts in execution right now.
exit status 1