使用 Golang、redis 和 time 进行测试

学习Golang要努力，但是不要急！今天的这篇文章《使用 Golang、redis 和 time 进行测试》将会介绍到等等知识点，如果你想深入学习Golang，可以关注我！我会持续更新相关文章的，希望对大家都能有所帮助！

我第一次尝试使用 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
}

整个代码的不光彩都在这里

我在想一定有更明智的方法来解决这个问题吗？或者我被迫做这样的事情？我需要存储的结构仅包含整数、字符串和时间。

*编辑 评论字段有点短，因此请进行编辑：

我最初确实像评论中建议的“傻瓜”和答案一样解决了这个问题。我之所以更改为上述部分，虽然解决方案更复杂，但我认为它对于更改来说更稳健。如果我采用硬编码地图解决方案，我“必须”具有：

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

我想要的问题/希望是：我真的必须像这样跳过障碍才能用 go 将时间存储在 redis 哈希中吗？公平，time.time 不是一个基元，redis 也不是一个（无）sql 数据库，但我认为缓存中的时间戳是一个非常常见的用例（在我的例子中，是一个心跳来跟踪超时会话和元数据）足以永久存储它，因此需要更新它们）。但也许我误用了 redis，我应该有两个条目，一个用于数据，一个用于时间戳，这样我就只剩下两个简单的 get/set 函数，接收 time.time 并返回 time.time。

正确答案

您可以使用 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
}

注意：结构体字段名称与 redis 标记匹配

本篇关于《使用 Golang、redis 和 time 进行测试》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！