参考资料

  1. https://www.runoob.com/redis/redis-transactions.html -菜鸟教程
  2. https://www.liwenzhou.com/posts/Go/go_redis/#autoid-2-4-0 -李文周博客

    安装

    go get -u github.com/go-redis/redis

    连接

    ```go var rdb *redis.Client

func initClient() (err error) { rdb = redis.NewClient(&redis.Options{ Addr: “localhost:6379”, Password: “”, DB: 0, // 默认值 }) _, err = rdb.Ping().Result() return err }

  1. <a name="lSpL6"></a>
  2. # 基本操作
  3. <a name="eE3yP"></a>
  4. ## set、get
  5. ```go
  6. func main() {
  7.     err := initClient()
  8.     if err != nil {
  9.         fmt.Printf("initclinet failed, err: %v\n", err)
  10.     }
  12.     // key, value , 超时时间
  13.     err = rdb.Set("score", 100, 0).Err()
  14.     if err != nil {
  15.         fmt.Printf("set failed, %v\n", err)
  16.     }
  18.     val, err := rdb.Get("score").Result()
  19.     if err != nil {
  20.         fmt.Printf("get failed, %v\n", err)
  21.     } else {
  22.         fmt.Println(val)
  23.     }
  25.     val2, err := rdb.Get("name").Result()
  26.     if err == redis.Nil {
  27.         fmt.Println("name does not exist")
  28.     } else if err != nil {
  29.         fmt.Printf("get name failed, err:%v\n", err)
  30.         return
  31.     } else {
  32.         fmt.Println("name:", val2)
  33.     }
  34. }

zset

  1. func redisExample2() {
  2.     zsetKey := "language_rank"
  3.     languages := []redis.Z{
  4.         redis.Z{Score: 90.0, Member: "Golang"},
  5.         redis.Z{Score: 98.0, Member: "Java"},
  6.         redis.Z{Score: 95.0, Member: "Python"},
  7.         redis.Z{Score: 97.0, Member: "JavaScript"},
  8.         redis.Z{Score: 99.0, Member: "C/C++"},
  9.     }
  10.     // ZADD
  11.     num, err := rdb.ZAdd(zsetKey, languages...).Result()
  12.     if err != nil {
  13.         fmt.Printf("zadd failed, err:%v\n", err)
  14.         return
  15.     }
  16.     fmt.Printf("zadd %d succ.\n", num)
  18.     // 把Golang的分数加10
  19.     newScore, err := rdb.ZIncrBy(zsetKey, 10.0, "Golang").Result()
  20.     if err != nil {
  21.         fmt.Printf("zincrby failed, err:%v\n", err)
  22.         return
  23.     }
  24.     fmt.Printf("Golang's score is %f now.\n", newScore)
  26.     // 取分数最高的3个
  27.     ret, err := rdb.ZRevRangeWithScores(zsetKey, 0, 2).Result()
  28.     if err != nil {
  29.         fmt.Printf("zrevrange failed, err:%v\n", err)
  30.         return
  31.     }
  32.     for _, z := range ret {
  33.         fmt.Println(z.Member, z.Score)
  34.     }
  36.     // 取95~100分的
  37.     op := redis.ZRangeBy{
  38.         Min: "95",
  39.         Max: "100",
  40.     }
  41.     ret, err = rdb.ZRangeByScoreWithScores(zsetKey, op).Result()
  42.     if err != nil {
  43.         fmt.Printf("zrangebyscore failed, err:%v\n", err)
  44.         return
  45.     }
  46.     for _, z := range ret {
  47.         fmt.Println(z.Member, z.Score)
  48.     }
  49. }

Pipeline

使用pipeline的目的是进行网络优化：如果有数量很多的redis服务请求，如果每个请求都单独发送，则将耗费大量RTT（Round-Trip Time），而使用pipeline，将使大量请求一次性发送，只耗费一个RTT。

适用场景：
需要连续发送多个相互之间没有依赖的数据库指令。

  1. // 基本操作
  2. pipe := rdb.Pipeline()
  4. incr := pipe.Incr("pipeline_counter")
  5. pipe.Expire("pipeline_counter", time.Hour)
  7. _, err := pipe.Exec()
  8. fmt.Println(incr.Val(), err)
  10. // 使用pipelined
  11. var incr *redis.IntCmd
  12. _, err := rdb.Pipelined(func(pipe redis.Pipeliner) error {
  13.     incr = pipe.Incr("pipelined_counter")
  14.     pipe.Expire("pipelined_counter", time.Hour)
  15.     return nil
  16. })
  17. fmt.Println(incr.Val(), err)
  19. // 相当于一次性执行了下面的命令：
  20. // INCR pipeline_counter
  21. // EXPIRE pipeline_counts 3600

事务

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

  • 批量操作在发送 EXEC 命令前被放入队列缓存。
  • 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
  • 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
  1. pipe := rdb.TxPipeline()
  3. incr := pipe.Incr("tx_pipeline_counter")
  4. pipe.Expire("tx_pipeline_counter", time.Hour)
  6. _, err := pipe.Exec()
  7. fmt.Println(incr.Val(), err)
  9. // 相当于执行了：
  10. // MULTI
  11. // INCR pipeline_counter
  12. // EXPIRE pipeline_counts 3600
  13. // EXEC

watch

在某些场景下，我们除了要使用MULTI/EXEC命令外，还需要配合使用WATCH命令。用户使用WATCH命令监视某个键之后，直到该用户执行EXEC命令的这段时间里，如果有其他用户抢先对被监视的键进行了更改，那么当用户尝试执行EXEC的时候，事务将失败并返回一个错误，用户可以根据这个错误选择重试事务或者放弃事务。

  1. // 监视watch_count的值，并在值不变的前提下将其值+1
  2. key := "watch_count"
  3. err = client.Watch(func(tx *redis.Tx) error {
  4.     n, err := tx.Get(key).Int()
  5.     if err != nil && err != redis.Nil {
  6.         return err
  7.     }
  8.     _, err = tx.Pipelined(func(pipe redis.Pipeliner) error {
  9.         pipe.Set(key, n+1, 0)
  10.         return nil
  11.     })
  12.     return err
  13. }, key)