La couche inférieure de go-redis et redigo est implémentée en appelant la méthode universelle Do, mais
redigo :
Puisque l'entrée est de type universel, vous devez vous souvenir des paramètres et renvoyer valeurs de chaque commande, il est très peu convivial à utiliser
Le type de paramètre est un type universel, donc le type de paramètre ne peut pas être vérifié pendant la phase de compilation
Chaque commande nécessite du temps pour enregistrer l'utilisation. méthode, nombre de paramètres, etc., et le coût d'utilisation est élevé ;
go-redis :
détaille les fonctions de chaque commande redis. Il suffit de mémoriser la commande et de vérifier directement l'application d'interface. pour un usage spécifique. Le coût d'utilisation est faible
Deuxièmement, il unifie le type de données en fonction du type de redis sous-jacent, ce qui peut aider à vérifier le type de paramètre lors de la compilation
Et sa réponse est renvoyée uniformément en utilisant l'interface de résultat, garantissant l'exactitude du type de paramètre renvoyé et le rendant plus convivial ;
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
Comme le montre la figure ci-dessus, bien que go-redis soit environ 10 % plus lent que redigo dans à chaque opération, redigo doit afficher la connexion application/fermeture, donc la différence de performances globale entre les deux est en fait. La petite
redigo est le client Go de la base de données Redis. Le fonctionnement de Redis est fondamentalement le même que les commandes. Les commandes Redigo sont essentiellement implémentées via la méthode Do.
Do(ctx context.Context, cmd string, args ...interface{}) (interface{}, error)Bien que l'appel des paramètres universels de la fonction Do puisse réaliser toutes les fonctions, mais il est très peu convivial à utiliser. Le type de paramètre est un type universel, donc le type de paramètre ne peut pas être vérifié pendant l'exécution. étape de compilation.Deuxièmement, chaque commande nécessite du temps pour enregistrer la méthode d'utilisation, le nombre de paramètres, etc., ce qui est coûteux à utiliser
Démontrer l'établissement de base du pool de connexions, le ping, les opérations de chaîne, les opérations de hachage, les opérations de liste, expirer et autres opérations
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)
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 fournit trois modes client correspondant au serveur, au cluster et à la sentinelle, et le mode autonome, les trois modes sont communs dans le pool de connexions, et fournit également un mécanisme Hook flexible, dont la couche inférieure est en fait la méthode universelle Do appelée
Mais go-redis affine chacun. Il suffit de se souvenir de la fonction de chaque commande redis. Pour une utilisation spécifique, nous pouvons directement. Vérifiez l'application de l'interface.Le coût d'utilisation est faible;Deuxièmement, il unifie le type de données en fonction du type de redis sous-jacent, ce qui peut aider à vérifier le type de paramètre, et sa réponse est renvoyée uniformément à l'aide de l'interface de résultat. assurer l'exactitude du type de paramètre renvoyé et le rendre plus convivial
Démontre l'établissement de base du pool de connexions, le ping, les opérations de chaîne, les opérations de hachage et les opérations de liste, l'expiration et d'autres opérations
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", 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 = &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())
}
})
}Sortie du résultat
goos : darwin
goarch : amd64
cpu : processeur Intel(R) Core(TM) i7-9750H à 2,60 GHz
BenchmarkRedis
BenchmarkRedis/redigo_client_Benchmark
BenchmarkRedis /redigo_client_Benchmark-12 26 386 39 110 ns/op
BenchmarkRedis /go-redis_client_Benchmark
BenchmarkRedis/go-redis_client_Benchmark-12 28186 37794 ns/op
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Logiciel de base de données couramment utilisé
Que sont les bases de données en mémoire ?
Lequel a une vitesse de lecture plus rapide, mongodb ou redis ?
Comment utiliser Redis comme serveur de cache
Comment Redis résout la cohérence des données
Comment MySQL et Redis assurent-ils la cohérence des doubles écritures ?
Quelles données le cache Redis stocke-t-il généralement ?
Quels sont les 8 types de données de Redis
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
