Go 操作 Redis

吴佳浩2023-11-20 15:11

Go语言操作Redis

在项目开发中redis的使用也比较频繁，本文介绍了Go语言中go-redis库的基本使用。

Redis介绍

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

Redis使用一种简单而高效的文本协议与客户端进行通信，该协议被称为Redis网络协议或RESP（Redis Serialization Protocol）。 RESP是一种直观的协议，它以行为单位进行通信，并且通过不同的数据类型和前缀来表示不同的指令和数据。

RESP协议的主要特点如下：

  1. 简单性：RESP协议的设计非常简单，易于实现和理解。它使用纯文本格式进行通信，每个指令和数据以换行符（\r\n）分隔。
  2. 支持不同的数据类型：RESP协议支持多种数据类型，包括字符串（Simple String）、错误信息（Error）、整数（Integer）、批量字符串（Bulk String）和数组（Array）。
  3. 基于请求-响应模型：客户端向Redis发送请求，Redis返回相应的响应。请求和响应之间使用简单的消息结构进行交互。

RESP协议的基本规则如下：

  • 简单字符串（Simple String）：以"+"字符开头，后面跟着字符串内容。例如，"+OK\r\n"表示一个简单字符串响应，内容为"OK"。
  • 错误信息（Error）：以"-"字符开头，后面跟着错误消息。例如，"-Error occurred\r\n"表示一个错误响应，内容为"Error occurred"。
  • 整数（Integer）：以":"字符开头，后面跟着整数值。例如，":42\r\n"表示一个整数响应，值为42。
  • 批量字符串（Bulk String）：以" <math xmlns="http://www.w3.org/1998/Math/MathML"> " 字符开头，后面跟着字符串长度和换行符，然后是字符串内容和换行符。例如， " "字符开头，后面跟着字符串长度和换行符，然后是字符串内容和换行符。例如，" </math>"字符开头，后面跟着字符串长度和换行符，然后是字符串内容和换行符。例如，"5\r\nHello\r\n"表示一个长度为5的批量字符串，内容为"Hello"。
  • 数组（Array）：以"*"字符开头，后面跟着数组元素的数量和换行符，然后是数组中的每个元素。例如，"*3\r\n$5\r\nHello\r\n:42\r\n-Error\r\n"表示一个包含3个元素的数组，分别是批量字符串"Hello"、整数42和错误信息"Error"。

RESP协议以文本形式提供了一种与Redis进行通信的简单方式。它使得客户端可以通过发送相应的指令并解析Redis的响应来与Redis进行交互。

需要注意的是，RESP协议是一种底层协议，对于常规的Redis操作，通常建议使用Redis客户端库，这些库提供了高级的抽象和功能，使得与Redis的交互更加方便和易于使用

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示例：

docker 复制代码 
docker run --name redis507 -p 6379:6379 -d redis:5.0.7

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

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

Linux 复制代码 
docker run -it --network host --rm redis:5.0.7 redis-cli

go-redis库

安装

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

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

go 复制代码 
go get -u github.com/go-redis/redis

连接

普通连接

go 复制代码 
// 声明一个全局的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
}

注意： 最新版本下Ping()可能需要传递context.Context参数，例如：

go 复制代码 
rdb.Ping(context.TODO())

连接Redis哨兵模式

go 复制代码 
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集群

go 复制代码 
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
}

基本使用

set/get示例

go 复制代码 
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示例

go 复制代码 
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)
	}
}

输出结果如下：

linux 复制代码 
$ ./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

Pipeline

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

Pipeline 基本示例如下：

go 复制代码 
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。

Linux 复制代码 
INCR pipeline_counter
EXPIRE pipeline_counts 3600

也可以使用Pipelined：

go 复制代码 
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包裹排队的命令。例如：

go 复制代码 
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命令：

sql 复制代码 
MULTI
INCR pipeline_counter
EXPIRE pipeline_counts 3600
EXEC

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

go 复制代码 
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的时候，事务将失败并返回一个错误，用户可以根据这个错误选择重试事务或者放弃事务。

go 复制代码 
Watch(fn func(*Tx) error, keys ...string) error

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

go 复制代码 
// 监视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)

最后看一个官方文档中使用GET和SET命令以事务方式递增Key的值的示例：

go 复制代码 
const routineCount = 100

increment := func(key string) error {
	txf := func(tx *redis.Tx) error {
		// 获得当前值或零值
		n, err := tx.Get(key).Int()
		if err != nil && err != redis.Nil {
			return err
		}

		// 实际操作（乐观锁定中的本地操作）
		n++

		// 仅在监视的Key保持不变的情况下运行
		_, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
			// pipe 处理错误情况
			pipe.Set(key, n, 0)
			return nil
		})
		return err
	}

	for retries := routineCount; retries > 0; retries-- {
		err := rdb.Watch(txf, key)
		if err != redis.TxFailedErr {
			return err
		}
		// 乐观锁丢失
	}
	return errors.New("increment reached maximum number of retries")
}

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("counter3").Int()
fmt.Println("ended with", n, err)

更多详情请查阅文档。

原文地址：也是我自己写的<Go语言操作Redis>

相关推荐
煎鱼eddycjy15 小时前
新提案：由迭代器启发的 Go 错误函数处理
go
煎鱼eddycjy15 小时前
Go 语言十五周年！权力交接、回顾与展望
go
不爱说话郭德纲1 天前
聚焦 Go 语言框架，探索创新实践过程
go·编程语言
进击的松鼠2 天前
【Nuxt 实战】02-集成 Pinia、新增导航栏、暗黑模式
前端·全栈·nuxt.js
不爱学习的YY酱2 天前
【Linux】＜共享内存应用＞——模拟实现不同进程把hello字符对＜共享内存文件对象＞的放入和取出操作
linux·数据库·nosql
0x派大星2 天前
【Golang】——Gin 框架中的 API 请求处理与 JSON 数据绑定
开发语言·后端·golang·go·json·gin
IT书架3 天前
golang高频面试真题
面试·go
郝同学的测开笔记3 天前
云原生探索系列(十四)：Go 语言panic、defer以及recover函数
后端·云原生·go
秋落风声3 天前
【滑动窗口入门篇】
java·算法·leetcode·go·哈希表
Kika写代码4 天前
【Hadoop】【大数据技术基础】实践三 NoSQL数据库 大数据基础编程、实验和案例教程（第2版）
大数据·hadoop·nosql
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇