脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Golang - golang连接redis库及基本操作示例过程

golang连接redis库及基本操作示例过程

2022-09-15 13:52Jeff的技术栈 Golang

这篇文章主要介绍了golang连接redis库及基本操作示例过程，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪

Redis介绍

Redis是一个开源的内存数据库，Redis提供了多种不同类型的数据结构，很多业务场景下的问题都可以很自然地映射到这些数据结构上。除此之外，通过复制、持久化和客户端分片等特性，我们可以很方便地将Redis扩展成一个能够包含数百GB数据、每秒处理上百万次请求的系统。

Redis支持的数据结构

Redis支持诸如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、带范围查询的排序集合（sorted sets）、位图（bitmaps）、hyperloglogs、带半径查询和流的地理空间索引等数据结构（geospatial indexes）。

Redis应用场景

  • 缓存系统，减轻主数据库（MySQL）的压力。
  • 计数场景，比如微博、抖音中的关注数和粉丝数。
  • 热门排行榜，需要排序的场景特别适合使用ZSET。
  • 利用LIST可以实现队列的功能。

准备Redis环境

这里直接使用Docker启动一个redis环境，方便学习使用。

docker启动一个名为redis507的5.0.7版本的redis server示例：

?
1
docker run --name redis507 -p 6379:6379 -d redis:5.0.7

注意：此处的版本、容器名和端口号请根据自己需要设置。

启动一个redis-cli连接上面的redis server:

?
1
docker run -it --network host --rm redis:5.0.7 redis-cli

go-redis库

安装

区别于另一个比较常用的Go语言redis client库：redigo，我们这里采用https://github.com/go-redis/redis连接Redis数据库并进行操作，因为go-redis支持连接哨兵及集群模式的Redis。

使用以下命令下载并安装:

?
1
go get -u github.com/go-redis/redis

连接

普通连接

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 声明一个全局的rdb变量
var rdb *redis.Client
// 初始化连接
func initClient() (err error) {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

V8新版本相关

最新版本的go-redis库的相关命令都需要传递context.Context参数，例如：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package main
import (
    "context"
    "fmt"
    "time"
    "github.com/go-redis/redis/v8" // 注意导入的是新版本
)
var (
    rdb *redis.Client
)
// 初始化连接
func initClient() (err error) {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "localhost:16379",
        Password: "",  // no password set
        DB:       0,   // use default DB
        PoolSize: 100, // 连接池大小
    })
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    _, err = rdb.Ping(ctx).Result()
    return err
}
func V8Example() {
    ctx := context.Background()
    if err := initClient(); err != nil {
        return
    }
 
    err := rdb.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        panic(err)
    }
 
    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val)
    val2, err := rdb.Get(ctx, "key2").Result()
    if err == redis.Nil {
        fmt.Println("key2 does not exist")
    } else if err != nil {
        panic(err)
    } else {
        fmt.Println("key2", val2)
    }
    // Output: key value
    // key2 does not exist
}

连接Redis哨兵模式

?
1
2
3
4
5
6
7
8
9
10
11
func initClient()(err error){
    rdb := redis.NewFailoverClient(&redis.FailoverOptions{
        MasterName:    "master",
        SentinelAddrs: []string{"x.x.x.x:26379", "xx.xx.xx.xx:26379", "xxx.xxx.xxx.xxx:26379"},
    })
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

连接Redis集群

?
1
2
3
4
5
6
7
8
9
10
func initClient()(err error){
    rdb := redis.NewClusterClient(&redis.ClusterOptions{
        Addrs: []string{":7000", ":7001", ":7002", ":7003", ":7004", ":7005"},
    })
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}

基本使用

HVals

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main
import (
    "fmt"
    "github.com/go-redis/redis"
    "reflect"
)
var rdb *redis.Client
// 初始化连接
func initClient() (err error) {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "10.0.3.100:6379",
        Password: "EfcHGSzKqg6cfzWq", // no password set
        DB:       8,  // use default DB
    })
 
    _, err = rdb.Ping().Result()
    if err != nil {
        return err
    }
    return nil
}
func main() {
    err:=initClient()
    if err != nil {
        fmt.Println(err)
    }
    value,err2 := rdb.HVals("toutiao_web_gt100").Result()
    if err2 != nil {
        fmt.Println(err2)
    }
    fmt.Println(reflect.TypeOf(value))
    fmt.Println(len(value))
    for i,j:=0,len(value);i<j;i++{
        fmt.Println(value[i])
    }
}

set/get示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
func redisExample() {
    err := rdb.Set("score", 100, 0).Err()
    if err != nil {
        fmt.Printf("set score failed, err:%v\n", err)
        return
    }
    val, err := rdb.Get("score").Result()
    if err != nil {
        fmt.Printf("get score failed, err:%v\n", err)
        return
    }
    fmt.Println("score", val)
    val2, err := rdb.Get("name").Result()
    if err == redis.Nil {
        fmt.Println("name does not exist")
    } else if err != nil {
        fmt.Printf("get name failed, err:%v\n", err)
        return
    } else {
        fmt.Println("name", val2)
    }
}

zset示例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
func redisExample2() {
    zsetKey := "language_rank"
    languages := []redis.Z{
        redis.Z{Score: 90.0, Member: "Golang"},
        redis.Z{Score: 98.0, Member: "Java"},
        redis.Z{Score: 95.0, Member: "Python"},
        redis.Z{Score: 97.0, Member: "JavaScript"},
        redis.Z{Score: 99.0, Member: "C/C++"},
    }
    // ZADD
    num, err := rdb.ZAdd(zsetKey, languages...).Result()
    if err != nil {
        fmt.Printf("zadd failed, err:%v\n", err)
        return
    }
    fmt.Printf("zadd %d succ.\n", num)
 
    // 把Golang的分数加10
    newScore, err := rdb.ZIncrBy(zsetKey, 10.0, "Golang").Result()
    if err != nil {
        fmt.Printf("zincrby failed, err:%v\n", err)
        return
    }
    fmt.Printf("Golang's score is %f now.\n", newScore)
 
    // 取分数最高的3个
    ret, err := rdb.ZRevRangeWithScores(zsetKey, 0, 2).Result()
    if err != nil {
        fmt.Printf("zrevrange failed, err:%v\n", err)
        return
    }
    for _, z := range ret {
        fmt.Println(z.Member, z.Score)
    }
 
    // 取95~100分的
    op := redis.ZRangeBy{
        Min: "95",
        Max: "100",
    }
    ret, err = rdb.ZRangeByScoreWithScores(zsetKey, op).Result()
    if err != nil {
        fmt.Printf("zrangebyscore failed, err:%v\n", err)
        return
    }
    for _, z := range ret {
        fmt.Println(z.Member, z.Score)
    }
}

输出结果如下：

?
1
2
3
4
5
6
7
8
9
10
$ ./06redis_demo
zadd 0 succ.
Golang's score is 100.000000 now.
Golang 100
C/C++ 99
Java 98
JavaScript 97
Java 98
C/C++ 99
Golang 100

根据前缀获取Key

?
1
vals, err := rdb.Keys(ctx, "prefix*").Result()

执行自定义命令

?
1
res, err := rdb.Do(ctx, "set", "key", "value").Result()

按通配符删除key

当通配符匹配的key的数量不多时，可以使用Keys()得到所有的key在使用Del命令删除。 如果key的数量非常多的时候，我们可以搭配使用Scan命令和Del命令完成删除。

?
1
2
3
4
5
6
7
8
9
10
11
ctx := context.Background()
iter := rdb.Scan(ctx, 0, "prefix*", 0).Iterator()
for iter.Next(ctx) {
    err := rdb.Del(ctx, iter.Val()).Err()
    if err != nil {
        panic(err)
    }
}
if err := iter.Err(); err != nil {
    panic(err)
}

Pipeline

Pipeline 主要是一种网络优化。它本质上意味着客户端缓冲一堆命令并一次性将它们发送到服务器。这些命令不能保证在事务中执行。这样做的好处是节省了每个命令的网络往返时间（RTT）。

Pipeline 基本示例如下：

?
1
2
3
4
5
pipe := rdb.Pipeline()
incr := pipe.Incr("pipeline_counter")
pipe.Expire("pipeline_counter", time.Hour)
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)

上面的代码相当于将以下两个命令一次发给redis server端执行，与不使用Pipeline相比能减少一次RTT。

?
1
2
INCR pipeline_counter
EXPIRE pipeline_counts 3600

也可以使用Pipelined：

?
1
2
3
4
5
6
7
var incr *redis.IntCmd
_, err := rdb.Pipelined(func(pipe redis.Pipeliner) error {
    incr = pipe.Incr("pipelined_counter")
    pipe.Expire("pipelined_counter", time.Hour)
    return nil
})
fmt.Println(incr.Val(), err)

在某些场景下，当我们有多条命令要执行时，就可以考虑使用pipeline来优化。

事务

Redis是单线程的，因此单个命令始终是原子的，但是来自不同客户端的两个给定命令可以依次执行，例如在它们之间交替执行。但是，Multi/exec能够确保在multi/exec两个语句之间的命令之间没有其他客户端正在执行命令。

在这种场景我们需要使用TxPipeline。TxPipeline总体上类似于上面的Pipeline，但是它内部会使用MULTI/EXEC包裹排队的命令。例如：

?
1
2
3
4
5
pipe := rdb.TxPipeline()
incr := pipe.Incr("tx_pipeline_counter")
pipe.Expire("tx_pipeline_counter", time.Hour)
_, err := pipe.Exec()
fmt.Println(incr.Val(), err)

上面代码相当于在一个RTT下执行了下面的redis命令：

?
1
2
3
4
MULTI
INCR pipeline_counter
EXPIRE pipeline_counts 3600
EXEC

还有一个与上文类似的TxPipelined方法，使用方法如下：

?
1
2
3
4
5
6
7
var incr *redis.IntCmd
_, err := rdb.TxPipelined(func(pipe redis.Pipeliner) error {
    incr = pipe.Incr("tx_pipelined_counter")
    pipe.Expire("tx_pipelined_counter", time.Hour)
    return nil
})
fmt.Println(incr.Val(), err)

Watch

在某些场景下，我们除了要使用MULTI/EXEC命令外，还需要配合使用WATCH命令。在用户使用WATCH命令监视某个键之后，直到该用户执行EXEC命令的这段时间里，如果有其他用户抢先对被监视的键进行了替换、更新、删除等操作，那么当用户尝试执行EXEC的时候，事务将失败并返回一个错误，用户可以根据这个错误选择重试事务或者放弃事务。

?
1
Watch(fn func(*Tx) error, keys ...string) error

Watch方法接收一个函数和一个或多个key作为参数。基本使用示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
// 监视watch_count的值，并在值不变的前提下将其值+1
key := "watch_count"
err = client.Watch(func(tx *redis.Tx) error {
    n, err := tx.Get(key).Int()
    if err != nil && err != redis.Nil {
        return err
    }
    _, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
        pipe.Set(key, n+1, 0)
        return nil
    })
    return err
}, key)

最后看一个V8版本官方文档中使用GET和SET命令以事务方式递增Key的值的示例，仅当Key的值不发生变化时提交一个事务。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
func transactionDemo() {
    var (
        maxRetries   = 1000
        routineCount = 10
    )
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    // Increment 使用GET和SET命令以事务方式递增Key的值
    increment := func(key string) error {
        // 事务函数
        txf := func(tx *redis.Tx) error {
            // 获得key的当前值或零值
            n, err := tx.Get(ctx, key).Int()
            if err != nil && err != redis.Nil {
                return err
            }
            // 实际的操作代码（乐观锁定中的本地操作）
            n++
            // 操作仅在 Watch 的 Key 没发生变化的情况下提交
            _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
                pipe.Set(ctx, key, n, 0)
                return nil
            })
            return err
        }
        // 最多重试 maxRetries 次
        for i := 0; i < maxRetries; i++ {
            err := rdb.Watch(ctx, txf, key)
            if err == nil {
                // 成功
                return nil
            }
            if err == redis.TxFailedErr {
                // 乐观锁丢失 重试
                continue
            }
            // 返回其他的错误
            return err
        }
        return errors.New("increment reached maximum number of retries")
    }
    // 模拟 routineCount 个并发同时去修改 counter3 的值
    var wg sync.WaitGroup
    wg.Add(routineCount)
    for i := 0; i < routineCount; i++ {
        go func() {
            defer wg.Done()
            if err := increment("counter3"); err != nil {
                fmt.Println("increment error:", err)
            }
        }()
    }
    wg.Wait()
    n, err := rdb.Get(context.TODO(), "counter3").Int()
    fmt.Println("ended with", n, err)
}

以上就是golang连接redis库及基本操作示例过程的详细内容，更多关于golang连接redis库操作过程的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/guyouyin123/p/14481650.html

  • 连接
  • golang
  • redis

    • 延伸 · 阅读

    精彩推荐
    • Golang浅谈golang结构体偷懒初始化

      浅谈golang结构体偷懒初始化

      这篇文章主要介绍了浅谈golang结构体偷懒初始化，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧...

      渔舟唱晚_hanpan12662021-03-08
    • GolangGo语言展现快速排序算法全过程的思路及代码示例

      Go语言展现快速排序算法全过程的思路及代码示例

      这篇文章主要介绍了Go语言展现快速排序算法全过程的思路及代码示例,文章最后作者还提到了对Quick Sort算法优化的一些想法,需要的朋友可以参考下 ...

      荆榆3602020-04-29
    • Golanggolang中struct和[]byte的相互转换示例

      golang中struct和[]byte的相互转换示例

      这篇文章主要介绍了golang中struct和[]byte的相互转换示例,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧 ...

      稳健明6142020-05-17
    • Golang在Golang中使用C语言代码实例

      在Golang中使用C语言代码实例

      这篇文章主要介绍了在Golang中使用C语言代码实例,本文先是给出了一个Hello World例子、Golang 引用 C例子,并总结了一些要注意的地方,需要的朋友可以参考下...

      Golang教程网3222019-11-17
    • GolangGolang空结构体struct{}用途,你知道吗

      Golang空结构体struct{}用途,你知道吗

      这篇文章主要介绍了Golang空结构体struct{}用途,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着...

      罗奇正6332021-03-26
    • GolangGo泛型：提前掌握Go泛型的基本使用

      Go泛型：提前掌握Go泛型的基本使用

      泛型，是 Go 语言多年来最令人兴奋和根本性的变化之一。没有泛型，很多人以此「鄙视」Go 语言。当然，也有人觉得根本不需要泛型。有泛型，不代表你一...

      polarisxu9192021-09-30
    • GolangGO语言gin框架实现管理员认证登陆接口

      GO语言gin框架实现管理员认证登陆接口

      这篇文章主要介绍了GO语言gin框架实现管理员认证登陆接口,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参...

      陶士涵9222021-01-31
    • Golang选择 Go API 框架时要考虑的四件事

      选择 Go API 框架时要考虑的四件事

      虽然我不会在这篇文章中比较或推荐任何特定的框架，但我将尝试通过介绍为 Go 中的下一个 API 项目选择框架时应该考虑的四个关键事项给你参考。...

      幽鬼7842021-12-03
    最近更新
    编辑推荐
    阅读排行
    热门标签
    信道处理 　 指针类型 　 new() 　 make() 　 并发模型 　 切片 　 静态WEB服务器 　 端口扫描器 　 Go语言入门教程 　 基础语 　 Slices 　 Maps 　 Golang编程 　 panic 　 接受者类型 　 嵌入类型 　 Slice 　 Golang教程 　 Golang项目 　 内存模型 　 开发环境搭建 　 大小端判断 　 代码组织结构 　 复合类型 　 GOPATH 　 工作目录 　 实例 　 struct类型 　 并发技术 　 buffered 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图