在Golang中使用Redis_golang redis eval

1. 初识 go-redis

Redis官方推荐使用的Golang客户端是go-redis，此客户端也是github上目前最受欢迎的Golang版本客户端。

自行查阅相关文档了解go-redis。推荐阅读列表：

1. 为什么选择go-redis？
2. 新手如何入门？
3. 如何批量执行命令？
4. go-redis文档

注意：本文档只介绍常见用法，一些特殊的用法请参考官方文档。

2. 基础用法

2.1. 连接Redis服务器

使用NewClient创建一个Redis客户端：

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

rdb := redis.NewClient(&redis.Options{
    Addr:       "localhost:6379",
    Password:   "", // no password set
    DB:         0,  // use default DB
})
1
2
3
4
5
6
7

注意；此处创建一个了Redis客户端实例，go-redis会自动维护连接池，在执行命令时自动连接服务器，无需我们手动建立或者关闭连接。

其他连接方式自行参考官方文档。

2.2. 执行普通命令

使用客户端执行已经封装好的命令：

val, err := rdb.Get(ctx, "key").Result()
if err != nil {
    fmt.Println("exec cmd failed:", err.Error())
}
fmt.Println(val)
1
2
3
4
5

或者暂存命令对象，稍后再获取命令返回数据和错误信息：

get := rdb.Get(ctx, "key")
fmt.Println(get.Val(), get.Err())
1
2

客户端支持的命令请参考Redis客户端定义。

2.3. 执行自定义命令

使用客户端执行自定义命令：

val, err := rdb.Do(ctx, "get", "key").Result()
if err != nil {
    if err == redis.Nil {
        fmt.Println("key does not exists")
        return
    }
    panic(err)
}
fmt.Println(val.(string))
1
2
3
4
5
6
7
8
9

Do方法返回一个Cmd对象，除了可以使用Result()方法返回interface{}对象，还可以使用其他方法转换结果类型：

s, err := cmd.Text()
flag, err := cmd.Bool()

num, err := cmd.Int()
num, err := cmd.Int64()
num, err := cmd.Uint64()
num, err := cmd.Float32()
num, err := cmd.Float64()

ss, err := cmd.StringSlice()
ns, err := cmd.Int64Slice()
ns, err := cmd.Uint64Slice()
fs, err := cmd.Float32Slice()
fs, err := cmd.Float64Slice()
bs, err := cmd.BoolSlice()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.4. 处理返回(nil)情况

执行部分命令时，服务器可能会返回(nil)，可以通过redis.Nil来判断：

val, err := rdb.Get(ctx, "key").Result()
switch {
case err == redis.Nil:
    fmt.Println("key does not exist")
case err != nil:
    fmt.Println("Get failed", err)
case val == "":
    fmt.Println("value is empty")
}
1
2
3
4
5
6
7
8
9

下列命令可能会返回(nil)：

• get
• blpop
• zscore

2.5. 使用单个客户端连接

在某些特殊的场景下，用户可能不希望使用连接池，希望直接使用一个独立的连接，可以使用Conn方法来获取：

cn := rdb.Conn(ctx)
defer cn.Close()

if err := cn.ClientSetName(ctx, "myclient").Err(); err != nil {
    panic(err)
}

name, err := cn.ClientGetName(ctx).Result()
if err != nil {
    panic(err)
}
fmt.Println("client name", name)
1
2
3
4
5
6
7
8
9
10
11
12

2.6. 批量执行命令

当你需要一次性执行多条命令时，可以使用Pipeline来一次性发送多条命令到服务器去执行：

pipe := rdb.Pipeline()

incr := pipe.Incr(ctx, "pipeline_counter")
pipe.Expire(ctx, "pipeline_counter", time.Hour)

cmds, err := pipe.Exec(ctx)
if err != nil {
    panic(err)
}

// The value is available only after Exec is called.
fmt.Println(incr.Val())
1
2
3
4
5
6
7
8
9
10
11
12

或者使用Pipelined方法按指令存储对应执行结果：

var incr *redis.IntCmd

cmds, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
    incr = pipe.Incr(ctx, "pipelined_counter")
    pipe.Expire(ctx, "pipelined_counter", time.Hour)
    return nil
})
if err != nil {
    panic(err)
}

// The value is available only after the pipeline is executed.
fmt.Println(incr.Val())
1
2
3
4
5
6
7
8
9
10
11
12
13

也可以遍历Pipelined方法返回的命令列表来获取命令执行结果：

cmds, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
    for i := 0; i < 100; i++ {
        pipe.Get(ctx, fmt.Sprintf("key%d", i))
    }
    return nil
})
if err != nil {
    panic(err)
}

for _, cmd := range cmds {
    fmt.Println(cmd.(*redis.StringCmd).Val())
}
1
2
3
4
5
6
7
8
9
10
11
12
13