go库：github.com/redis/go-redis/v9
package main
import (
"context"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
var rdb *redis.Client
func init() {
// redis 连接
rdb = redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // 密码
DB: 0, // 数据库号
})
}
func main() {
//上下文
ctx := context.Background()
// -------------------- String 类型 ----------------------
// 【Set】设置key value 第三个参数 0 表示不过期
string_res, err := rdb.Set(ctx, "key1", "value1", 0).Result()
if err != nil {
panic(string_res)
}
fmt.Println(string_res) // OK
// 【Set】设置一分钟过期
string_res, err = rdb.Set(ctx, "key2", "value2", time.Minute).Result()
if err != nil {
panic(err)
}
fmt.Println(string_res) // OK
// 下文为了精简代码，忽略错误处理部分，实际项目代码需要加上
// 【Get】获取key对应的value
string_res, _ = rdb.Get(ctx, "key1").Result()
fmt.Println(string_res) // value1
// 【GetSet】设置一个key值，并返回这个key的旧值
string_res, _ = rdb.GetSet(ctx, "key1", "value1_new").Result()
fmt.Println(string_res) // value1
// 【SetNX】如果key 不存在，则设置其值，不存在返回true， 已存在返回false
bool_res, _ := rdb.SetNX(ctx, "key3", "value3", 0).Result()
fmt.Println(bool_res) // true or false
// 【MGet】批量查询key的值，返回数组
array_res, _ := rdb.MGet(ctx, "key1", "key2", "key3").Result()
fmt.Println(array_res) // [value1_new value2 value3]
// 【MSet】批量设置key4、key5的值，常规方式
string_res, _ = rdb.MSet(ctx, "key4", "value4", "key5", "value5").Result()
fmt.Println(string_res) // OK
// 【MSet】批量设置key4、key5的值，数组方式
string_res, _ = rdb.MSet(ctx, []string{"key4", "value4", "key5", "value5"}).Result()
fmt.Println(string_res) // OK
// 【MSet】批量设置key4、key5的值，map方式
string_res, _ = rdb.MSet(ctx, map[string]any{"key4": "value4", "key5": "value5"}).Result()
fmt.Println(string_res) // OK
// 【Incr】数值自增，key必须是数值或者不存在
int64_res, _ := rdb.Incr(ctx, "key6").Result()
fmt.Println(int64_res) // 1
// 【IncrBy】数值自增，自定义增步长，key必须是数值或者不存在，每次减2
int64_res, _ = rdb.IncrBy(ctx, "key7", -2).Result()
fmt.Println(int64_res) // -2
// 【IncrByFloat】数值自增，自定义增步长(浮点数)，key必须是数值或者不存在
float64_res, _ := rdb.IncrByFloat(ctx, "key8", 6.23).Result()
fmt.Println(float64_res) // 6.23
// 【Decr】数值自减，key必须是数值或者不存在
int64_res, _ = rdb.Decr(ctx, "key9").Result()
fmt.Println(int64_res) // -1
// 【DecrBy】数值自减，自定义步长，key必须是数值或者不存在
int64_res, _ = rdb.DecrBy(ctx, "key10", 100).Result()
fmt.Println(int64_res) // -100
// 【Del】单个删除数
int64_res, _ = rdb.Del(ctx, "key10").Result()
fmt.Println(int64_res) // 1
// 【Del】多个key批量删除，返回删除key 的个数
int64_res, _ = rdb.Del(ctx, "key9", "key8", "key7", "key6").Result()
fmt.Println(int64_res) // 4
// 【Expire】设置key的过期时间，key不存在返回false，设置10秒过期
bool_res, _ = rdb.Expire(ctx, "key1", time.Second*10).Result()
fmt.Println(bool_res) // true
// 【Exists】返回key存在的个数
int64_res, _ = rdb.Exists(ctx, "key2", "key3", "key55").Result()
fmt.Println(int64_res) // 2
// -------------------- Hash 类型 ----------------------
// 【HSet】为hash key 设置字段名和值，返回不存在的field数
int64_res, _ = rdb.HSet(ctx, "hkey1", "name", "zhangsan").Result()
fmt.Println(int64_res) // 1
// 【HSet】批量设置，数组模式
int64_res, _ = rdb.HSet(ctx, "hkey1", []string{"sex", "man", "age", "18"}).Result()
fmt.Println(int64_res) // 2
// 【HSet】批量设置， map模式
int64_res, _ = rdb.HSet(ctx, "hkey1", map[string]any{"name": "wangwu", "age": 100}).Result()
fmt.Println(int64_res) // 0
// 【HGet】获取 key 指定字段的值
string_res, _ = rdb.HGet(ctx, "hkey1", "name").Result()
fmt.Println(string_res) // wangwu
// 【HGetAll】获取 key 的所有字段和值，返回 map[string]string
map_res, _ := rdb.HGetAll(ctx, "hkey1").Result()
fmt.Println(map_res) // map[age:100 name:wangwu sex:man]
// 【HIncrBy】使 key 指定的字段自增 某个整数值
int64_res, _ = rdb.HIncrBy(ctx, "hkey1", "count", 1).Result()
fmt.Println(int64_res) // 1
// 【HIncrByFloat】使 key 指定的字段自增 某个浮点数值
float64_res, _ = rdb.HIncrByFloat(ctx, "hkey1", "count", 2.2).Result()
fmt.Println(float64_res) // 2.2
// 【HKeys】返回 key 的所有字段名，返回数组
array_string_res, _ := rdb.HKeys(ctx, "hkey1").Result()
fmt.Println(array_string_res) // [age name sex score count]
// 【HLen】返回 key 的所有字段的总数
int64_res, _ = rdb.HLen(ctx, "hkey1").Result()
fmt.Println(int64_res) // 5
// 【HMGet】获取 key 指定字段(多个)的值
array_res, _ = rdb.HMGet(ctx, "hkey1", "name", "age", "score").Result()
fmt.Println(array_res) // [wangwu 100 1]
// 【HMSet】批量设置， map模式
bool_res, _ = rdb.HMSet(ctx, "hkey1", map[string]any{"name": "zhaoliu", "age": 33}).Result()
fmt.Println(bool_res) // true
// 【HSetNX】如果字段不存在，则设置值
bool_res, _ = rdb.HSetNX(ctx, "hkey1", "name", "da da da").Result()
fmt.Println(bool_res) // false
// 【HDel】删除 key 的指定字段（支持批量），返回删除字段的个数
int64_res, _ = rdb.HDel(ctx, "hkey1", "name", "age").Result()
fmt.Println(int64_res) // 2
// 【HExists】检查 key 的指定字段是否存在
bool_res, _ = rdb.HExists(ctx, "hkey1", "score").Result()
fmt.Println(bool_res) // true
// -------------------- List 类型 ----------------------
// 【LPush】从左边插入数据，支持一次插入任意个数据，返回数据的总数
int64_res, _ = rdb.LPush(ctx, "lkey1", "one", "two", "three", "four").Result()
fmt.Println(int64_res) // 4
// 【LPushX】用法与上述一样，但只有列表存在时才插入
int64_res, _ = rdb.LPushX(ctx, "lkey2", "one", "two").Result()
fmt.Println(int64_res) // 0
// 【RPop】从列表的右边删除数据，并返回删除的数据
string_res, _ = rdb.RPop(ctx, "lkey1").Result()
fmt.Println(string_res) // one
// 【RPush】、【RPushX】、【LPop】与上述对应，反向相反，不再示例
// 【LLen】返回列表元素的总数
int64_res, _ = rdb.LLen(ctx, "lkey1").Result()
fmt.Println(int64_res) // 3
// 【LRange】返回列表某范围的元素，开始索引为0，-1表示到末尾
array_string_res, _ = rdb.LRange(ctx, "lkey1", 1, -1).Result()
fmt.Println(array_string_res) // [three two]
// 【LRem】从列表左边开始删除指定元素, 返回结果为成功删除的个数
// 1表示删除从左边开始遇到的1个 two;
// 如果是-2表示删除从右边开始遇到的两个two
// 如果为 0 表示删除列表中的所有 two
int64_res, _ = rdb.LRem(ctx, "lkey1", 1, "two").Result()
fmt.Println(int64_res) // 1
// 再插入一些测试数据
rdb.LPush(ctx, "lkey1", "five", "six", "seven", "eight").Result()
// 【LIndex】返回指定索引位置的元素（左侧索引从0开始）
string_res, _ = rdb.LIndex(ctx, "lkey1", 3).Result()
fmt.Println(string_res) // five
// 【LInsert】在指定位置插入元素, before为指定元素之前， after为之后
// 返回插入之后元素的数量，指定元素不存在返回 -1
int64_res, _ = rdb.LInsert(ctx, "lkey1", "before", "six", "before_one").Result()
fmt.Println(int64_res) // 7
// -------------------- Set 类型 ----------------------
// 与List 类型的区别是集合中的元素不能重复，已存在则不添加
// 【SAdd】添加元素，支持批量，返回添加成功的个数
int64_res, _ = rdb.SAdd(ctx, "skey1", 100, 100, 200, 300, 400, 500, 600).Result()
fmt.Println(int64_res) // 6 两个100只算1个
// 【SCard】获取集合元素个数
int64_res, _ = rdb.SCard(ctx, "skey1").Result()
fmt.Println(int64_res) // 6
// 【SIsMember】判断元素是否在集合中
bool_res, _ = rdb.SIsMember(ctx, "skey1", 500).Result()
fmt.Println(bool_res) // true
// 【SMembers】获取集合中的所有元素
array_string_res, _ = rdb.SMembers(ctx, "skey1").Result()
fmt.Println(array_string_res) // [100 200 300 400 500 600]
// 【SRem】删除集合中的元素，返回被删元素的个数
int64_res, _ = rdb.SRem(ctx, "skey1", 100, 200).Result()
fmt.Println(int64_res) // 2
// 【SPop】随机删除1个元素，并返回删除的元素
string_res, _ = rdb.SPop(ctx, "skey1").Result()
fmt.Println(string_res) // 500
// 【SPop】随机删除n个元素，并返回删除的元素数组
array_string_res, _ = rdb.SPopN(ctx, "skey1", 2).Result()
fmt.Println(array_string_res) // [400 300]
// -------------------- Sorted Set 类型 ----------------------
// 带排序的集合，Score 为排序的权重值
// 【ZAdd】添加元素，支持批量，返回成功添加的个数，元素存在则更新分数
int64_res, _ = rdb.ZAdd(ctx, "zkey1",
redis.Z{
Score: 9.2,
Member: "one",
},
redis.Z{
Score: 8.3,
Member: "two",
},
redis.Z{
Score: 7.3,
Member: "three",
},
).Result()
fmt.Println(int64_res) // 3
// 【ZCount】返回指定分数区间的元素个数（注意要用字符串），返回 7 <= 分数 <= 9的元素个数
// 后两个参数如果是 "(7" , "(9" 则表示 7 < 分数 < 9
int64_res, _ = rdb.ZCount(ctx, "zkey1", "7", "9").Result()
fmt.Println(int64_res) // 2
// 【ZIncrBy】给指定元素增加分数
float64_res, _ = rdb.ZIncrBy(ctx, "zkey1", 2.2, "one").Result()
fmt.Println(float64_res) // 11.399999999999999
// 【ZRange】按分数从小到大返回元素集合，索引范围， -1表示全部
array_string_res, _ = rdb.ZRange(ctx, "zkey1", 0, -1).Result()
fmt.Println(array_string_res) // [three two one]
// 【ZRevRange】按分数大到小返回元素集合，索引范围， -1表示全部
array_string_res, _ = rdb.ZRevRange(ctx, "zkey1", 0, 1).Result()
fmt.Println(array_string_res) // [one two]
// 【ZRangeByScore】按分数从小到大返回元素集合， 索引范围，分数范围
op := redis.ZRangeBy{
Min: "(5", // > 5
Max: "9", // <= 9
Offset: 0, // 类似mysql的 偏移位置
Count: 5, // 类似mysql的 limit 数量
}
array_string_res, _ = rdb.ZRangeByScore(ctx, "zkey1", &op).Result()
fmt.Println(array_string_res) // [three two]
// 【ZRevRangeByScore】按分数从大到小返回元素集合， 索引范围，分数范围
array_string_res, _ = rdb.ZRevRangeByScore(ctx, "zkey1", &op).Result()
fmt.Println(array_string_res) // [two three]
// 【ZRangeByScoreWithScores】同时返回元素和分数，从小到大
array_struct_res, _ := rdb.ZRangeByScoreWithScores(ctx, "zkey1", &op).Result()
fmt.Println(array_struct_res) // [{7.3 three} {8.3 two}]
// 【ZRevRangeByScoreWithScores】同时返回元素和分数，从大到小
array_struct_res, _ = rdb.ZRevRangeByScoreWithScores(ctx, "zkey1", &op).Result()
fmt.Println(array_struct_res) // [{8.3 two} {7.3 three}]
// 【ZRem】删除集合元素，支持批量，返回成功删除的个数
int64_res, _ = rdb.ZRem(ctx, "zkey1", "one", "two").Result()
fmt.Println(int64_res) // 2
// 【ZRemRangeByRank】按索引范围删除，返回成功删除的个数
int64_res, _ = rdb.ZRemRangeByRank(ctx, "zkey1", 0, 1).Result()
fmt.Println(int64_res) // 1
// 【ZRemRangeByScore】按分数范围删除，返回成功删除的个数
int64_res, _ = rdb.ZRemRangeByScore(ctx, "zkey1", "(2", "8").Result()
fmt.Println(int64_res) // 0
rdb.ZAdd(ctx, "zkey1",
redis.Z{
Score: 1.1,
Member: "one",
},
redis.Z{
Score: 2.2,
Member: "two",
},
redis.Z{
Score: 3.3,
Member: "three",
},
).Result()
// 【ZScore】查询指定元素的分数，不存在返回0
float64_res, _ = rdb.ZScore(ctx, "zkey1", "one").Result()
fmt.Println(float64_res) // 0
// 【ZRank】查询指定元素从小到大的排名，索引从0开始
int64_res, _ = rdb.ZRank(ctx, "zkey1", "two").Result()
fmt.Println(int64_res) // 1
// 【ZRevRank】查询指定元素从大到小的排名，索引从0开始
int64_res, _ = rdb.ZRevRank(ctx, "zkey1", "one").Result()
fmt.Println(int64_res) // 2
// -------------------- 事务处理 ----------------------
// 类似于mysql事务，事务中的所有命令会按顺序执行，并且不被外界命令所打断
// 原子性：要么全部执行，要么全部不执行
// 【TxPipeline】开启一个事务
pipe := rdb.TxPipeline()
p := pipe.Set(ctx, "pkey1", 1, 0)
pipe.IncrBy(ctx, "pkey1", 2)
// 【Exec】执行事务，这一步之后才开始顺序执行所有命令
res, err := pipe.Exec(ctx)
fmt.Println(res, err) // [set pkey1 1: OK incrby pkey1 2: 3] <nil>
fmt.Println(p.Val()) // OK
// -------------------- 消息订阅 ----------------------
Subscribe()
select {}
}
// 订阅
func Subscribe() {
// 模拟发布者，每两秒往频道里发送1次消息
go func() {
ctx := context.Background()
c := time.Tick(time.Second * 2)
var count int
for {
<-c
count++
// 【Publish】往指定频道发送消息
rdb.Publish(ctx, "channel1", fmt.Sprintf("hello: %d", count))
}
}()
var receive func(int) = func(num int) {
ctx := context.Background()
//【Subscribe】订阅频道
sub := rdb.Subscribe(ctx, "channel1")
// 订阅者实时接收频道中的消息
for msg := range sub.Channel() {
// 打印频道号和消息内容
fmt.Printf("我是接收者%d，我接收到来自频道%s的消息: %s\n",
num, msg.Channel, msg.Payload)
}
}
// 模拟接收者1
go receive(1)
// 模拟接收者2
go receive(2)
}