go-redis

狂虐倭奴 發表於 2022-8-10 14:00:00

<h1 class="md-end-block md-heading">golang redis快速入门教程</h1>
redis是目前流行的高性能key/value缓存，基本上在各种项目都经常出现，后续教程针对golang如何操作redis进行展开。
本教程是使用的是go-redis/redis包操作redis。 github: https://github.com/go-redis/redis
<h2 class="md-end-block md-heading">1.安装依赖包</h2>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">go get -u github.com/go-redis/redis</pre>
<h2 class="md-end-block md-heading">2.golang连接redis</h2>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 根据redis配置初始化一个客户端 client := redis.NewClient(&redis.Options{ Addr:     "localhost:6379", // redis地址 Password: "", // redis密码，没有则留空 DB:       0,// 默认数据库，默认是0 })</pre>
<h2 class="md-end-block md-heading">3.简单的例子</h2>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 设置一个key，过期时间为0，意思就是永远不过期 err := client.Set("key", "value", 0).Err() // 检测设置是否成功 if err != nil { panic(err) } // 根据key查询缓存，通过Result函数返回两个值 //第一个代表key的值，第二个代表查询错误信息 val, err := client.Get("key").Result() // 检测，查询是否出错 if err != nil { panic(err) } fmt.Println("key", val)</pre>
<h1 class="md-end-block md-heading">golang 如何连接redis</h1>
下面介绍golang如何连接redis服务端。
<h2 class="md-end-block md-heading">1.golang连接redis</h2>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 初始化一个新的redis client client := redis.NewClient(&redis.Options{ Addr:     "localhost:6379", // redis地址 Password: "", // redis没密码，没有设置，则留空 DB:       0,// 使用默认数据库 })</pre>
通过例子，我们知道主要通过Options配置redis的连接参数，下面对Options参数进行详细说明。
<blockquote>
提示：go-redis包自带了连接池，会自动维护redis连接，因此创建一次client即可，不要查询一次redis就关闭client。
</blockquote>
<h2 class="md-end-block md-heading">2.Options参数详解</h2>
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">type Options struct { // 网络类型 tcp 或者 unix. // 默认是 tcp. Network string // redis地址，格式 host:port Addr string // 新建一个redis连接的时候，会回调这个函数 OnConnect func(*Conn) error // redis密码，redis server没有设置可以为空。 Password string // redis数据库，序号从0开始，默认是0，可以不用设置 DB int // redis操作失败最大重试次数，默认不重试。 MaxRetries int // 最小重试时间间隔. // 默认是 8ms ; -1 表示关闭. MinRetryBackoff time.Duration // 最大重试时间间隔 // 默认是 512ms; -1 表示关闭. MaxRetryBackoff time.Duration // redis连接超时时间. // 默认是 5 秒. DialTimeout time.Duration // socket读取超时时间 // 默认 3 秒. ReadTimeout time.Duration // socket写超时时间 WriteTimeout time.Duration // redis连接池的最大连接数. // 默认连接池大小等于 cpu个数 * 10 PoolSize int // redis连接池最小空闲连接数. MinIdleConns int // redis连接最大的存活时间，默认不会关闭过时的连接. MaxConnAge time.Duration // 当你从redis连接池获取一个连接之后，连接池最多等待这个拿出去的连接多长时间。 // 默认是等待 ReadTimeout + 1 秒. PoolTimeout time.Duration // redis连接池多久会关闭一个空闲连接. // 默认是 5 分钟. -1 则表示关闭这个配置项 IdleTimeout time.Duration // 多长时间检测一下，空闲连接 // 默认是 1 分钟. -1 表示关闭空闲连接检测 IdleCheckFrequency time.Duration // 只读设置，如果设置为true， redis只能查询缓存不能更新。 readOnly bool }</pre>
<h1 class="md-end-block md-heading">golang redis基本键值操作</h1>
redis基本的key/value操作，指的是针对value值的类型为字符串或者数字类型的读写操作。
golang redis常用函数列表：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
Set - 设置一个key的值
</li>
<li class="md-list-item">
Get - 查询key的值
</li>
<li class="md-list-item">
GetSet - 设置一个key的值，并返回这个key的旧值
</li>
<li class="md-list-item">
SetNX - 如果key不存在，则设置这个key的值
</li>
<li class="md-list-item">
MGet - 批量查询key的值
</li>
<li class="md-list-item">
MSet - 批量设置key的值
</li>
<li class="md-list-item">
Incr,IncrBy,IncrByFloat - 针对一个key的数值进行递增操作
</li>
<li class="md-list-item">
Decr,DecrBy - 针对一个key的数值进行递减操作
</li>
<li class="md-list-item">
Del - 删除key操作，可以批量删除
</li>
<li class="md-list-item">
Expire - 设置key的过期时间
</li>
</ul>
<h2 class="md-end-block md-heading">1.Set</h2>
设置一个key的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 第三个参数代表key的过期时间，0代表不会过期。 err := client.Set("key", "value", 0).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">2.Get</h2>
查询key的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// Result函数返回两个值，第一个是key的值，第二个是错误信息 val, err := client.Get("key").Result() // 判断查询是否出错 if err != nil { panic(err) } fmt.Println("key", val)</pre>
<h2 class="md-end-block md-heading">3.GetSet</h2>
设置一个key的值，并返回这个key的旧值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// Result函数返回两个值，第一个是key的值，第二个是错误信息 oldVal, err := client.GetSet("key", "new value").Result() if err != nil { panic(err) } // 打印key的旧值 fmt.Println("key", oldVal)</pre>
<h2 class="md-end-block md-heading">4.SetNX</h2>
如果key不存在，则设置这个key的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 第三个参数代表key的过期时间，0代表不会过期。 err := client.SetNX("key", "value", 0).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">5.MGet</h2>
批量查询key的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// MGet函数可以传入任意个key，一次性返回多个值。 // 这里Result返回两个值，第一个值是一个数组，第二个值是错误信息 vals, err := client.MGet("key1", "key2", "key3").Result() if err != nil { panic(err) } fmt.Println(vals)</pre>
<h2 class="md-end-block md-heading">6.MSet</h2>
批量设置key的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">err := client.MSet("key1", "value1", "key2", "value2", "key3", "value3").Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">7.Incr,IncrBy</h2>
针对一个key的数值进行递增操作
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// Incr函数每次加一 val, err := client.Incr("key").Result() if err != nil { panic(err) } fmt.Println("最新值", val) // IncrBy函数，可以指定每次递增多少 val, err := client.IncrBy("key", 2).Result() if err != nil { panic(err) } fmt.Println("最新值", val) // IncrByFloat函数，可以指定每次递增多少，跟IncrBy的区别是累加的是浮点数 val, err := client.IncrByFloat("key", 2).Result() if err != nil { panic(err) } fmt.Println("最新值", val)</pre>
<h2 class="md-end-block md-heading">8.Decr,DecrBy</h2>
针对一个key的数值进行递减操作
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// Decr函数每次减一 val, err := client.Decr("key").Result() if err != nil { panic(err) } fmt.Println("最新值", val) // DecrBy函数，可以指定每次递减多少 val, err := client.DecrBy("key", 2).Result() if err != nil { panic(err) } fmt.Println("最新值", val)</pre>
<h2 class="md-end-block md-heading">9.Del</h2>
删除key操作，支持批量删除
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 删除key client.Del("key") // 删除多个key, Del函数支持删除多个key err := client.Del("key1", "key2", "key3").Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">10.Expire</h2>
设置key的过期时间,单位秒
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">client.Expire("key", 3)</pre>
<h1 class="md-end-block md-heading">golang redis hash教程</h1>
golang redis hash类型数据操作。
如果你希望key/value的值也能作为hash结构进行操作，可以选择redis hash类型。
使用场景举例： 如果我们希望缓存一条用户信息(包括用户id、用户名、email字段)，希望能够做到局部读写用户信息（例如：读写用户名），也能够读取整条用户信息，那么hash类型就支持这些操作。
redis hash操作主要有2-3个元素组成：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
key - redis key 唯一标识
</li>
<li class="md-list-item">
field - hash数据的字段名
</li>
<li class="md-list-item">
value - 值，有些操作不需要值
</li>
</ul>
go redis hash数据常用函数：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
HSet - 根据key和field字段设置，field字段的值
</li>
<li class="md-list-item">
HGet - 根据key和field字段，查询field字段的值
</li>
<li class="md-list-item">
HGetAll - 根据key查询所有字段和值
</li>
<li class="md-list-item">
HIncrBy - 根据key和field字段，累加数值。
</li>
<li class="md-list-item">
HKeys - 根据key返回所有字段名
</li>
<li class="md-list-item">
HLen - 根据key，查询hash的字段数量
</li>
<li class="md-list-item">
HMGet - 根据key和多个字段名，批量查询多个hash字段值
</li>
<li class="md-list-item">
HMSet - 根据key和多个字段名和字段值，批量设置hash字段值
</li>
<li class="md-list-item">
HSetNX - 如果field字段不存在，则设置hash字段值
</li>
<li class="md-list-item">
HDel - 根据key和字段名，删除hash字段，支持批量删除hash字段
</li>
<li class="md-list-item">
HExists - 检测hash字段名是否存在。
</li>
</ul>
<blockquote>
提示：不管我们选择redis什么类型的数据，操作的时候都必须要有一个唯一的Key, 用来唯一标识一个数据。
</blockquote>
<h2 class="md-end-block md-heading">1.HSet</h2>
根据key和field字段设置，field字段的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// user_1 是hash key，username 是字段名, tizi365是字段值 err := client.HSet("user_1", "username", "tizi365").Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">2.HGet</h2>
根据key和field字段，查询field字段的值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// user_1 是hash key，username是字段名 username, err := client.HGet("user_1", "username").Result() if err != nil { panic(err) } fmt.Println(username)</pre>
<h2 class="md-end-block md-heading">3.HGetAll</h2>
根据key查询所有字段和值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 一次性返回key=user_1的所有hash字段和值 data, err := client.HGetAll("user_1").Result() if err != nil { panic(err) } // data是一个map类型，这里使用使用循环迭代输出 for field, val := range data { fmt.Println(field,val) }</pre>
<h2 class="md-end-block md-heading">4.HIncrBy</h2>
根据key和field字段，累加字段的数值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 累加count字段的值，一次性累加2， user_1为hash key count, err := client.HIncrBy("user_1", "count", 2).Result() if err != nil { panic(err) } fmt.Println(count)</pre>
<h2 class="md-end-block md-heading">5.HKeys</h2>
根据key返回所有字段名
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// keys是一个string数组 keys, err := client.HKeys("user_1").Result() if err != nil { panic(err) } fmt.Println(keys)</pre>
<h2 class="md-end-block md-heading">6.HLen</h2>
根据key，查询hash的字段数量
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">size, err := client.HLen("key").Result() if err != nil { panic(err) } fmt.Println(size)</pre>
<h2 class="md-end-block md-heading">7.HMGet</h2>
根据key和多个字段名，批量查询多个hash字段值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// HMGet支持多个field字段名，意思是一次返回多个字段值 vals, err := client.HMGet("key","field1", "field2").Result() if err != nil { panic(err) } // vals是一个数组 fmt.Println(vals)</pre>
<h2 class="md-end-block md-heading">8.HMSet</h2>
根据key和多个字段名和字段值，批量设置hash字段值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 初始化hash数据的多个字段值 data := make(mapinterface{}) data["id"] = 1 data["username"] = "tizi" // 一次性保存多个hash字段值 err := client.HMSet("key", data).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">9.HSetNX</h2>
如果field字段不存在，则设置hash字段值
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">err := client.HSetNX("key", "id", 100).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">10.HDel</h2>
根据key和字段名，删除hash字段，支持批量删除hash字段
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 删除一个字段id client.HDel("key", "id") // 删除多个字段 client.HDel("key", "id", "username")</pre>
<h2 class="md-end-block md-heading">11.HExists</h2>
检测hash字段名是否存在。
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 检测id字段是否存在 err := client.HExists("key", "id").Err() if err != nil { panic(err) }</pre>
<h1 class="md-end-block md-heading">golang redis 列表(list)用法</h1>
Redis列表是简单的字符串列表，列表是有序的，列表中的元素可以重复。
可以添加一个元素到列表的头部（左边）或者尾部（右边）
golang redis list数据操作常用函数：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
LPush - 从列表左边插入数据
</li>
<li class="md-list-item">
LPushX - 跟LPush的区别是，仅当列表存在的时候才插入数据
</li>
<li class="md-list-item">
RPop - 从列表的右边删除第一个数据，并返回删除的数据
</li>
<li class="md-list-item">
RPush - 从列表右边插入数据
</li>
<li class="md-list-item">
RPushX - 跟RPush的区别是，仅当列表存在的时候才插入数据
</li>
<li class="md-list-item">
LPop - 从列表左边删除第一个数据，并返回删除的数据
</li>
<li class="md-list-item">
LLen - 返回列表的大小
</li>
<li class="md-list-item">
LRange - 返回列表的一个范围内的数据，也可以返回全部数据
</li>
<li class="md-list-item">
LRem - 删除列表中的数据
</li>
<li class="md-list-item">
LIndex - 根据索引坐标，查询列表中的数据
</li>
<li class="md-list-item">
LInsert - 在指定位置插入数据
</li>
</ul>
<h2 class="md-end-block md-heading">1.LPush</h2>
从列表左边插入数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 插入一个数据 client.LPush("key", "data1") // LPush支持一次插入任意个数据 err := client.LPush("key", 1,2,3,4,5).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">2.LPushX</h2>
跟LPush的区别是，仅当列表存在的时候才插入数据,用法完全一样。
<h2 class="md-end-block md-heading">3.RPop</h2>
从列表的右边删除第一个数据，并返回删除的数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">val, err := client.RPop("key").Result() if err != nil { panic(err) } fmt.Println(val)</pre>
<h2 class="md-end-block md-heading">4.RPush</h2>
从列表右边插入数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 插入一个数据 client.RPush("key", "data1") // 支持一次插入任意个数据 err := client.RPush("key", 1,2,3,4,5).Err() if err != nil { panic(err) }</pre>
<h2 class="md-end-block md-heading">5.RPushX</h2>
跟RPush的区别是，仅当列表存在的时候才插入数据, 他们用法一样
<h2 class="md-end-block md-heading">6.LPop</h2>
从列表左边删除第一个数据，并返回删除的数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">val, err := client.LPop("key").Result() if err != nil { panic(err) } fmt.Println(val)</pre>
<h2 class="md-end-block md-heading">7.LLen</h2>
返回列表的大小
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">val, err := client.LLen("key").Result() if err != nil { panic(err) } fmt.Println(val)</pre>
<h2 class="md-end-block md-heading">8.LRange</h2>
返回列表的一个范围内的数据，也可以返回全部数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 返回从0开始到-1位置之间的数据，意思就是返回全部数据 vals, err := client.LRange("key",0,-1).Result() if err != nil { panic(err) } fmt.Println(vals)</pre>
<h2 class="md-end-block md-heading">9.LRem</h2>
删除列表中的数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 从列表左边开始，删除100，如果出现重复元素，仅删除1次，也就是删除第一个 dels, err := client.LRem("key",1,100).Result() if err != nil { panic(err) } // 如果存在多个100，则从列表左边开始删除2个100 client.LRem("key",2,100) // 如果存在多个100，则从列表右边开始删除2个100 // 第二个参数负数表示从右边开始删除几个等于100的元素 client.LRem("key",-2,100) // 如果存在多个100，第二个参数为0，表示删除所有元素等于100的数据 client.LRem("key",0,100)</pre>
<h2 class="md-end-block md-heading">10.LIndex</h2>
根据索引坐标，查询列表中的数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 列表索引从0开始计算，这里返回第6个元素 val, err := client.LIndex("key",5).Result() if err != nil { panic(err) } fmt.Println(val)</pre>
<h2 class="md-end-block md-heading">11.LInsert</h2>
在指定位置插入数据
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 在列表中5的前面插入4 // before是之前的意思 err := client.LInsert("key","before", 5, 4).Err() if err != nil { panic(err) } // 在列表中 tizi365 元素的前面插入欢迎你 client.LInsert("key","before", "tizi365", "欢迎你") // 在列表中 tizi365 元素的后面插入 2019 client.LInsert("key","after", "tizi365", "2019")</pre>
<h1 class="md-end-block md-heading">golang redis 集合（set）</h1>
redis的set类型（集合）是string类型数值的无序集合，并且集合元素唯一。
下面介绍go redis的集合用法。
go redis 集合（set）常用函数列表：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
SAdd - 添加集合元素
</li>
<li class="md-list-item">
SCard - 获取集合元素个数
</li>
<li class="md-list-item">
SIsMember - 判断元素是否在集合中
</li>
<li class="md-list-item">
SMembers - 获取集合中所有的元素
</li>
<li class="md-list-item">
SRem - 删除集合元素
</li>
<li class="md-list-item">
SPop,SPopN - 随机返回集合中的元素，并且删除返回的元素
</li>
</ul>
<h2 class="md-end-block md-heading">1.SAdd</h2>
添加集合元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 添加100到集合中 err := client.SAdd("key",100).Err() if err != nil { panic(err) } // 将100,200,300添加到集合中 client.SAdd("key",100, 200, 300)</pre>
<h2 class="md-end-block md-heading">2.SCard</h2>
获取集合元素个数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">size, err := client.SCard("key").Result() if err != nil { panic(err) } fmt.Println(size)</pre>
<h2 class="md-end-block md-heading">3.SIsMember</h2>
判断元素是否在集合中
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 检测100是否包含在集合中 ok, _ := client.SIsMember("key", 100).Result() if ok { fmt.Println("集合包含指定元素") }</pre>
<h2 class="md-end-block md-heading">4.SMembers</h2>
获取集合中所有的元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">es, _ := client.SMembers("key").Result() // 返回的es是string数组 fmt.Println(es)</pre>
<h2 class="md-end-block md-heading">5.SRem</h2>
删除集合元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 删除集合中的元素100 client.SRem("key", 100) // 删除集合中的元素tizi和2019 client.SRem("key", "tizi", "2019")</pre>
<h2 class="md-end-block md-heading">6.SPop,SPopN</h2>
随机返回集合中的元素，并且删除返回的元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 随机返回集合中的一个元素，并且删除这个元素 val, _ := client.SPop("key").Result() fmt.Println(val) // 随机返回集合中的5个元素，并且删除这些元素 vals, _ := client.SPopN("key", 5).Result() fmt.Println(vals)</pre>
<h1 class="md-end-block md-heading">golang redis 有序集合(sorted set)</h1>
Redis 有序集合（sorted set）和集合一样也是string类型元素的集合,且不允许重复的成员，不同的是每个元素都会关联一个double类型的分数，这个分数主要用于集合元素排序。
下面介绍golang redis 有序集合的用法
go redis有序集合常用函数:
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
ZAdd - 添加一个或者多个元素到集合，如果元素已经存在则更新分数
</li>
<li class="md-list-item">
ZCard - 返回集合元素个数
</li>
<li class="md-list-item">
ZCount - 统计某个分数范围内的元素个数
</li>
<li class="md-list-item">
ZIncrBy - 增加元素的分数
</li>
<li class="md-list-item">
ZRange,ZRevRange - 返回集合中某个索引范围的元素，根据分数从小到大排序
</li>
<li class="md-list-item">
ZRangeByScore,ZRevRangeByScore - 根据分数范围返回集合元素，元素根据分数从小到大排序，支持分页。
</li>
<li class="md-list-item">
ZRem - 删除集合元素
</li>
<li class="md-list-item">
ZRemRangeByRank - 根据索引范围删除元素
</li>
<li class="md-list-item">
ZRemRangeByScore - 根据分数范围删除元素
</li>
<li class="md-list-item">
ZScore - 查询元素对应的分数
</li>
<li class="md-list-item">
ZRank, ZRevRank - 查询元素的排名
</li>
</ul>
<h2 class="md-end-block md-heading">1.ZAdd</h2>
添加一个或者多个元素到集合，如果元素已经存在则更新分数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 添加一个集合元素到集合中，这个元素的分数是2.5，元素名是tizi err := client.ZAdd("key", redis.Z{2.5,"tizi"}).Err() if err != nil { panic(err) }</pre>
下面是redis.Z结构体说明：
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">type Z struct { Scorefloat64 // 分数 Member interface{} // 元素名 }</pre>
<h2 class="md-end-block md-heading">2.ZCard</h2>
返回集合元素个数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">size, err := client.ZCard("key").Result() if err != nil { panic(err) } fmt.Println(size)</pre>
<h2 class="md-end-block md-heading">3.ZCount</h2>
统计某个分数范围内的元素个数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 返回： 1<=分数<=5 的元素个数, 注意："1", "5"两个参数是字符串 size, err := client.ZCount("key", "1","5").Result() if err != nil { panic(err) } fmt.Println(size) // 返回： 1<分数<=5 的元素个数 // 说明：默认第二，第三个参数是大于等于和小于等于的关系。 // 如果加上（则表示大于或者小于，相当于去掉了等于关系。 size, err := client.ZCount("key", "(1","5").Result()</pre>
<h2 class="md-end-block md-heading">4.ZIncrBy</h2>
增加元素的分数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 给元素5，加上2分 client.ZIncrBy("key", 2,"5")</pre>
<h2 class="md-end-block md-heading">5.ZRange,ZRevRange</h2>
返回集合中某个索引范围的元素，根据分数从小到大排序
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 返回从0到-1位置的集合元素，元素按分数从小到大排序 // 0到-1代表则返回全部数据 vals, err := client.ZRange("key", 0,-1).Result() if err != nil { panic(err) } for _, val := range vals { fmt.Println(val) }</pre>
ZRevRange用法跟ZRange一样，区别是ZRevRange的结果是按分数从大到小排序。
<h2 class="md-end-block md-heading">6.ZRangeByScore</h2>
根据分数范围返回集合元素，元素根据分数从小到大排序，支持分页。
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 初始化查询条件， Offset和Count用于分页 op := redis.ZRangeBy{ Min:"2", // 最小分数 Max:"10", // 最大分数 Offset:0, // 类似sql的limit, 表示开始偏移量 Count:5, // 一次返回多少数据 } vals, err := client.ZRangeByScore("key", op).Result() if err != nil { panic(err) } for _, val := range vals { fmt.Println(val) }</pre>
<h2 class="md-end-block md-heading">7.ZRevRangeByScore</h2>
用法类似ZRangeByScore，区别是元素根据分数从大到小排序。
<h2 class="md-end-block md-heading">8.ZRangeByScoreWithScores</h2>
用法跟ZRangeByScore一样，区别是除了返回集合元素，同时也返回元素对应的分数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 初始化查询条件， Offset和Count用于分页 op := redis.ZRangeBy{ Min:"2", // 最小分数 Max:"10", // 最大分数 Offset:0, // 类似sql的limit, 表示开始偏移量 Count:5, // 一次返回多少数据 } vals, err := client.ZRangeByScoreWithScores("key", op).Result() if err != nil { panic(err) } for _, val := range vals { fmt.Println(val.Member) // 集合元素 fmt.Println(val.Score) // 分数 }</pre>
<h2 class="md-end-block md-heading">8.ZRem</h2>
删除集合元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 删除集合中的元素tizi client.ZRem("key", "tizi") // 删除集合中的元素tizi和xiaoli // 支持一次删除多个元素 client.ZRem("key", "tizi", "xiaoli")</pre>
<h2 class="md-end-block md-heading">9.ZRemRangeByRank</h2>
根据索引范围删除元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 集合元素按分数排序，从最低分到高分，删除第0个元素到第5个元素。 // 这里相当于删除最低分的几个元素 client.ZRemRangeByRank("key", 0, 5) // 位置参数写成负数，代表从高分开始删除。 // 这个例子，删除最高分数的两个元素，-1代表最高分数的位置，-2第二高分，以此类推。 client.ZRemRangeByRank("key", -1, -2)</pre>
<h2 class="md-end-block md-heading">10.ZRemRangeByScore</h2>
根据分数范围删除元素
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 删除范围： 2<=分数<=5 的元素 client.ZRemRangeByScore("key", "2", "5") // 删除范围： 2<=分数<5 的元素 client.ZRemRangeByScore("key", "2", "(5")</pre>
<h2 class="md-end-block md-heading">11.ZScore</h2>
查询元素对应的分数
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 查询集合元素tizi的分数 score, _ := client.ZScore("key", "tizi").Result() fmt.Println(score)</pre>
<h2 class="md-end-block md-heading">12.ZRank</h2>
根据元素名，查询集合元素在集合中的排名，从0开始算，集合元素按分数从小到大排序
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">rk, _ := client.ZRank("key", "tizi").Result() fmt.Println(rk)</pre>
ZRevRank的作用跟ZRank一样，区别是ZRevRank是按分数从大到小排序。
<h1 class="md-end-block md-heading">golang redis发布订阅</h1>
Redis提供了发布订阅功能，可以用于消息的传输，Redis的发布订阅机制包括三个部分，发布者，订阅者和Channel。
发布订阅架构图：
<img src="https://www.tizi365.com/wp-content/uploads/2019/09/redis-pubsub.jpg" alt="img">
发布者和订阅者都是Redis客户端，Channel则为Redis服务器端，发布者将消息发送到某个的频道，订阅了这个频道的订阅者就能接收到这条消息。Redis的这种发布订阅机制与基于主题的发布订阅类似，Channel相当于主题。
下面介绍golang如何使用redis的发布订阅功能。
go redis发布订阅常用函数：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
Subscribe - 订阅channel
</li>
<li class="md-list-item">
PSubscribe - 订阅channel支持通配符匹配
</li>
<li class="md-list-item">
Publish - 将信息发送到指定的channel。
</li>
<li class="md-list-item">
PubSubChannels - 查询活跃的channel
</li>
<li class="md-list-item">
PubSubNumSub - 查询指定的channel有多少个订阅者
</li>
</ul>
<h2 class="md-end-block md-heading">1.Subscribe</h2>
订阅channel
例子1：
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 订阅channel1这个channel sub := client.Subscribe("channel1") // 读取channel消息 iface, err := sub.Receive() if err != nil {  // handle error } // 检测收到的消息类型 switch iface.(type) { case *redis.Subscription:  // 订阅成功 case *redis.Message:  // 处理收到的消息  // 这里需要做一下类型转换  m := iface.(redis.Message)  // 打印收到的小 fmt.Println(m.Payload) case *redis.Pong:  // 收到Pong消息 default:  // handle error }</pre>
例子2： 使用golang channel的方式处理消息
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 订阅channel1这个channel sub := client.Subscribe("channel1") // sub.Channel() 返回go channel，可以循环读取redis服务器发过来的消息 for msg := range sub.Channel() { // 打印收到的消息 fmt.Println(msg.Channel) fmt.Println(msg.Payload) }</pre>
例子3： 取消订阅
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 订阅channel1这个channel sub := client.Subscribe("channel1") // 忽略其他处理逻辑 // 取消订阅 sub.Unsubscribe("channel1")</pre>
<h2 class="md-end-block md-heading">2.PSubscribe</h2>
用法跟Subscribe一样，区别是PSubscribe订阅通道(channel)支持模式匹配。
例子：
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 订阅channel1这个channel sub := client.PSubscribe("ch_user_*") // 可以匹配ch_user_开头的任意channel</pre>
<h2 class="md-end-block md-heading">3.Publish</h2>
将消息发送到指定的channel
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 将"message"消息发送到channel1这个通道上 client.Publish("channel1","message")</pre>
<h2 class="md-end-block md-heading">4.PubSubChannels</h2>
查询活跃的channel
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 没有指定查询channel的匹配模式，则返回所有的channel chs, _ := client.PubSubChannels("").Result() for _, ch := range chs { fmt.Println(ch) } // 匹配user_开头的channel chs, _ := client.PubSubChannels("user_*").Result()</pre>
<h2 class="md-end-block md-heading">5.PubSubNumSub</h2>
查询指定的channel有多少个订阅者
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 查询channel1，channel2两个通道的订阅者数量 chs, _ := client.PubSubNumSub("channel1", "channel2").Result() for ch, count := range chs { fmt.Println(ch) // channel名字 fmt.Println(count) // channel的订阅者数量 }</pre>
<h1 class="md-end-block md-heading">golang redis事务</h1>
redis事务可以一次执行多个命令，并且带有以下两个重要的保证：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
</li>
<li class="md-list-item">
事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。
</li>
</ul>
下面介绍golang redis事务用法。
go redis事务常用函数：
<ul class="ul-list" data-mark="-">
<li class="md-list-item">
TxPipeline - 以Pipeline的方式操作事务
</li>
<li class="md-list-item">
Watch - redis乐观锁支持
</li>
</ul>
<h2 class="md-end-block md-heading">1.TxPipeline</h2>
以Pipeline的方式操作事务
<pre class="md-fences md-end-block ty-contain-cm modeLoaded">// 开启一个TxPipeline事务 pipe := client.TxPipeline() // 执行事务操作，可以通过pipe读写redis incr := pipe.Incr("tx_pipeline_counter") pipe.Expire("tx_pipeline_counter", time.Hour) // 上面代码等同于执行下面redis命令 // //     MULTI //     INCR pipeline_counter //     EXPIRE pipeline_counts 3600 //     EXEC // 通过Exec函数提交redis事务 _, err := pipe.Exec() // 提交事务后，我们可以查询事务操作的结果 // 前面执行Incr函数，在没有执行exec函数之前，实际上还没开始运行。 fmt.Println(incr.Val(), err)</pre>
<h2 class="md-end-block md-heading">2.watch</h2>
redis乐观锁支持，可以通过watch监听一些Key, 如果这些key的值没有被其他人改变的话，才可以提交事务。
<div class="cnblogs_code">
<pre>// 定义一个回调函数，用于处理事务逻辑
fn := func(tx *redis.Tx) error {
 // 先查询下当前watch监听的key的值
 v, err := tx.Get("key").Result()
 if err != nil && err != redis.Nil {
 return err
 }

 // 这里可以处理业务
 fmt.Println(v)

 // 如果key的值没有改变的话，Pipelined函数才会调用成功
 _, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
 // 在这里给key设置最新值
 pipe.Set("key", "new value", 0)
 return nil
 })
 return err
}

// 使用Watch监听一些Key, 同时绑定一个回调函数fn, 监听Key后的逻辑写在fn这个回调函数里面
// 如果想监听多个key，可以这么写：client.Watch(fn, "key1", "key2", "key3")
client.Watch(fn, "key")</pre>
</div>
  
来源：https://www.cnblogs.com/root-123/p/16572175.html

頁: [1]

琼殿技术论坛's Archiver

go-redis