基本使用

    Do和DoVar的区别在于返回的结果类型不一样，DoVar返回的是gvar.Var类型，该类型对象可以执行非常方便的类型转换。

    使用Do/DoVar方法已经能够满足绝大部分的场景需要，如果需要更复杂的Redis操作，那么我们可以使用Conn方法从连接池中获取一个连接对象，随后使用该连接对象进行操作。但需要注意的是，该连接对象不再使用时，应当显示调用Close方法进行关闭（丢回连接池）。

    执行后，输出结果为：

    1. v

    Send可以执行批量指令，并通过Receive方法一一获取返回结果。

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/frame/g"
    6.     "github.com/gogf/gf/util/gconv"
    7. )
    9. func main() {
    10.     conn := g.Redis().Conn()
    11.     defer conn.Close()
    12.     conn.Send("SET", "foo", "bar")
    13.     conn.Send("GET", "foo")
    14.     conn.Flush()
    15.     // reply from SET
    16.     conn.Receive()
    17.     // reply from GET
    18.     v, _ := conn.Receive()
    19.     fmt.Println(gconv.String(v))
    20. }
    1. package main
    3. import (
    4.     "fmt"
    6.     "github.com/gogf/gf/util/gconv"
    7. )
    9. func main() {
    10.     conn := g.Redis().Conn()
    11.     defer conn.Close()
    12.     if err != nil {
    13.         panic(err)
    14.     }
    15.     for {
    16.         reply, err := conn.Receive()
    17.         if err != nil {
    18.             panic(err)
    19.         }
    20.         fmt.Println(gconv.Strings(reply))
    21.     }
    22. }

    执行后，程序将阻塞等待获取数据。

    另外打开一个终端通过redis-cli命令进入Redis Server，发布一条消息：

    1. $ redis-cli
    2. 127.0.0.1:6379> publish channel test
    3. (integer) 1
    4. 127.0.0.1:6379>

    当给定的参数为map, slice, struct时，gredis内部支持自动对其使用json序列化，并且读取数据时可使用gvar.Var的转换功能实现反序列化。

    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gvar"
    6.     "github.com/gogf/gf/frame/g"
    7. )
    9. func main() {
    10.     var (
    11.         err    error
    12.         result *gvar.Var
    13.         key    = "user"
    14.         data   = g.Map{
    15.             "id":   10000,
    16.             "name": "john",
    17.         }
    18.     )
    20.     if err != nil {
    21.         panic(err)
    22.     }
    23.     result, err = g.Redis().DoVar("GET", key)
    24.     if err != nil {
    25.         panic(err)
    26.     fmt.Println(result.Map())
    27. }
    1. package main
    3. import (
    4.     "fmt"
    5.     "github.com/gogf/gf/container/gvar"
    6.     "github.com/gogf/gf/frame/g"
    7. )
    9. func main() {
    10.     type User struct {
    11.         Id   int
    12.         Name string
    13.     }
    14.     var (
    15.         err    error
    16.         result *gvar.Var
    17.         key    = "user"
    18.         user   = &User{
    19.             Id:   10000,
    20.             Name: "john",
    21.         }
    22.     )
    24.     _, err = g.Redis().Do("SET", key, user)
    25.     if err != nil {
    26.         panic(err)
    27.     }
    28.     result, err = g.Redis().DoVar("GET", key)
    29.     if err != nil {
    30.         panic(err)
    31.     }
    33.     var user2 *User
    34.     if err = result.Struct(&user2); err != nil {
    35.         panic(err)
    36.     }
    37.     fmt.Println(user2.Id, user2.Name)
    38. }