本文作者：anker
源码
https://github.com/go-redis/redis
下面样例用到的是 github.com/go-redis/[email protected]
怎么用？
一般拿到一个框架，我们下意识会去搜索引擎看看怎么用。
《Go操作Redis实战》是一篇很好的文章，介绍了基本所有数据类型的基本操作，可以在本文后阅读一下。
下面提取了文中一个代码样例，大致看看就行。
package main
import (
"context"
"fmt"
"github.com/go-redis/redis/v8"
"time"
)
var ctx = context.Background()
func main() {
rdb := redis.NewClient(&redis.Options{
Addr: "172.16.147.128:6379",
Password: "",
DB: 0,
})
_, err := rdb.Ping(ctx).Result()
//fmt.Println(pong, err)
if err != nil {
fmt.Printf("连接redis出错，错误信息：%v", err)
return
}
//Set方法的最后一个参数表示过期时间，0表示永不过期
err = rdb.Set(ctx, "key1", "value1", 0).Err()
if err != nil {
panic(err)
}
//key2将会在两分钟后过期失效
err = rdb.Set(ctx, "key2", "value2", time.Minute * 2).Err()
if err != nil {
panic(err)
}
}
是关于 set 命令的基本用法的。set key1 value1 看似没有太大毛病，实际上在实战中，存在的大量存储结构体的需求。那么有没有一种办法可以实现结构体存储的需求呢？
结构体存储
简单实现
下方有个不太优雅的实现，每次设置前都用 json.Marshal（或其他编码方法）对结构体进行编码后，再调用方法进行设置。那么相对应的，获取数据先获取数据内容，然后通过 json.Unmarshal (或其他解码方法) 还原数据结构体。
（这也太不好使了吧？）
package main
import (
"context"
"encoding/json"
"github.com/go-redis/redis/v8"
)
var ctx = context.Background()
type myStruct struct {
UserId int64 `json:"user_id"`
UserName string `json:"user_name"`
}
func main() {
rdb := redis.NewClient(&redis.Options{
Addr: "172.16.147.128:6379",
Password: "",
DB: 0,
})
data := &myStruct{
UserId: 123,
UserName: "anker",
}
b, err := json.Marshal(data)
if err != nil {
panic(err)
}
err = rdb.Set(ctx, "key1", string(b), 0).Err()
if err != nil {
panic(err)
}
}
其他更优处理手法？
那是肯定有的！
这里是 Set 方法的定义：
func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
细心的同学可能已经发现了，value 接受的是一个 interface{} 类型的参数，那么意味着这里可以传入任意参数，那么传入结构体指针行不行呢？我们来看看源码。
// internal/proto/writer.go
func (w *Writer) WriteArg(v interface{}) error {
switch v := v.(type) {
case nil:
return w.string("")
case string:
return w.string(v)
case []byte:
return w.bytes(v)
case int:
return w.int(int64(v))
case int8:
return w.int(int64(v))
case int16:
return w.int(int64(v))
case int32:
return w.int(int64(v))
case int64:
return w.int(v)
case uint:
return w.uint(uint64(v))
case uint8:
return w.uint(uint64(v))
case uint16:
return w.uint(uint64(v))
case uint32:
return w.uint(uint64(v))
case uint64:
return w.uint(v)
case float32:
return w.float(float64(v))
case float64:
return w.float(v)
case bool:
if v {
return w.int(1)
}
return w.int(0)
case time.Time:
w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
return w.bytes(w.numBuf)
case encoding.BinaryMarshaler:
b, err := v.MarshalBinary()
if err != nil {
return err
}
return w.bytes(b)
default:
return fmt.Errorf(
"redis: can't marshal %T (implement encoding.BinaryMarshaler)", v)
}
}
经过阅读源码看到，在 go-redis 内，有这么一段 redis 协议的写入值的方法，里面通过判断写入值类型来进行编码。go-redis 已经支持了所有的 go 基本数据类型（int,strting...）。
值得注意的是，里面判断了 value 是否实现 encoding.BinaryMarshaler（ interface），然后调用实现了 interface 的方法 MarshalBinary 进行编码成 []byte。redis 的值是二进制安全的，可以支持任意二进制编码。
更优的实现
通过上面的源码我们可以知道，可以通过实现 encoding.BinaryMarshaler 来进行结构体存储。
直接上代码
package main
import (
"context"
"encoding"
"encoding/json"
"fmt"
"github.com/go-redis/redis/v8"
)
var _ encoding.BinaryMarshaler = new(myStruct2)
var _ encoding.BinaryUnmarshaler = new(myStruct2)
type myStruct2 struct {
UserId string `json:"user_id"`
UserName string `json:"user_name"`
}
func (m *myStruct2) MarshalBinary() (data []byte, err error) {
return json.Marshal(m)
}
func (m *myStruct2) UnmarshalBinary(data []byte) error {
return json.Unmarshal(data, m)
}
func main() {
var ctx = context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379",
Password: "",
DB: 0,
})
data := &myStruct2{
UserId: "123",
UserName: "anker",
}
err := rdb.Set(ctx, "key1", data, 0).Err()
if err != nil {
panic(err)
}
result := &myStruct2{}
err = rdb.Get(ctx, "key1").Scan(result)
if err != nil {
panic(err)
}
fmt.Println("get success:", data.UserId == result.UserId)
}
通过实现 encoding.BinaryMarshaler 和 encoding.BinaryUnmarshaler，能够简化很多业务代码，而且统一了维护编码的实现位置，方便管理。
实际上不仅只有 string 支持这种操作， set，list，sorted set等数据结构也可以进行如此从走，通过 ScanSlice 方法，直接批量获取结构体 Slice，操作起来更加灵活自由。
优化升级
如果一开始 json 用着还行，后面想优化一下编码怎么办呢？下面展现了一个自定义且兼容 json 编码的实现。这样实现起来会更加的灵活。
func (m *myStruct2) MarshalBinary() (data []byte, err error) {
// 版本1
// return json.Marshal(m)
// 后来觉得 json太占空间内容了，所以有了后面的实现
// 版本2
b := bytes.NewBuffer(nil)
b.WriteString(m.UserId)
b.WriteByte('\t')
b.WriteString(m.UserName)
return b.Bytes(), nil
}
func (m *myStruct2) UnmarshalBinary(data []byte) error {
// 先按照 json 解析
err := json.Unmarshal(data, m)
if err == nil {
// 解析成功直接返回
return nil
}
// 前面失败，按照 \t 分割解析
results := bytes.Split(data, []byte{'\t'})
if len(results) != 2 {
return errors.New("not valid format")
}
m.UserId = string(results[0])
m.UserName = string(results[1])
return nil
}