go-redis 框架基本使用

最新推荐文章于 2024-10-04 22:38:08 发布
最新推荐文章于 2024-10-04 22:38:08 发布
阅读量741 收藏
点赞数 2
分类专栏： Go语言 文章标签： golang redis 缓存 事务 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54015483/article/details/133035130
版权

文章目录

redis使用场景

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

下载框架和连接redis

Go 社区中目前有很多成熟的 redis client 库，比如redigo和go-redis，读者可以自行选择适合自己的库。本文章使用 go-redis 这个库来操作 Redis 数据库。

1. 安装go-redis

# redis 6
go get github.com/go-redis/redis/v8
# redis 7
go get github.com/go-redis/redis/v9

2. 连接redis

var Rdb *redis.Client

func Connect() {
	Rdb = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
		PoolSize: 10,
	})
}

字符串操作

只要Redis命令足够熟悉，那么对于这个框架的API的学习基本就没有什么问题。由于Redis命令太多，在此只列出了字符串和有序集合这两种数据类型的操作示例。

func String() {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()

	//set命令
	_, err := connect.Rdb.Set(ctx, "name", "bing", 0).Result()
	if err != nil {
		fmt.Println(err.Error())
	}
	name, err := connect.Rdb.Get(ctx, "name").Result()
	fmt.Println(name)

	//GetSet命令
	v1, _ := connect.Rdb.GetSet(ctx, "name", "xyz").Result()
	fmt.Println("旧值: " + v1) //bing
	name, err = connect.Rdb.Get(ctx, "name").Result()
	fmt.Println("新值: " + name) //xyz

	//MSet和MGet命令
	connect.Rdb.MSet(ctx, "age", 18, "password", "1234")
	v2 := connect.Rdb.MGet(ctx, "name", "age", "password").Val()
	for _, v := range v2 {
		fmt.Println(v)
	}

	//IncrBy命令
	v3 := connect.Rdb.IncrBy(ctx, "age", 2).Val() //20
	fmt.Println(v3)

	//append命令
	connect.Rdb.Append(ctx, "password", "abc")
	v4 := connect.Rdb.Get(ctx, "password").Val() //1234abc
	fmt.Println(v4)

	//SetRange命令
	connect.Rdb.SetRange(ctx, "password", 0, "987654")
	v5 := connect.Rdb.Get(ctx, "password").Val() //987654c
	fmt.Println(v5)

	//GetRange命令
	v6 := connect.Rdb.GetRange(ctx, "password", 4, -1).Val() //54c
	fmt.Println(v6)
	v7 := connect.Rdb.Get(ctx, "password").Val() //987654c
	fmt.Println(v7)

	//StrLen命令
	v8 := connect.Rdb.StrLen(ctx, "name").Val() //3
	fmt.Println(v8)

	//获取编码方式
	v9 := connect.Rdb.ObjectEncoding(ctx, "age").Val() //int
	fmt.Println(v9)
    
    //redis.Nil的用法
	v10, err := connect.Rdb.Get(ctx, "no_existing").Result()
	if redis.Nil == err {
		fmt.Println("key不存在")
	} else if err != nil {
		fmt.Println(err.Error())
	} else {
		fmt.Println(v10)
	}
}

有序集合操作

func ZSet() {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()

	ZSetKey := "languages"
	languages := []redis.Z{
		{Score: 90, Member: "Go"},
		{Score: 85, Member: "Python"},
		{Score: 99, Member: "C"},
		{Score: 95, Member: "Java"},
		{Score: 99, Member: "Rust"},
		{Score: 80, Member: "PHP"},
	}

	err := connect.Rdb.ZAdd(ctx, ZSetKey, languages...).Err()
	if err != nil {
		fmt.Println(err.Error())
	}

	//按照分数从低到高遍历
	v1 := connect.Rdb.ZRange(ctx, ZSetKey, 0, -1).Val()
	fmt.Println(v1) //[PHP Python Go Java C Rust]

	v2 := connect.Rdb.ZRangeWithScores(ctx, ZSetKey, 0, -1).Val()
	fmt.Println(v2) //[{80 PHP} {85 Python} {90 Go} {95 Java} {99 C} {99 Rust}]

	opt1 := &redis.ZRangeBy{
		Min:    "0",  //查询的最小分数值
		Max:    "95", //查询的最大分数值
		Offset: 0,    //查询的起始位置
		Count:  6,    //需要查询的元素个数
	}
	v3 := connect.Rdb.ZRangeByScoreWithScores(ctx, ZSetKey, opt1).Val()
	fmt.Println(v3) //[{80 PHP} {85 Python} {90 Go} {95 Java}]

	opt2 := &redis.ZRangeBy{
		Min:    "[K", //查询的最小字典序值
		Max:    "[X", //查询的最大字典序值
		Offset: 0,    //查询的起始位置
		Count:  5,    //需要查询的元素个数
	}
	v4 := connect.Rdb.ZRangeByLex(ctx, ZSetKey, opt2).Val()
	fmt.Println(v4) //[PHP Python Go Java C]

	v5 := connect.Rdb.ZCard(ctx, ZSetKey).Val()
	fmt.Println("集合长度: " + strconv.FormatInt(v5, 10)) // 6
}

流水线

使用流水线就是将多个执行的命令放入 pipeline 中，然后使用1次读写操作就像执行单个命令一样执行它们，就相当于把多个命令打包，然后一起发送给redis服务器，让redis服务器一次性执行完毕。这样做的好处是节省了执行命令的网络往返时间（RTT）。

注意：如果redis采用了分布式集群模式，不可以直接使用pipeline命令进行操作，因为访问的key可能并不在同一个节点上。

下面的示例代码中演示了使用 pipeline 将pipeline_counter键的值加1和设置过期时间。

func PipeLine() {
   ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
   defer cancel()

   //创建一个Pipeline对象:pipe
   pipe := connect.Rdb.Pipeline()

   //将名为"pipeline_counter"的键的值加1
   incr := pipe.Incr(ctx, "pipeline_counter")
   //设置"pipeline_counter"键的过期时间为1分钟
   pipe.Expire(ctx, "pipeline_counter", time.Minute)
   //执行所有的命令。
   _, err := pipe.Exec(ctx)
   if err != nil {
      panic(err)
   }

   // 在执行pipe.Exec之后才能获取到结果
   fmt.Println(incr.Val())
}

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

INCR pipeline_counter
EXPIRE pipeline_counts 60

或者，你也可以使用Pipelined 方法，它会在当前函数退出时调用 Exec。

func PipeLine() {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	var incr *redis.IntCmd

	cmdS, err := connect.Rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
		incr = pipe.Incr(ctx, "pipelined_counter")
		pipe.Expire(ctx, "pipelined_counter", time.Minute)
		return nil
	})
	if err != nil {
		panic(err)
	}

	// 在pipeline执行后获取到结果
	fmt.Println(incr.Val())
    
    //使用类型断言特性来对 cmd 进行类型检查
	for _, cmd := range cmdS {
		switch v := cmd.(type) {
		case *redis.StringCmd:
			fmt.Println(v.Val())
		case *redis.IntCmd:
			fmt.Println(v.Val())
		case *redis.BoolCmd:
			fmt.Println(v.Val())
		default:
			fmt.Printf("unexpected type %T\n", v)
		}
	}
}

运行结果如下：

image-20230919111235190

所以，在那些我们需要一次性执行多个命令的场景下，就可以考虑使用 pipeline 来优化。

事务

1. 普通事务

Redis 是单线程执行命令的，因此单个命令始终是原子的，但是来自不同客户端的两个给定命令可以依次执行，例如在它们之间交替执行。使用事务后，Redis会按照命令的顺序执行这些命令，并且在执行过程中不会立即返回结果，只有在所有命令都执行完毕后，才会一次性返回所有命令的执行结果。也就是在执行过程中保证了原子性，即要么所有命令都执行成功，要么所有命令都不执行。

同时，Redis事务还支持WATCH命令，可以在事务执行之前监视一个或多个键，如果在事务执行期间这些键发生了改变，事务会被中断。这样可以确保在执行事务期间，被监视的键没有被其他客户端修改。

"Tx"是"Transaction"的缩写，意为"事务”。TxPipeline 和 TxPipelined 的使用方法如下所示：

func Work() {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()

	pipe := connect.Rdb.TxPipeline()
	incr := pipe.Incr(ctx, "tx_pipeline_counter")
	pipe.Expire(ctx, "tx_pipeline_counter", time.Minute)
	_, err := pipe.Exec(ctx)
	fmt.Println(incr.Val(), err)

	var incr2 *redis.IntCmd
	_, err = connect.Rdb.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
		incr2 = pipe.Incr(ctx, "tx_pipeline_counter")
		pipe.Expire(ctx, "tx_pipeline_counter", time.Minute)
		return nil
	})
	fmt.Println(incr2.Val(), err)
}

运行结果如下：

image-20230919140331961

2. Watch

我们通常搭配 WATCH命令来执行事务操作。从使用WATCH命令监视某个 key 开始，直到执行EXEC命令的这段时间里，如果有其他用户抢先对被监视的 key 进行了替换、更新、删除等操作，那么当用户尝试执行EXEC的时候，事务将失败并返回一个错误，用户可以根据这个错误选择重试事务或者放弃事务。

Watch方法接收一个函数和一个或多个key作为参数。

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

假设我们有一个应用程序，它需要保持用户的积分。我们需要一个函数，可以安全地减少用户的积分。为了避免并发问题，我们将使用WATCH命令来监视用户的积分，并在事务中更新积分。

func WatchUserPoints(userID string, points int) error {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()

	for {
		// 监控
		err := connect.Rdb.Watch(ctx, func(tx *redis.Tx) error {
			// 得到当前用户的积分n
			n, err := tx.Get(ctx, userID).Int()

			//扣除积分时开启事务,points表示要扣除的积分
			_, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
				err := pipe.Set(ctx, userID, n-points, 0).Err()
				return err
			})
			return err
		}, userID) //监控的键为userID,也就是当这个键的值(积分)如果在事务执行过程中被其他客户端修改,那么当前事务就会执行失败。

		//对错误的判断
		if err == redis.TxFailedErr {
			//表示监视的键在事务执行过程中被其他客户端修改了，因此事务执行失败了。
			continue
		} else if err != nil {
			//其他类型的错误
			return err
		} else {
			//没有错误
			break
		}
	}
	//能够跳出循环说明一切正常
	return nil
}

这段代码的目的是监视用户的当前积分，如果在事务执行过程中，其他客户端改变了这个键的值（也就是用户的积分），那么 Watch 会发现这个变化并使得事务失败，返回 redis.TxFailedErr 错误。

总的来说，这段代码的目的是确保在减少用户积分的过程中，用户的积分没有被其他客户端修改。这是通过Redis的 WATCH 命令来实现的，这个命令可以将一个或多个键标记为监视，然后在执行事务之前检查这些键是否已经被修改。

N-1-萘乙基二胺盐酸盐
关注
专栏目录
Golang之redis中间件框架——go-redis的使用
QianLiStudent的博客
01-16 4912
写在前面       本文主要介绍操作redis数据库的框架go-redis，因此下面涉及到redis中的命令本文不做详解，下文通过使用go-redis实现go语言代码操作redis，对应命令的作用及说明请看这篇文章，里面介绍了redis各数据类型常用的一些命令。 go-redis简介     &n...
Golang go-redis cluster模式下不断创建新连接，效率下降问题解决
m0_67401228的博客
07-31 406
至于go-redis的cluster模式怎么调用，我就不多说了。在我测试集群模式下redis调用的时候发现效率不如单一节点模式。我们先复现一下问题是怎么出现的。
redis在go语言中的使用
qq_63728673的博客
02-18 2673
之前的Set方法中，最后一个参数是0，表示的就是过期时间设置，默认以秒为单位，当为0时，表示永不过期，写10，就是10s后过期，写其他单位的数字就需要加单位，如1*time.Minute就是1分钟；redis使用的是5.0.14的windows版本（正常开发项目redis都是在linux上使用，windows的redis版本很低），但基础功能都有，满足学习要求；左侧会显示key，点击后右侧会显示value的值，使用和查找起来较为方便，能够增加学习效率，当然还有很多功能，这里就不赘述。
Redis数据库与GO完结篇：redis操作总结与GO使用redis
最新发布
技术卷的博客
10-04 1210
redis操作总结与GO链接，操作redis
Go---Redis使用
weixin_47328424的博客
01-21 1677
Redis 1.Redis是NoSQL数据库，不是传统的关系型数据库 2.Redis: REmoteDlctionary Server(远程字典版务器)，Redis性能非常高，单机能够达到 15wqps，通常适合做缓存,也可以持久化。 3.是完全开源免费的，高性能的(keylvalue)分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库，是最热门的NoSql数据库之—,也称为数据结构服务器 4.Redis工作原理图 启动redis Redis的命令参数 网站Redis...
go-redis的使用(哈希类型数据)
B4ToB的博客
03-21 3195
package redisdb import ( "fmt" "github.com/go-redis/redis" // 实现了redis连接池 "tbkt/config" "tbkt/logger" "time" ) // 定义redis链接池 var client *redis.Client // 初始化...
go-redis基础使用
忆灬凝的博客
03-27 1154
GoLand中调用 package main import ( "context" "fmt" "github.com/go-redis/redis/v8" ) var ctx = context.Background() func main() { rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", Password: "", // no password set DB: 0
开源项目-go-redis-redis.zip
09-09
`go-redis` 是一个强大且易于使用的 Go 语言 Redis 客户端，提供了丰富的功能和良好的性能。对于需要在 Go 应用中集成 Redis 的开发者来说，这是一个理想的选择。特别是其对 Redis Cluster 的支持，使得在分布式环境...
【Go】go-redis使用手记
lsy1162526799的博客
11-08 639
redis工具部分封装。
redis实战——go-redis的使用与redis基础数据类型的使用场景(一)
qq_73924465的博客
08-22 889
在之前的文章我们介绍了redis的五大基础数据结构以及一些操作这些数据结构,而用原生命令在我们日常开发的过程中当然是不可能的，本文我们所要探究的就是如何基于go语言实现对redis数据库的操作以及不同的数据结构所使用的场景。
[go学习笔记.第十七章.redis的使用] 1.redis的使用
zhoupenghui168的博客
11-27 1484
redis的使用以及go怎么使用redis
用于Go的Redis兼容服务器框架-Golang开发
05-26
适用于Go的Fast Redis兼容服务器框架Redcon是适用于Go的自定义Redis服务器框架，使用简便。 之所以使用此库，是因为它为BuntDB和Tile38项目提供了高效的服务器前端。 适用于Go的Fast Redis兼容服务器框架Redcon是适用于Go的自定义Redis服务器框架，使用简便。 之所以使用此库，是因为它为BuntDB和Tile38项目提供了高效的服务器前端。 功能在Go Simple界面中创建快速的自定义Redis兼容服务器。 一个函数ListenAndServe和两种类型的Conn＆Command对流水线和telnet命令的支持与Redis客户端（如redigo，redis-py，node_redis和jedis）配合使用TLS支持M
Go-redis-一个简单的强大的Redis的Go客户端
08-13
redis - 一个简单的、强大的 Redis的Go客户端
Go语言Redis理解和使用（十）—— Redis
qq_54353206的博客
02-15 2282
1、redis是什么 2、redis应用案例 3、redis使用注意事项
Go：Redis
鄢秋实的博客
08-27 1133
Redis介绍 1. 简介 A. 开源的、内存中的数据结构系统。 B. 支持多种数据结构，string、hash、列表、集合以及有序集合 C. 性能非常好，单机能够达到15wQPS。 D. 通常用来做缓存系统，完全可以替代memcache 2. 应用场景 ...
Golang 安装 Redis
QMxnbbb
09-06 1295
Redis下载及安装，redis基本使用，golang下配置redis....
【从java到Go】搭建Go的Redis客户端框架redigo
幽灵雾的专栏
10-10 788
基于java基础，快速学习Golang 从零搭建redis服务
lrange是取出所有值并移除么_Go操作Redis实战
weixin_35385462的博客
02-01 672
目录安装Redis客户端连接redis基本指令Keys():根据正则获取keysType():获取key对应值得类型Del():删除缓存项Exists():检测缓存项是否存在Expire(),ExpireAt():设置有效期TTL(),PTTL():获取有效期DBSize():查看当前数据库key的数量FlushDB():清空当前数据FlushAll():清空所有数据库字符串(string)类型S...
安利两个超好用的的go redis框架
个人学习笔记库，一篇一篇记录成长的足迹
03-05 978
超好用的两个go redis框架
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值