golang-redis系列——redigo返回值助手函数(二)

站长

2023年02月18日 18:40 · 阅读数 16

1、redigo客户端的返回值解析

从上一节的内容可知，Do() 和 Receive() 等方法的返回值，除了 error 外，是一个 interface{} 类型的返回值，因此当我们的复杂操作返回的不是基本数据类型时，就需要我们自己解析返回值，例如，当我们利用 HMGET 方法获取一批返回值时，就需要对返回结果进行解析，具体如下：

	var param = map[string][]int64{
		"153_35_2": []int64{10, 20, 30},
		"153_35_1": []int64{1, 2, 3},
		"153_35_3": []int64{100, 200, 300},
	}

	_, err := rc.Do("HMSET", redis.Args{}.Add("redis-hash").AddFlat(param)...)
	if err != nil {
		fmt.Println("cacheModelInfo error:", err.Error())
		return
	}

	fmt.Println("insert ok")

	reply, _ := rc.Do("HGETALL", "redis-hash")

	for i,v := range reply.([]interface{}){
		fmt.Println(string(v.([]uint8)))
	}
---------------------------------------------------
返回结果：
insert ok
153_35_2
[10 20 30]
153_35_1
[1 2 3]
153_35_3
[100 200 300]

由于返回值是多条数据，因此需要先将 reply 转成 []interface 类型，然后在遍历结果时在分别转成 []uint8 (byte数组)，最后再转成 string 类型。

写入时 vaule 为 []int64，为什么读出来是 string 类型呢？

这是因为 Redis hash 是一个 string 类型的 field（字段）和 value（值）的映射表，hash 特别适合用于存储对象。 Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。

Redis Hash

随着我们操作复杂度，数据解析的工作量也会非常大，(lua 脚本的使用，会使结果的解析更为复杂，因为可能存在多种类型的结果一起返回的情况，lua 脚本相关的内容会在下一节介绍)。

redigo 包中的返回值助手函数的存在，就是为了帮助我们完成这些枯燥繁琐的数据解析过程。

2、redigo 返回值助手函数

返回值助手函数相关源码路径为 github.com/gomodule/redigo/redis/reply.go 提供的主要方法如下：

方法	说明
func Int(reply interface{}, err error) (int, error)	将返回值转为 int 类型数据
Int64(reply interface{}, err error) (int64, error)	将返回值转为 int64 类型数据
Uint64(reply interface{}, err error) (uint64, error)	将返回值转为 uint64 类型数据
func Float64(reply interface{}, err error) (float64, error)	将返回值转为 float64 类型数据
func String(reply interface{}, err error) (string, error)	将返回值转为 string 类型数据
func Bytes(reply interface{}, err error) ([]byte, error)	将返回值转为 []byte 类型数据,通常用于解析某些编码数据，例如protobuf 或者 json等
Bool(reply interface{}, err error) (bool, error)	将返回值转为 bool 类型数据
func Values(reply interface{}, err error) ([]interface{}, error)	将返回值转为 []interface 类型数据,一般用于分解复杂结构，例如 lua 脚本的聚合结果
func Float64s(reply interface{}, err error) ([]float64, error)	将返回值转为 []float 类型数据
func Strings(reply interface{}, err error) ([]string, error)	将返回值转为 []string 类型数据
func ByteSlices(reply interface{}, err error) ([][]byte, error)	将返回值转为 [][]byte 类型数据,通常用于解析某些编码数据数组，例如protobuf 或者 json等
func Int64s(reply interface{}, err error) ([]int64, error)	将返回值转为 []int64 类型数据
func Ints(reply interface{}, err error) ([]int, error)	将返回值转为 []int 类型数据
func StringMap(result interface{}, err error) (map[string]string, error)	将返回值转为 map[string]string 类型数据,通常用于 HMGET、MGET、HGETALL 等场景
func IntMap(result interface{}, err error) (map[string]int, error)	将返回值转为 map[string]int 类型数据，通常用于value 类型为 int 的 HMGET、MGET、HGETALL
func Int64Map(result interface{}, err error) (map[string]int64, error)	将返回值转为 map[string]int64 类型数据通常用于value 类型为 int64 的 HMGET、MGET、HGETALL
func Uint64s(reply interface{}, err error) ([]uint64, error)	将返回值转为 []uint64 类型数据
func Uint64Map(result interface{}, err error) (map[string]uint64, error)	将返回值转为 map[string]uint64 类型数据
func SlowLogs(result interface{}, err error) ([]SlowLog, error)	将返回值转为 []SlowLog 类型数据，主要用于获取慢查询日志
func Positions(result interface{}, err error) ([]*[2]float64, error)	将返回值转为 []*[2]float64 类型数据，主要用于 GEOPOS 命令的返回

上述返回值助手函数的具体使用，应该依据具体的命令进行选择。如果大家还记得上一节介绍的 Redis 基本数据类型，可能会有些疑问，对于 redis 来说，其数据据存储本质都是 []bytes，为什么可以解析出 Int、int64、float等类型的数据呢？

我们以 Float64() 为例进行说明，具体源码如下：

func Float64(reply interface{}, err error) (float64, error) {
	if err != nil {
		return 0, err
	}
	switch reply := reply.(type) {
	case []byte:
		n, err := strconv.ParseFloat(string(reply), 64)
		return n, err
	case nil:
		return 0, ErrNil
	case Error:
		return 0, reply
	}
	return 0, fmt.Errorf("redigo: unexpected type for Float64, got type %T", reply)
}

其实，返回值助手函数是将 []byte 类型的原始数据，利用 strconv.ParseFloat(string(reply), 64) 转换成了 float64类型，因此在我们使用过程中返回值助手函数的选择，应该基于业务和实际存储的数据格式为依据。我们以第一小节的示例为例，看返回值助手函数如何降低我们的工作量，具体如下：

reply,_ := redis.StringMap(rc.Do("HGETALL", "redis-hash"))
for k,v := range reply{
    fmt.Println(k,":",v)
}

---------------------------------------------------------------
153_35_2 : [10 20 30]
153_35_1 : [1 2 3]
153_35_3 : [100 200 300]


reply,_ := redis.Strings(rc.Do("HGETALL", "redis-hash"))
for _,v := range reply{
    fmt.Println(v)
}
---------------------------------------------------------------
153_35_2
[10 20 30]
153_35_1
[1 2 3]
153_35_3
[100 200 300]

3、Scan 方法解析复杂结构

除了使用返回值助手函数对上述固定结构的结果进行解析外，redigo 包还提供了一个 Scan()函数用于解析自定义的复杂数据结构，我们依然以上一个示例进行说明,具体示例如下：

	rc := RedisClientPool.Get()
	defer func() {
		rcErr := rc.Close()
		if rcErr != nil {
			fmt.Printf("Cache init redis client close err: %s", rcErr.Error())
		}
	}()

	var param = map[string][]int64{
		"153_35_2": []int64{10, 20, 30},
		"153_35_1": []int64{1, 2, 3},
		"153_35_3": []int64{100, 200, 300},
	}

	_, err := rc.Do("HMSET", redis.Args{}.Add("redis-hash").AddFlat(param)...)
	if err != nil {
		fmt.Println("cacheModelInfo error:", err.Error())
		return
	}

	fmt.Println("insert ok")

	reply,_ := redis.Values(rc.Do("HGETALL", "redis-hash"))

	fmt.Println(reply)

	for len(reply) > 0 {
		var key string
		var value string
		reply, err = redis.Scan(reply, &key, &value)
		if err != nil {
			fmt.Println(err)
			return
		}
		fmt.Println(key,":",value)
	}

--------------------------------------------------------------------------------
Output:
153_35_2 : [10 20 30]
153_35_1 : [1 2 3]
153_35_3 : [100 200 300]

Scan 函数从 src 扫描副本到 dest 指向的值。

dest 指向的值必须是整数、浮点数、布尔值、字符串、[]byte、interface{} 或这些类型的切片。扫描使用标准的 strconv 包将字符串转换为数字和布尔类型。

如果 dest 值为 nil，则跳过相应的 src 值。

如果 src 元素为 nil，则不修改对应的 dest 值。

为了在循环中轻松使用 Scan，Scan 返回的结果为 src 切片扫描之后剩余的部分。

如果返回结果为结构化切片，也可以使用 canSlice() 方法，从而简化 loop 处理的部分，具体示例如下：

    var result []struct {
		Key string
		Value string
	}
	if err := redis.ScanSlice(reply, &result); err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%v\n", result)

---------------------------------------------------------
Output:
[
    {153_35_2 [10 20 30]} 
    {153_35_1 [1 2 3]} 
    {153_35_3 [100 200 300]}
]

通过上述的示例，我们介绍了 scan 函数的基本用法，但是细心的同学可能会发现吗，为什么数据写入时，value 的类型为 []int64 但是读取时只能按照 string 类型读取呢。这是因为 Redis 底层存储的数据本质都是 string 类型，。无论是 HMSET 还是 MSET 最终都只能按照 string 类型读取，因为其本质都是 hash 结构，不同之处仅在于 HMSET 是嵌套的 hash类型。 因此，[]int64 数据在写入阶段，就已经被自动处理为 []byte，写入 redis 之后，len 和类型属性会丢失。

如果强行按照 []int64解析将出错：

    var result []struct {
		Key string
		Value []int64
	}
	if err := redis.ScanSlice(reply, &result); err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%v\n", result)

-----------------------------------------------------------
redigo.ScanSlice: cannot assign element 1 to field Value: cannot convert from Redis bulk string to []int64

如果 value 必须以结构化的数据存储，那么可以提前对要写入的数据进行编码，例如 json、protobuf 等，取出后再进行解码获得原始数据。