使用 Golang、redis 和时间进行测试

Question

我第一次尝试使用 Redis 进行一些测试，但遇到了一些关于 HGET/HSET/HGETALL 的困惑。我的主要问题是我需要存储时间，我想使用散列，因为我会不断更新时间。

起初我读到 MarshalBinary 函数如何拯救我：

func (f Foo) MarshalBinary() ([]byte, error) {
    return json.Marshal(f)
}

所做的是将结构保存为 json 字符串，但仅作为字符串而不是实际的 Redis 哈希。我最终做的是一个相当大的样板代码，它使我想要保存到地图中的结构，并且该结构作为哈希正确存储在 Redis 中。

type Foo struct {
    Number int       `json:"number"`
    ATime  time.Time `json:"atime"`
    String string    `json:"astring"`
}

func (f Foo) toRedis() map[string]interface{} {
    res := make(map[string]interface{})
    rt := reflect.TypeOf(f)
    rv := reflect.ValueOf(f)
    if rt.Kind() == reflect.Ptr {
        rt = rt.Elem()
        rv = rv.Elem()
    }
    for i := 0; i < rt.NumField(); i++ {
        f := rt.Field(i)
        v := rv.Field(i)
        switch t := v.Interface().(type) {
        case time.Time:
            res[f.Tag.Get("json")] = t.Format(time.RFC3339)
        default:
            res[f.Tag.Get("json")] = t
        }
    }
    return res
}

然后在调用 HGetAll(..).Result() 时解析回我的 Foo 结构，我将结果作为 map[string]string 并使用这些函数创建一个新的 Foo：

func setRequestParam(arg *Foo, i int, value interface{}) {
    v := reflect.ValueOf(arg).Elem()
    f := v.Field(i)
    if f.IsValid() {
        if f.CanSet() {
            if f.Kind() == reflect.String {
                f.SetString(value.(string))
                return
            } else if f.Kind() == reflect.Int {
                f.Set(reflect.ValueOf(value))
                return
            } else if f.Kind() == reflect.Struct {
                f.Set(reflect.ValueOf(value))
            }
        }
    }
}

func fromRedis(data map[string]string) (f Foo) {
    rt := reflect.TypeOf(f)
    rv := reflect.ValueOf(f)

    for i := 0; i < rt.NumField(); i++ {
        field := rt.Field(i)
        v := rv.Field(i)
        switch v.Interface().(type) {
        case time.Time:
            if val, ok := data[field.Tag.Get("json")]; ok {
                if ti, err := time.Parse(time.RFC3339, val); err == nil {
                    setRequestParam(&f, i, ti)
                }
            }
        case int:
            if val, ok := data[field.Tag.Get("json")]; ok {
                in, _ := strconv.ParseInt(val, 10, 32)
                setRequestParam(&f, i, int(in))

            }
        default:
            if val, ok := data[field.Tag.Get("json")]; ok {
                setRequestParam(&f, i, val)
            }
        }
    }
    return
}

不光彩的整个代码是here

我在想一定有更明智的方法来解决这个问题？还是我被迫做这样的事情？我需要存储的结构只包含整数、字符串和 time.Times.

*编辑评论字段有点短，所以改为编辑：

我最初确实按照 'The Fool' 在评论和答案中建议的那样解决了它。我更改为上述部分的原因是，虽然解决方案更复杂，但我认为它对于更改更健壮。如果我使用硬编码地图解决方案，我“必须”拥有：

具有字段散列键的常量，因为它们至少会在两个地方使用（从和到 Redis），所以编译器不会发现愚蠢的错误。当然可以跳过，但知道我自己的拼写很可能会发生
如果有人只是想添加一个新的字段并且不太了解代码，它会编译得很好，但不会在 Redis 中添加新的字段。一个容易犯的错误，特别是对于有点天真的初级开发人员，或过于自信的高级开发人员。
我可以将这些辅助函数放入一个库中，当需要时间或复杂类型时，我们所有的代码都会神奇地工作。

不过我的意图 question/hope 是：我真的必须像这样跳过箍才能使用 go 将时间存储在 Redis 哈希中吗？公平地说，time.Time 不是原语，Redis 也不是 (no)sql 数据库，但我认为缓存中的时间戳是一个非常常见的用例（在我的例子中是跟踪的心跳）超时会话连同足以永久存储它的元数据，因此需要更新它们）。但也许我滥用了 Redis，我宁愿有两个条目，一个用于数据，一个用于时间戳，这样我就可以使用两个简单的 get/set 函数接收 time.Time 并返回 time.Time.

Answer 1

您可以使用 redigo/redis#Args.AddFlat 将结构转换为 Redis 哈希，我们可以使用 redis 标记映射值。

package main

import (
  "fmt"

  "time"
  "github.com/gomodule/redigo/redis"
)

type Foo struct {
    Number  int64     `json:"number"  redis:"number"`
    ATime   time.Time `json:"atime"   redis:"atime"`
    AString string    `json:"astring" redis:"astring"`
}

func main() {
  c, err := redis.Dial("tcp", ":6379")
  if err != nil {
    fmt.Println(err)
    return
  }
  defer c.Close()

  t1 := time.Now().UTC()
  var foo Foo
  foo.Number = 10000000000
  foo.ATime = t1
  foo.AString = "Hello"

  tmp := redis.Args{}.Add("id1").AddFlat(&foo)
  if _, err := c.Do("HMSET", tmp...); err != nil {
    fmt.Println(err)
    return
  }

  v, err := redis.StringMap(c.Do("HGETALL", "id1"))
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Printf("%#v\n", v)
}

然后要更新 ATime 你可以使用 redis HSET

if _, err := c.Do("HMSET", "id1", "atime", t1.Add(-time.Hour * (60 * 60 * 24))); err != nil {
  fmt.Println(err)
  return
}

为了将它检索回结构，我们必须做一些reflect魔术

func structFromMap(src map[string]string, dst interface{}) error {
  dt := reflect.TypeOf(dst).Elem()
  dv := reflect.ValueOf(dst).Elem()

  for i := 0; i < dt.NumField(); i++ {
    sf := dt.Field(i)
    sv := dv.Field(i)
    if v, ok := src[strings.ToLower(sf.Name)]; ok {
      switch sv.Interface().(type) {
        case time.Time:
          format := "2006-01-02 15:04:05 -0700 MST"
          ti, err := time.Parse(format, v)
          if err != nil {
            return err
          }
          sv.Set(reflect.ValueOf(ti))
        case int, int64:
          x, err := strconv.ParseInt(v, 10, sv.Type().Bits())
          if err != nil {
            return err
          }
          sv.SetInt(x)
        default:
          sv.SetString(v)
      }
    }
  }

  return nil
}

最终代码

package main

import (
  "fmt"

  "time"
  "reflect"
  "strings"
  "strconv"

  "github.com/gomodule/redigo/redis"
)

type Foo struct {
    Number  int64     `json:"number"  redis:"number"`
    ATime   time.Time `json:"atime"   redis:"atime"`
    AString string    `json:"astring" redis:"astring"`
}

func main() {
  c, err := redis.Dial("tcp", ":6379")
  if err != nil {
    fmt.Println(err)
    return
  }
  defer c.Close()

  t1 := time.Now().UTC()
  var foo Foo
  foo.Number = 10000000000
  foo.ATime = t1
  foo.AString = "Hello"

  tmp := redis.Args{}.Add("id1").AddFlat(&foo)
  if _, err := c.Do("HMSET", tmp...); err != nil {
    fmt.Println(err)
    return
  }

  v, err := redis.StringMap(c.Do("HGETALL", "id1"))
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Printf("%#v\n", v)

  if _, err := c.Do("HMSET", "id1", "atime", t1.Add(-time.Hour * (60 * 60 * 24))); err != nil {
    fmt.Println(err)
    return
  }

  var foo2 Foo
  structFromMap(v, &foo2)
  fmt.Printf("%#v\n", foo2)
}

func structFromMap(src map[string]string, dst interface{}) error {
  dt := reflect.TypeOf(dst).Elem()
  dv := reflect.ValueOf(dst).Elem()

  for i := 0; i < dt.NumField(); i++ {
    sf := dt.Field(i)
    sv := dv.Field(i)
    if v, ok := src[strings.ToLower(sf.Name)]; ok {
      switch sv.Interface().(type) {
        case time.Time:
          format := "2006-01-02 15:04:05 -0700 MST"
          ti, err := time.Parse(format, v)
          if err != nil {
            return err
          }
          sv.Set(reflect.ValueOf(ti))
        case int, int64:
          x, err := strconv.ParseInt(v, 10, sv.Type().Bits())
          if err != nil {
            return err
          }
          sv.SetInt(x)
        default:
          sv.SetString(v)
      }
    }
  }

  return nil
}

注意：struct字段名与redis标签匹配

使用 Golang、redis 和时间进行测试

Testing with Golang, redis and time

go

redigo

最终代码