开发者

Go Redis客户端使用的两种对比

目录
  • 介绍
    • 性能对比
  • Redigo库
    • 演示
      • go-Redis组件介绍和使用
        • 演示
          •  性能测试

            介绍

            go-redis和redigo底层是通过调用的万能 Do 方法实现, 但是

            redigo:

            • 由于输入是万能类型所以必须记住每个命令的参数和返回值情况, 使用起来非常的不友好,
            • 参数类型是万能类型导致在编译阶段无法检查参数类型,
            • 每个命令都需要花时间记录使用方法,参数个数等,使用成本高;

            go-redis:

            • 细化了每个redis每个命令的功能, 我们只需记住命令,具体的用法直接查看接口的申请就可以了,使用成本低;
            • 其次它对数据类型按照redis底层的类型进行统一,编译时就可以帮助检查参数类型
            • 并且它的响应统一采用 Result 的接口返回,确保了返回参数类型的正确性,对用户更加友好;

            性能对比

            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-redijss_client_Benchmark-12   27127	     46451 ns/op

            从上图可以看出, go-redis虽然每次操作会比redigo慢10%左右, 但是redigo需要显示申请/关闭连接,所以总体上二者的性能差异其实不大

            Redigo库

            redigo 是Redis数开发者_NewSQL据库的Go客户端, 操作Redis基本和commands一样. Redigo命令基本都是通过Do方法来实现的.

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

            虽然调用Do函数万能参数可以实现所有的功能,但是使用起来非常的不友好,参数类型是万能类型,所以在编译阶段无法检查参数类型, 其次每个命令都需要花时间记录使用方法,参数个数等,使用成本高;

            演示

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

            package main
            import (
               "fmt"
               "github.com/gomodule/redigo/redis"
            )
            func main() {
               // 新建一个连接池
               var pool *redis.Pool
               pool = &redis.Pool{
                  MaxIdle:     10,  //最初的连接数量
                  MaxActive:   0,   //连接池最大连接数量,(0表示自动定义),按需分配
                  IdleTimeout: 300, //连接关闭时间 300秒 (300秒不使用自动关闭)
                  Dial: func() (redis.Conn, error) { //要连接的redis数据库
                     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)
               fmtjs.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机制, 其底层实际也是调用的万能 Do 方法.

            Go Redis客户端使用的两种对比

            但go-redis细化了每个redis每个命令的功能, 我们只需记住命令,具体的用法直接查看接口的申请就可以了,使用成本低;其次它对数据类型按照redis底层的类型进行统一,编译时就可以帮助检查参数类型, 并且它的响应统一采用 Result 的接口返回,确保了返回参数类型的正确性,对用户更加友好;

            演示

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

            func main() {
               var rdb = redis2.NewClient(
                  &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", python0).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 rehttp://www.devze.coms=%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 = &redis.Pool{
                  MaxIdle:     10,   //最初的连接数量
                  MaxActive:   1000, //连接池最大连接数量,(0表示自动定义),按需分配
                  IdleTimeout: 300,  //连接关闭时间 300秒 (300秒不使用自动关闭)
                  Dial: func() (redis.Conn, error) { //要连接的redis数据库
                     return redis.Dial("tcp", "localhost:6379")
                  },
               }
               var rdb = redis2.NewClient(
                  &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客户端使用对比的详细内容,更多关于Go Redis客户端对比的资料请关注我们其它相关文章!

            0

            上一篇:

            下一篇:

            精彩评论

            暂无评论...
            验证码 换一张
            取 消

            最新数据库

            数据库排行榜