Redis实战入门

一. Redis 连接

1. 进入redis环境

docker run -d -p 6379:6379 --name redis redis:latest
docker exec -it redis redis-cli

2. 检测 Redis 是否正常

127.0.0.1:6379> ping
PONG

3. 退出连接

127.0.0.1:6379> quit
[root@VM-4-12-centos data]#

二. redis内容

1. key 操作命令

2. 字符串string 操作命令

3. 无序集合Set 操作命令

相当于 Java 语言里面的 HashSet

4. 有序集合zset

类似于 Java 的 SortedSet 和 HashMap 的结合体

和列表的区别：

1、列表使用链表实现，两头快，中间慢。有序集合是散列表和跳跃表实现的，即使读取中间的元素也比较快。

2、列表不能调整元素位置，有序集合能。

3、有序集合比列表更占内存。

5. 列表操作命令list

Redis 中的 list 和 Java 中的 LinkedList 很像，底层都是一种链表结构， list 的插入和删除操作非常快，时间复杂度为 0(1)，不像数组结构插入、删除操作需要移动数据。

6. 散列表hash

Redis 中的 Hash 和 Java的 HashMap 更加相似， 都是 数组+链表 的结构，当发生 hash 碰撞时将会把元素追加到链表上，值得注意的是在 Redis 的 Hash 中 value 只能是字符串.

三. key的操作之get set

1. get、set去设置

// exampleClient redis连接客户端的代码
func exampleClient() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   err := rdb.Set(ctx, "key", "value", 0).Err()
   if err != nil {
      panic(err)
   }
   val, err := rdb.Get(ctx, "key").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("key", val)

   val2, err := rdb.Get(ctx, "key2").Result()
   if err == redis.Nil {
      fmt.Println("key2 does not exist")
   } else if err != nil {
      panic(err)
   } else {
      fmt.Println("key2", val2)
   }
}

2. 执行任意命令

go-redis 还提供了一个执行任意命令或自定义命令的 Do 方法，特别是一些 go-redis 库暂时不支持的命令都可以使用该方法执行。具体使用方法如下

// doCommand 基本的get set
func doCommand() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
   defer cancel()

   // 执行命令获取结果
   val, err := rdb.Get(ctx, "key").Result()
   fmt.Println("test1", val, err)

   // 先获取到命令对象
   cmder := rdb.Get(ctx, "key")
   fmt.Println("test2", cmder.Val())
   fmt.Println("test3", cmder.Err())

   // 直接执行命令获取错误
   // rdb.Set(ctx, "key", 10, time.Hour).Err()
   err = rdb.Set(ctx, "key", 3000, 0).Err()

   // 直接执行命令获取值
   value := rdb.Get(ctx, "key").Val()
   fmt.Println("test4", value)
}

3. redis.Nil

go-redis 库提供了一个 redis.Nil 错误来表示 Key 不存在的错误。因此在使用 go-redis 时需要注意对返回错误的判断。在某些场景下我们应该区别处理 redis.Nil 和其他不为 nil 的错误。

// exampleClient redis连接客户端的代码
func exampleClient() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   err := rdb.Set(ctx, "key", "value", 0).Err()
   if err != nil {
      panic(err)
   }
   val, err := rdb.Get(ctx, "key").Result()
   if err != nil {
      panic(err)
   }
   fmt.Println("key", val)

   val2, err := rdb.Get(ctx, "key2").Result()
   if err == redis.Nil {
      fmt.Println("key2 does not exist")
   } else if err != nil {
      panic(err)
   } else {
      fmt.Println("key2", val2)
   }
}

4. 扫描或遍历所有key

你可以使用 KEYS prefix:* 命令按前缀获取所有 key

func ScanKeysDemo2() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, cancel := context.WithTimeout(context.Background(), time.Hour)
   defer cancel()
   // 按前缀扫描key
   iter := rdb.Scan(ctx, 0, "prefix:*", 0).Iterator()
   // 此外，对于 Redis 中的 set、hash、zset 数据类型，go-redis 也支持类似的遍历方法。
   // iter := rdb.SScan(ctx, "set-key", 0, "prefix:*", 0).Iterator()
   // iter := rdb.HScan(ctx, "hash-key", 0, "prefix:*", 0).Iterator()
   // iter := rdb.ZScan(ctx, "sorted-hash-key", 0, "prefix:*", 0).Iterator()

   for iter.Next(ctx) {
      fmt.Println("[key]:", iter.Val())
   }
   if err := iter.Err(); err != nil {
      panic(err)
   }
}

四. zset命令

func ZSetDemo() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   zsetKey := "language_rank"
   languages := []*redis.Z{
      {Score: 90.0, Member: "Golang"},
      {Score: 98.0, Member: "Java"},
      {Score: 95.0, Member: "Python"},
      {Score: 97.0, Member: "JavaScript"},
      {Score: 99.0, Member: "C/C++"},
   }
   ctx, cancel := context.WithTimeout(context.Background(), 50000*time.Microsecond)
   defer cancel()

   // ZADD
   err := rdb.ZAdd(ctx, zsetKey, languages...).Err()
   if err != nil {
      fmt.Printf("zadd failed, err:%v\n", err)
      return
   }
   fmt.Println("zadd success!")

   // Goland分数加10
   newScore, err := rdb.ZIncrBy(ctx, zsetKey, 10.0, "Golang").Result()
   if err != nil {
      fmt.Printf("zincrby failed, err:%v\n", err)
      return
   }
   fmt.Printf("Goland's score is %f now.\n", newScore)

   // 取分数最高的3个
   ret := rdb.ZRevRangeWithScores(ctx, zsetKey, 0, 2).Val()
   for _, z := range ret {
      fmt.Println(z.Member, z.Score)
   }
   fmt.Println("=================")

   // 取95~100分的
   op := redis.ZRangeBy{
      Min: "95",
      Max: "100",
   }
   ret, err = rdb.ZRangeByScoreWithScores(ctx, 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)
   }
}

执行上面的函数将得到如下输出结果。

zadd success
Golang's score is 100.000000 now.
Golang 100
C/C++ 99
Java 98
Python 95
JavaScript 97
Java 98
C/C++ 99
Golang 100

五. Pipeline

Redis Pipeline 允许通过使用单个 client-server-client 往返执行多个命令来提高性能。区别于一个接一个地执行100个命令，你可以将这些命令放入 pipeline 中，然后使用1次读写操作像执行单个命令一样执行它们。这样做的好处是节省了执行命令的网络往返时间（RTT）。

1. 写法一. pipeline

func PipelineWithNoExecDemo() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, _ := context.WithTimeout(context.Background(), time.Hour)

   var incr *redis.IntCmd
   _, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
      incr = pipe.Incr(ctx, "pipeline_counter")
      pipe.Expire(ctx, "pipeline_counter", time.Hour)
      return nil
   })
   if err != nil {
      panic(err)
   }
   // 在执行pipe.Exec之后才能获取到结果
   fmt.Println(incr.Val())
}

也可以使用 Pipelined 方法，它会在函数退出时调用 Exec. 代码会更加简洁

2. 写法二. pipelined

func PipelineWithNoExecMulDemo() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, _ := context.WithTimeout(context.Background(), time.Hour)
   _, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
      for i := 0; i < 100; i++ {
         pipe.Set(ctx, fmt.Sprintf("key%d", i), fmt.Sprintf("key%d", i), time.Hour)
      }
      return nil
   })
   if err != nil {
      panic(err)
   }

   cmds, err := rdb.Pipelined(ctx, func(pipe redis.Pipeliner) error {
      for i := 0; i < 100; i++ {
         pipe.Get(ctx, fmt.Sprintf("key%d", i))
      }
      return nil
   })
   if err != nil {
      panic(err)
   }

   for _, cmd := range cmds {
      fmt.Println(cmd.(*redis.StringCmd).Val())
   }
}

六. 加锁

Redis 是单线程执行命令的，因此单个命令始终是原子的，但是来自不同客户端的两个给定命令可以依次执行，例如在它们之间交替执行。但是， Multi/exec 能够确保在 multi/exec 两个语句之间的命令之间没有其他客户端正在执行命令。

在这种场景我们需要使用 TxPipeline 或 TxPipelined 方法将 pipeline 命令使用 MULTI 和 EXEC 包裹起来。

// ZTransactionTxPipeDemo 这里只是相当于加锁，TxPipeline/TxPipelined
func ZTransactionTxPipeDemo() {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, cancel := context.WithTimeout(context.Background(), 50000*time.Microsecond)
   defer cancel()

   // TxPipeline demo
   pipe := rdb.TxPipeline()
   pipe.Incr(ctx, "tx_pipeline_counter")
   pipe.Expire(ctx, "tx_pipeline_counter", time.Hour)
   _, err := pipe.Exec(ctx)
   if err != nil {
      panic(err)
   }

   // TxPipelined demo
   var incr2 *redis.IntCmd
   _, err = rdb.TxPipelined(ctx, func(pipeliner redis.Pipeliner) error {
      incr2 = pipe.Incr(ctx, "tx_pipeline_counter")
      pipe.Expire(ctx, "tx_pipeline_counter", time.Hour)
      return nil
   })

   fmt.Println(incr2.Val(), err)
}

七. 事务-watch

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

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

// WatchDemo 配合TxPipeline/TxPipelined完成增删改查
func WatchDemo() error {
   rdb := redis.NewClient(redis.Options{Addr: "localhost:6379", Password: "", DB: 0})
   ctx, cancel := context.WithTimeout(context.Background(), 50000*time.Microsecond)
   defer cancel()
   key := "key"
   return rdb.Watch(ctx, func(tx *redis.Tx) error {
      n, err := tx.Get(ctx, key).Int()
      if err != nil; err != redis.Nil {
         return err
      }
      // 假设操作耗时5秒
      // 5秒内我们通过其他的客户端修改key，当前事务就会失败
      time.Sleep(5 * time.Second)
      _, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
         pipe.Set(ctx, key, n+1, time.Hour)
         return nil
      })
      return err
   }, key)
}

参考文章

1. Go语言操作Redis
2. https://github.com/go-redis/redis
3. Redis 常用操作命令，非常详细！
4. Redis基础系列短视频《2. Redis简单实战》
5. redis中文官网
6. Redis 常用命令

未经允许不得转载：木盒主机 » Redis实战入门