在结构体字段上实现 Redigo 扫描程序接口

Question

>我有一个看起来像这样的结构：

type authEnum int
const (
    never authEnum = iota
    sometimes
    always
)
type Attrs struct {
    Secret         string   `redis:"secret"`
    RequireSecret  authEnum `redis:"requireSecret"`
    UserID         string   `redis:"userId"`
}
func (e *authEnum) RedisScan(src interface{}) error {
    // This never gets called!
    if e == nil {
        return fmt.Errorf("nil pointer")
    }
    switch src := src.(type) {
    case string:
        if src == "false" || src == "never" {
            *e = never
        } else if src == "sometimes" {
            *e = sometimes
        } else { // "always" or "true"
            *e = always
        }
    default:
        return fmt.Errorf("cannot convert authEnum from %T to %T", src, e)
    }
    return nil
}
func getAttributes(ctx *AppContext, hash string) (*Attrs, error) {
    rc := ctx.RedisPool.Get()
    values, err := redis.Values(rc.Do("HGETALL", "redishash"))
    rc.Close()
    if err != nil {
        return nil, err
    }
    attrs := Attrs{}
    redis.ScanStruct(values, &attrs)
    return &attrs, nil
}

如何在 RequireSecret 属性上实现 Scanner 接口以解析 authEnum 类型，使其"never"、"sometimes"或 "always" redis 哈希值？

如何计算该值并将其分配给身份验证Enum？在我的代码示例中，RedisScan永远不会被调用。

Answer 1

您不是在字段上实现接口，而是在类型上实现接口。

可以使authEnum类型满足接口，只需在该类型上创建一个具有签名RedisScan(src interface{}) error的方法即可。

要分配给接收器，您需要接收指针。 然后，您可以按如下方式分配给它：

func (e *authEnum) RedisScan(src interface{}) error {
    var value authEnum
    // Logic here to convert src to value
    *e = value
}

Answer 2

在指针接收器上实现该方法。Redis 批量字符串表示为 []byte，而不是字符串：

func (e *authEnum) RedisScan(src interface{}) error {
    b, ok := src.([]byte)
    if !ok {
        return fmt.Errorf("cannot convert authEnum from %T to %T", src, b)
    }
    switch string(b) {
    case "false", "never":
        *e = never
    case "sometimes":
        *e = sometimes
    default:
        *e = always
    }
    return nil
}

始终检查和处理错误。从 ScanStruct 返回的错误报告类型问题。

无需检查指向结构成员的 nil 指针。如果 ScanStruct 的参数为 nil，那么 Redigo 会在调用 RedisScan 方法之前感到恐慌。