GO 操作redis

于 2023-10-07 18:19:21 发布
阅读量155 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： GO语言 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lisus2007/article/details/133650466

一.基本命令

1.SET,GET
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   err := client.Set("hello", "world", 0).Err()
   if err != nil {
      panic(err)
   }
   val, err := client.Get("hello").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("val", val)
}
2.SETNX
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   err := client.SetNX("name", "lisus", 0).Err()
   if err != nil {
      panic(err)
   }
   value, err := client.Get("name").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("value:", value)
}

二.hash命令

1.HSET,HGET
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.HSet("user_1", "username", "tizi365").Err()
   if err != nil {
      panic(err)
   }
   username, err := client.HGet("user_1", "username").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(username)
}
2.HGETALL,HINCRBY,HKEYS,HLENS
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   data, err := client.HGetAll("user_1").Result()
   if err != nil {
      panic(err)
   }
   for field, val := range data {
      fmt.Println(field, val)
   }
   count, err := client.HIncrBy("user_1", "count", 2).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(count)
​
   keys, err := client.HKeys("user_1").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(keys)
​
   size, err := client.HLen("user_1").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(size)
​
}
3.HMSet,HExists,HDel
package main
​
import "github.com/go-redis/redis"
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   data := make(map[string]interface{})
   data["id"] = 2
   data["username"] = "lisus"
​
   //一次性保存多个hash字段值
   err := client.HMSet("user_2", data).Err()
   if err != nil {
      panic(err)
   }
    
   // 检测id字段是否存在
    err := client.HExists("key", "id").Err()
    if err != nil {
        panic(err)
    }
}
​
​

三.list用法

Redis列表是简单的字符串列表，列表是有序的，列表中的元素可以重复。
​
可以添加一个元素到列表的头部（左边）或者尾部（右边）
​
golang redis list数据操作常用函数：
​
LPush - 从列表左边插入数据
LPushX - 跟LPush的区别是，仅当列表存在的时候才插入数据
RPop - 从列表的右边删除第一个数据，并返回删除的数据
RPush - 从列表右边插入数据
RPushX - 跟RPush的区别是，仅当列表存在的时候才插入数据
LPop - 从列表左边删除第一个数据，并返回删除的数据
LLen - 返回列表的大小
LRange - 返回列表的一个范围内的数据，也可以返回全部数据
LRem - 删除列表中的数据
LIndex - 根据索引坐标，查询列表中的数据
LInsert - 在指定位置插入数据LPUSH
1.LPush,LPushX
package main
​
import "github.com/go-redis/redis"
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   err := client.LPush("sale_number", 1, 2, 3, 4, 5, 6, 7, 8).Err()
   if err != nil {
      panic(err)
   }
}
2.RPop,RPush,5.RPushX,LPop
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   val, err := client.RPop("sale_number").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
   //插入一个数据
   client.RPush("sale_number", 9)
   val, err = client.LPop("sale_number").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
}
3.LLen,LRange,LRem
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func IniClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   IniClient()
   val, err := client.LIndex("sale_number", 5).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(val)
​
   vals, err := client.LRange("keys", 0, -1).Result()
   if err != nil {
      panic(err)
   }
   fmt.Println(vals)
​
   dels, err := client.LRem("sale_number", 1, 100).Result()
   if err != nil {
      panic(
          err)
   }
   fmt.Println(dels)
​
}

四.集合set的用法

1.SADD,SCard,SIsMember
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.SAdd("num1", 100).Err()
   if err != nil {
      panic(err)
   }
   client.SAdd("num1", 100, 200, 300)
​
   size, _ := client.SCard("num1").Result()
   fmt.Println(size)
​
   //判断元素是否在集合中
   ok, _ := client.SIsMember("num1", 100).Result()
   if ok {
      fmt.Println("集合包含指定元素")
   }
}
2.SMembers,SRem,SPop,SPopN
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   es, _ := client.SMembers("num1").Result()
   fmt.Println(es)
​
   // 随机返回集合中的一个元素，并且删除这个元素
   val, _ := client.SPop("num1").Result()
   fmt.Println(val)
   client.SRem("num1", 100)
​
   vals, _ := client.SPopN("num1", 5).Result()
   fmt.Println(vals)
}

五.有序集合

1.ZADD,ZCARD,ZCOUNT
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   err := client.ZAdd("zaddr", redis.Z{
      2.5,
      "tizi",
   }).Err()
   if err != nil {
      panic(err)
   }
​
   size, _ := client.ZCard("zaddr").Result()
   fmt.Println(size)
​
   count, _ := client.ZCount("zaddr", "1", "5").Result()
   fmt.Println(count)
}
2.ZRANGE,ZIncrBy
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
​
func main() {
   InitClient()
   client.ZIncrBy("znum1", 2, "5")
​
   vals, err := client.ZRange("znum1", 0, -1).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val)
   }
}
3.ZRangeByScore
package main
​
import (
   "fmt"
   "github.com/go-redis/redis"
)
​
var client *redis.Client
​
func InitClient() {
   client = redis.NewClient(&redis.Options{
      Addr:     "127.0.0.1:6379",
      Password: "123456",
      DB:       0,
   })
}
func main() {
   InitClient()
   op := redis.ZRangeBy{
      Min:    "2",  //最小分数
      Max:    "10", //最大分数
      Offset: 0,    //类似sql的limit, 表示开始偏移量
      Count:  5,    //一次返回多少数据
   }
   vals, err := client.ZRangeByScore("znum1", op).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val)
   }
}
4.ZRangeByScoreWithScores
func main() {
   InitClient()
   op := redis.ZRangeBy{
      Min:    "2",  //最小分数
      Max:    "10", //最大分数
      Offset: 0,    //类似sql的limit, 表示开始偏移量
      Count:  5,    //一次返回多少数据
   }
   vals, err := client.ZRangeByScoreWithScores("znum1", op).Result()
   if err != nil {
      panic(err)
   }
   for _, val := range vals {
      fmt.Println(val.Member)
      fmt.Println(val.Score)
   }
}
5.ZRem,ZRemRangeByRank
func main() {
   InitClient()
   client.ZRem("zddr", "test2")
}
func main() {
    InitClient()
    client.ZRemRangeByRank("zaddr", 0, 2)
}
6.ZSCORE
func main() {
   InitClient()
   score, _ := client.ZScore("zaddr", "test2").Result()
   fmt.Println(score)
}
7.ZRank
func main() {
   InitClient()
   rk, _ := client.ZRank("zaddr", "yangmi").Result()
   fmt.Println(rk)
}

六.事务处理

edis乐观锁支持，可以通过watch监听一些Key, 如果这些key的值没有被其他人改变的话，才可以提交事务。

// 定义一个回调函数，用于处理事务逻辑
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")
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值