GoFrame gredis快取DoVar及Conn連線物件的自動序列化

2022-06-14 10:00:43

前言

上一篇文章為大家介紹了 GoFrame gcache使用實踐 | 快取控制淘汰策略，得到了大家積極的反饋。

後續幾篇文章再接再厲，仍然為大家介紹GoFrame框架快取相關的知識點，以及自己專案使用中的一些總結思考，GoFrame框架下文簡稱gf。

這篇文章比較硬核，爆肝2千字，閱讀大約需要5~8分鐘。

詳細的介紹了gredis的使用，包括：Do/DoVar方法的使用及區別、複雜場景下使用Conn方法從連線池中獲取一個redis連線物件、當給定的引數為map, slice, struct時，gredis內部支援自動對其使用json序列化，並且讀取資料時可使用gvar.Var的轉換功能實現反序列化。

GoFrame gredis

整體介紹

Redis使用者端由gredis模組實現，底層採用了連結池設計。

gredis使用了連線池來進行Redis連線管理，通過Config設定物件或者Set*方法可以對連線池的屬性進行管理，通過Stats方法可以獲取連線池的統計資訊。

我們最常用的是Do/DoVar方法，執行同步指令，通過向Redis Server傳送對應的Redis API命令，來使用Redis Server的服務。Do/Var方法最大的特點是內部自行從連線池中獲取連線物件，使用完畢後自動丟回連線池中，開發者無需手動呼叫Close方法，方便使用。

Do/DoVar方法

我們最常用的是Do/DoVar方法，執行同步指令，通過向Redis Server傳送對應的Redis API命令，來使用Redis Server的服務。

Do/Var方法最大的特點是內部自行從連線池中獲取連線物件，使用完畢後自動丟回連線池中，開發者無需手動呼叫Close方法，方便使用。

小技巧

Do和DoVar的區別在於返回的結果型別不一樣，DoVar返回的是gvar.Var型別，該型別物件可以執行非常方便的型別轉換。

gvar.Var型別就像go原生提供的interface一樣，要了解更多的可以檢視這篇文章：GoFrame 通用型別變數gvar | 對比 interface{}

基本使用

package main
import (
	"fmt"
	"github.com/gogf/gf/frame/g"
)
func main() {
	g.Redis().Do("SET", "k", "v")
	v, _ := g.Redis().DoVar("GET", "k")
	fmt.Println(v.String())
}

HSET/HGETALL操作

Hset 命令用於為雜湊表中的欄位賦值。

如果雜湊表不存在，一個新的雜湊表被建立並進行 HSET 操作。

如果欄位已經存在於雜湊表中，舊值將被覆蓋。

package main
import (
	"fmt"
	"github.com/gogf/gf/container/gvar"
	"github.com/gogf/gf/frame/g"
)
func main() {
	var (
		err    error
		result *gvar.Var
		key    = "user"
	)
	_, err = g.Redis().Do("HSET", key, "id", 10000)
	if err != nil {
		panic(err)
	}
	_, err = g.Redis().Do("HSET", key, "name", "王中陽")
	if err != nil {
		panic(err)
	}
	result, err = g.Redis().DoVar("HGETALL", key)
	if err != nil {
		panic(err)
	}
	fmt.Println(result.Map()) //列印結果： map[id:10000 name:王中陽]
}

HMSET/HMGET操作

強烈推薦，非常好用：我們可以通過map引數執行HMSET操作。

package main
import (
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gutil"
)
func main() {
	var (
		key  = "user_100"
		data = g.Map{
			"name":  "王中陽",
			"sex":   0,
			"score": 100,
		}
	)
	_, err := g.Redis().Do("HMSET", append(g.Slice{key}, gutil.MapToSlice(data)...)...)
	if err != nil {
		g.Log().Fatal(err)
	}
	v, err := g.Redis().DoVar("HMGET", key, "name")
	if err != nil {
		g.Log().Fatal(err)
	}
	fmt.Println(v.Slice())  //列印結果 [王中陽]
}

我們也可以通過struct引數執行HMSET操作。

package main
import (
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gutil"
)
func main() {
	type User struct {
		Name  string `json:"name"`
		Sex   int    `json:"sex"`
		Score int    `json:"score"`
	}
	var (
		key  = "user_100"
		data = &amp;User{
			Name:  "王中陽",
			Sex:   0,
			Score: 100,
		}
	)
	_, err := g.Redis().Do("HMSET", append(g.Slice{key}, gutil.StructToSlice(data)...)...)
	if err != nil {
		g.Log().Fatal(err)
	}
	v, err := g.Redis().DoVar("HMGET", key, "name")
	if err != nil {
		g.Log().Fatal(err)
	}
	fmt.Println(v.Slice()) //列印結果： [王中陽]
}

Conn連線物件

使用Do/DoVar方法已經能夠滿足絕大部分的場景需要，如果需要更復雜的Redis操作，我們可以使用Conn方法從連線池中獲取一個連線物件，隨後使用該連線物件進行操作。

需要注意的是，該連線物件不再使用時，應當顯式呼叫Close方法進行關閉（丟回連線池）。

由於該Conn是個連線物件，注意該物件存在連線超時的限制，超時和伺服器端設定有關。

基本使用

package main
import (
    "fmt"
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/gf/util/gconv"
)
func main() {
    conn := g.Redis().Conn()
    defer conn.Close()
    conn.Do("SET", "k", "v")
    v, _ := conn.Do("GET", "k")
    fmt.Println(gconv.String(v)) //列印結果：v
}

Send批次指令

Send可以執行批次指令，並通過Receive方法一一獲取返回結果。

package main
import (
    "fmt"
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/gf/util/gconv"
)
func main() {
    conn := g.Redis().Conn()
    defer conn.Close()
    conn.Send("SET", "foo", "bar")
    conn.Send("GET", "foo")
    conn.Flush()
    // reply from SET
    conn.Receive()
    // reply from GET
    v, _ := conn.Receive()
    fmt.Println(gconv.String(v))  //列印結果：bar
}

讓我想到了之前寫的一篇爆文：Redis 如何批次設定過期時間？PIPLINE的使用

訂閱/釋出

我們可以通過Redis的SUBSCRIBE/PUBLISH命令實現訂閱/釋出模式。

package main
import (
    "fmt"
    "github.com/gogf/gf/frame/g"
    "github.com/gogf/gf/util/gconv"
)
func main() {
    conn := g.Redis().Conn()
    defer conn.Close()
    _, err := conn.Do("SUBSCRIBE", "channel")
    if err != nil {
        panic(err)
    }
    for {
        reply, err := conn.Receive()
        if err != nil {
            panic(err)
        }
        fmt.Println(gconv.Strings(reply))
    }
}

執行後，程式將阻塞等待獲取資料。

另外開啟一個終端通過redis-cli命令進入Redis Server，釋出一條訊息：

$ redis-cli
127.0.0.1:6379> publish channel test
(integer) 1
127.0.0.1:6379>

隨後程式終端立即列印出從Redis Server獲取的資料：

[message channel test]

自動序列化/反序列化

當給定的引數為map, slice, struct時，gredis內部支援自動對其使用json序列化，並且讀取資料時可使用gvar.Var的轉換功能實現反序列化。

map存取

package test
import (
   "fmt"
   "github.com/gogf/gf/container/gvar"
   "github.com/gogf/gf/frame/g"
)
func Run1() {
   var (
      err    error
      result *gvar.Var
      key    = "test_user"
      data   = g.Map{
         "id":   7,
         "name": "王中陽",
      }
   )
   _, err = g.Redis().Do("SET", key, data)
   if err != nil {
      panic(err)
   }
   result, err = g.Redis().DoVar("GET", key)
   if err != nil {
      panic(err)
   }
   fmt.Println("result:", result) //result: {"id":7,"name":"王中陽"}
   fmt.Println("result.Map():", result.Map()) //result.Map(): map[id:7 name:王中陽]
}

列印結果

struct存取

package test
import (
   "fmt"
   "github.com/gogf/gf/container/gvar"
   "github.com/gogf/gf/frame/g"
)
func Run1() {
   type User struct {
      Id   int
      Name string
   }
   var (
      err    error
      result *gvar.Var
      key    = "test_user"
      user   = &amp;User{
         Id:   007,
         Name: "王中陽",
      }
   )
   _, err = g.Redis().Do("SET", key, user)
   if err != nil {
      panic(err)
   }
   result, err = g.Redis().DoVar("GET", key)
   if err != nil {
      panic(err)
   }
   var user2 *User
   if err = result.Struct(&amp;user2); err != nil {
      panic(err)
   }
   fmt.Println("user2:", user2) //user2: &amp;{7 王中陽}
   fmt.Printf("id:%v, name:%v n", user2.Id, user2.Name) //id:7, name:王中陽
}

列印結果

總結

詳細的介紹了gredis的使用，包括：Do/DoVar方法的使用及區別、複雜場景下使用Conn方法從連線池中獲取一個redis連線物件、當給定的引數為map, slice, struct時，gredis內部支援自動對其使用json序列化，並且讀取資料時可使用gvar.Var的轉換功能實現反序列化，更多關於GoFrame gredis DoVar Conn連線物件自動序列化的資料請關注it145.com其它相關文章！