Go?Redis客戶端使用的兩種對比

更新時間：2022年07月27日 11:52:10 作者：Johns

這篇文章主要為大家介紹了Go?Redis客戶端使用對比詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪

介紹

go-redis和redigo底層是通過調(diào)用的萬能 Do 方法實現(xiàn), 但是

redigo:

由于輸入是萬能類型所以必須記住每個命令的參數(shù)和返回值情況, 使用起來非常的不友好，
參數(shù)類型是萬能類型導致在編譯階段無法檢查參數(shù)類型,
每個命令都需要花時間記錄使用方法，參數(shù)個數(shù)等，使用成本高；

go-redis:

細化了每個redis每個命令的功能, 我們只需記住命令，具體的用法直接查看接口的申請就可以了，使用成本低；
其次它對數(shù)據(jù)類型按照redis底層的類型進行統(tǒng)一，編譯時就可以幫助檢查參數(shù)類型
并且它的響應統(tǒng)一采用 Result 的接口返回，確保了返回參數(shù)類型的正確性，對用戶更加友好；

性能對比

BenchmarkRedis/redigo_client_Benchmark-12     31406	     36919 ns/op
BenchmarkRedis/go-redis_client_Benchmark-12   29977	     38152 ns/op
BenchmarkRedis/redigo_client_Benchmark-12     27928	     39923 ns/op
BenchmarkRedis/go-redis_client_Benchmark-12   27127	     46451 ns/op

從上圖可以看出, go-redis雖然每次操作會比redigo慢10%左右, 但是redigo需要顯示申請/關閉連接,所以總體上二者的性能差異其實不大

Redigo庫

redigo 是Redis數(shù)據(jù)庫的Go客戶端, 操作Redis基本和commands一樣. Redigo命令基本都是通過Do方法來實現(xiàn)的.

Do(ctx context.Context, cmd string, args ...interface{}) (interface{}, error)

雖然調(diào)用Do函數(shù)萬能參數(shù)可以實現(xiàn)所有的功能，但是使用起來非常的不友好，參數(shù)類型是萬能類型，所以在編譯階段無法檢查參數(shù)類型, 其次每個命令都需要花時間記錄使用方法，參數(shù)個數(shù)等，使用成本高；

演示

演示基本的連接池建立, ping, string操作, hash操作, list操作, expire等操作

package main
import (
   "fmt"
   "github.com/gomodule/redigo/redis"
)
func main() {
   // 新建一個連接池
   var pool *redis.Pool
   pool = &amp;redis.Pool{
      MaxIdle:     10,  //最初的連接數(shù)量
      MaxActive:   0,   //連接池最大連接數(shù)量,（0表示自動定義），按需分配
      IdleTimeout: 300, //連接關閉時間 300秒 （300秒不使用自動關閉）
      Dial: func() (redis.Conn, error) { //要連接的redis數(shù)據(jù)庫
         return redis.Dial("tcp", "localhost:6379")
      },
   }
   conn := pool.Get() //從連接池，取一個鏈接
   defer conn.Close()
   // 0. ping正常返回pong， 異常res is nil, err not nil
   res, err := conn.Do("ping")
   fmt.Printf("ping res=%v\n", res)
   if err != nil {
      fmt.Printf("ping err=%v\n", err.Error())
   }
   // string操作
   // set
   res, err = conn.Do("set", "name", "測試001")
   fmt.Printf("set res=%v\n", res)
   if err != nil {
      fmt.Printf("set err=%v\n", err.Error())
   }
   // get
   res, err = redis.String(conn.Do("get", "name"))
   fmt.Printf("get res=%v\n", res)
   if err != nil {
      fmt.Printf("get err=%v\n", err.Error())
   }
   // MSet   MGet
   res, err = conn.Do("MSet", "name", "測試001", "age", 18)
   fmt.Printf("MSet res=%v\n", res)
   if err != nil {
      fmt.Printf("MSet err=%v\n", err.Error())
   }
   r, err := redis.Strings(conn.Do("MGet", "name", "age"))
   fmt.Printf("MGet res=%v\n", r)
   if err != nil {
      fmt.Printf("MGet err=%v\n", err.Error())
   }
   // expire
   res, err = conn.Do("expire", "name", 5)
   fmt.Printf("expire res=%v\n", r)
   if err != nil {
      fmt.Printf("expire err=%v\n", err.Error())
   }
   // list操作
   // lpush lpop
   res, err = conn.Do("lpush", "hobby", "籃球", "足球", "乒乓球")
   fmt.Printf("lpush res=%v\n", r)
   if err != nil {
      fmt.Printf("lpush err=%v\n", err.Error())
   }
   // lpop
   rs, er := conn.Do("lpop", "hobby")
   fmt.Printf("lpop res=%v\n", rs)
   if er != nil {
      fmt.Printf("lpop err=%v\n", er.Error())
   }
   // hash 操作
   // hset
   res, err = conn.Do("HSet", "userinfo", "name", "lqz")
   fmt.Printf("HSet res=%v\n", r)
   if err != nil {
      fmt.Printf("HSet err=%v\n", err.Error())
   }
   // hget
   r4, er4 := conn.Do("HGet", "userinfo", "name")
   fmt.Printf("HGet res=%v\n", r4)
   if er4 != nil {
      fmt.Printf("HGet err=%v\n", er4.Error())
   }
}

go-redis組件介紹和使用

go-redis提供了三種對應服務端的客戶端模式，集群，哨兵，和單機模式，三種模式在連接池這一塊都是公用的, 同時還提供了靈活的Hook機制, 其底層實際也是調(diào)用的萬能 Do 方法.

但go-redis細化了每個redis每個命令的功能, 我們只需記住命令，具體的用法直接查看接口的申請就可以了，使用成本低；其次它對數(shù)據(jù)類型按照redis底層的類型進行統(tǒng)一，編譯時就可以幫助檢查參數(shù)類型, 并且它的響應統(tǒng)一采用 Result 的接口返回，確保了返回參數(shù)類型的正確性，對用戶更加友好；

演示

演示基本的連接池建立, ping, string操作, hash操作, list操作, expire等操作

func main() {
   var rdb = redis2.NewClient(
      &amp;redis2.Options{
         Addr:     "localhost:6379",
         Password: "", DB: 1,
         MinIdleConns: 1,
         PoolSize:     1000,
      })
   ctx := context.Background()
   res, err = rdb.Ping(ctx).Result()
   fmt.Printf("ping res=%v\n", res)
   if err != nil {
      fmt.Printf("ping err=%v\n", err.Error())
   }
   // string操作
   // set
   res, err = rdb.Set(ctx, "name", "測試001", 0).Result()
   fmt.Printf("set res=%v\n", res)
   if err != nil {
      fmt.Printf("set err=%v\n", err.Error())
   }
   // get
   res, err = rdb.Get(ctx, "name").Result()
   fmt.Printf("get res=%v\n", res)
   if err != nil {
      fmt.Printf("get err=%v\n", err.Error())
   }
   // MSet   MGet
   res, err = rdb.MSet(ctx, "name", "測試001", "age", "18").Result()
   fmt.Printf("MSet res=%v\n", res)
   if err != nil {
      fmt.Printf("MSet err=%v\n", err.Error())
   }
   var ret []interface{}
   ret, err = rdb.MGet(ctx, "name", "age").Result()
   fmt.Printf("MGet res=%v\n", ret)
   if err != nil {
      fmt.Printf("MGet err=%v\n", err.Error())
   }
   // expire
   res, err = rdb.Expire(ctx, "name", time.Second).Result()
   fmt.Printf("expire res=%v\n", res)
   if err != nil {
      fmt.Printf("expire err=%v\n", err.Error())
   }
   // list操作
   // lpush lpop
   res, err = rdb.LPush(ctx, "hobby", "籃球", "足球", "乒乓球").Result()
   fmt.Printf("lpush res=%v\n", res)
   if err != nil {
      fmt.Printf("lpush err=%v\n", err.Error())
   }
   // lpop
   rs, err = rdb.LPop(ctx, "hobby").Result()
   fmt.Printf("lpop res=%v\n", rs)
   if er != nil {
      fmt.Printf("lpop err=%v\n", er.Error())
   }
   // hash 操作
   // hset
   res, err = rdb.HSet(ctx, "userinfo", "name", "lqz").Result()
   fmt.Printf("HSet res=%v\n", r)
   if err != nil {
      fmt.Printf("HSet err=%v\n", err.Error())
   }
   // hget
   r4, er4 = rdb.HGet(ctx, "userinfo", "name").Result()
   fmt.Printf("HGet res=%v\n", r4)
   if er4 != nil {
      fmt.Printf("HGet err=%v\n", er4.Error())
   }
}

性能測試

package main
import (
   "context"
   redis2 "github.com/go-redis/redis/v8"
   "github.com/gomodule/redigo/redis"
   "testing"
   "time"
)
func BenchmarkRedis(b *testing.B) {
   // 新建一個連接池
   var pool *redis.Pool
   pool = &amp;redis.Pool{
      MaxIdle:     10,   //最初的連接數(shù)量
      MaxActive:   1000, //連接池最大連接數(shù)量,（0表示自動定義），按需分配
      IdleTimeout: 300,  //連接關閉時間 300秒 （300秒不使用自動關閉）
      Dial: func() (redis.Conn, error) { //要連接的redis數(shù)據(jù)庫
         return redis.Dial("tcp", "localhost:6379")
      },
   }
   var rdb = redis2.NewClient(
      &amp;redis2.Options{
         Addr:         "localhost:6379",
         Password:     "",
         MinIdleConns: 10,
         PoolSize:     1000,
      })
   b.Run("redigo client Benchmark", func(b *testing.B) {
		for j := 0; j < b.N; j++ {
			conn := pool.Get() //從連接池，取一個鏈接
			conn.Do("set", time.Now().String(), 10000, time.Second)
			conn.Do("get", time.Now().String())
			conn.Close()
		}
	})
	ctx := context.Background()
	b.Run("go-redis client Benchmark", func(b *testing.B) {
		for j := 0; j < b.N; j++ {
			rdb.Set(ctx,  time.Now().String(), 1000, time.Second)
			rdb.Get(ctx,  time.Now().String())
		}
	})
}

結果輸出

goos: darwin
goarch: amd64
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkRedis
BenchmarkRedis/redigo_client_Benchmark
BenchmarkRedis/redigo_client_Benchmark-12 26386 39110 ns/op
BenchmarkRedis/go-redis_client_Benchmark
BenchmarkRedis/go-redis_client_Benchmark-12 28186 37794 ns/op

以上就是Go Redis客戶端使用對比的詳細內(nèi)容，更多關于Go Redis客戶端對比的資料請關注腳本之家其它相關文章！

您可能感興趣的文章: