Go操作Redis

准备环境

首先需要安装docker， 可参考菜鸟教程， docker环境配置好后，从docker hub 上拉一个redis镜像：

docker pull nginx

默认拉取最新版本的镜像

拉取镜像后可以运行容器：

docker run -d -p 6379:6379 --name redis redis

参数说明
-d指定后台运行容器 -p配置内外端口映射 --name 指定运行容器的名字
再启动一个redis-cli连接上面启动的redis服务

docker run -it --network host --rm redis redis-cli

参数说明
-it进入到运行的容器中 --network指定网络模式为host模式 --rm停止容器后自动删除挂载点

go-redis库

使用go-redis库连接操作redis数据库，go-redis库支持连接哨兵及集群模式的redis
使用以下命令安装

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

运行go get -u将会升级到最新的次要版本或者修订版本(x.y.z, z是修订版本号， y是次要版本号)

连接

import "github.com/go-redis/redis"

// 声明全局rdb变量
var rdb *redis.Client

func initClient() (err error) {
	rdb = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})
	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

基本使用

set/get示例

func redisExample() {
	err := rdb.Set("score", 100, 0).Err()
	if err != nil {
		fmt.Printf("set score failed, err: %v\n", err)
		return
	}
	val, err := rdb.Get("score").Result()
	if err != nil {
		fmt.Printf("get score faild, err: %v\n", err)
		return
	}
	fmt.Println("score", val)
	val2, err := rdb.Get("name").Result()
	if err == redis.Nil {
		fmt.Printf("name dose not exist\n")
	} else if err != nil {
		fmt.Printf("get name failed , err: %v\n", err)
		return
	} else {
		fmt.Println("name", val2)
	}
}

zset示例

func redisExample2() {
	zsetKey := "language_rank"
	languages := []redis.Z{
		redis.Z{Score: 90.0, Member: "Golang"},
		redis.Z{Score: 98.0, Member: "Java"},
		redis.Z{Score: 95.0, Member: "Python"},
		redis.Z{Score: 97.0, Member: "JavaScript"},
		redis.Z{Score: 99.0, Member: "c/c++"},
	}
	// ZADD
	num, err := rdb.ZAdd(zsetKey, languages...).Result()
	if err != nil {
		fmt.Printf("zadd failed err: %v\n", err)
		return
	}
	fmt.Printf("zadd %d succ. \n", num)

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

	// 取分数最高的三个
	ret, err := rdb.ZRevRangeWithScores(zsetKey, 0, 2).Result()
	if err != nil {
		fmt.Printf("zrevrange failed, err: %v\n", err)
		return
	}
	for _, z := range ret {
		fmt.Println(z.Member, z.Score)
	}
	// 取 95~100分的
	op := redis.ZRangeBy{Min: "95", Max: "100"}
	ret, err = rdb.ZRangeByScoreWithScores(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)
	}
}

根据前缀获取key

keys, err := rdb.Keys("pattern*").Result()

执行自定义命令

res, err := rdb.Do("set", "key", "value").Result()

按照通配符删除key

当通配符匹配的key的数量不多时，可以使用Keys()得到所有的key在使用Del命令删除。 如果key的数量非常多的时候，我们可以搭配使用Scan命令和Del命令完成删除

iter := rdb.Scan(0, "pattern*", 0).Iterator()
	for iter.Next() {
		err := rdb.Del(iter.Val()).Err()
		if err != nil {
			panic(err)
		}
	}
	if err := iter.Err(); err != nil {
		panic(err)
	}

pipeline

客户端缓存一堆命令，一次性发送到服务器，这些命令不能保证在事务中执行，但好处是节省了命令的网络往返时间（RTT）
基本示例：

pipe := rdb.Pipeline()

incr := pipe.Incr("pipeline_counter")
pipe.Expire("pipeline_counter", time.Hour)

_, err := pipe.Exec()
fmt.Println(incr.Val(), err)

相当于发送一下两个命令给redis server，节省了一次RTT时间

INCR pipeline_counter
EXPIRE pipeline_counts 3600

同样可以使用Pipelined

var incr *redis.IntCmd
_, err := rdb.Pipelined(func(pipe redis.Pipeliner) error {
	incr = pipe.Incr("pipelined_counter")
	pipe.Expire("pipelined_counter", time.Hour)
	return nil
})
fmt.Println(incr.Val(), err)

事务

redis是单线程的，因而每个命令都是原子的，但是不同客户端发送的命令可能会交错执行，通过事务可以串联多个命令防止别的命令插队
在这种场景我们需要使用TxPipeline。TxPipeline总体上类似于上面的Pipeline，但是它内部会使用MULTI/EXEC包裹排队的命令。例如：

pipe := rdb.TxPipeline()

incr := pipe.Incr("tx_pipeline_counter")
pipe.Expire("tx_pipeline_counter", time.Hour)

_, err := pipe.Exec()
fmt.Println(incr.Val(), err)

相当于在一个RTT下执行了以下命令

MULTI
INCR pipeline_counter
EXPIRE pipeline_counts 3600
EXEC

类似的TxPipelined如下：

var incr *redis.IntCmd
_, err := rdb.TxPipelined(func(pipe redis.Pipeliner) error {
	incr = pipe.Incr("tx_pipelined_counter")
	pipe.Expire("tx_pipelined_counter", time.Hour)
	return nil
})
fmt.Println(incr.Val(), err)

watch

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断，返回一个错误，用户可以根据这个错误选择重试或者放弃这个事务。

Watch方法接收一个函数和一个或多个key作为参数。基本使用示例如下：

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

下面是go-redisV8版本的官方文档中使用GET和SET命令以事务方式递增Key的值的示例，仅当Key的值不发生变化时提交一个事务。

func transactionDemo() {
	var (
		maxRetries   = 1000
		routineCount = 10
	)
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// Increment 使用GET和SET命令以事务方式递增Key的值
	increment := func(key string) error {
		// 事务函数
		txf := func(tx *redis.Tx) error {
			// 获得key的当前值或零值
			n, err := tx.Get(ctx, key).Int()
			if err != nil && err != redis.Nil {
				return err
			}

			// 实际的操作代码（乐观锁定中的本地操作）
			n++

			// 操作仅在 Watch 的 Key 没发生变化的情况下提交
			_, err = tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
				pipe.Set(ctx, key, n, 0)
				return nil
			})
			return err
		}

		// 最多重试 maxRetries 次
		for i := 0; i < maxRetries; i++ {
			err := rdb.Watch(ctx, txf, key)
			if err == nil {
				// 成功
				return nil
			}
			if err == redis.TxFailedErr {
				// 乐观锁丢失 重试
				continue
			}
			// 返回其他的错误
			return err
		}

		return errors.New("increment reached maximum number of retries")
	}

	// 模拟 routineCount 个并发同时去修改 counter3 的值
	var wg sync.WaitGroup
	wg.Add(routineCount)
	for i := 0; i < routineCount; i++ {
		go func() {
			defer wg.Done()
			if err := increment("counter3"); err != nil {
				fmt.Println("increment error:", err)
			}
		}()
	}
	wg.Wait()

	n, err := rdb.Get(context.TODO(), "counter3").Int()
	fmt.Println("ended with", n, err)
}

参考

Go语言操作Redis