requête par lots Redis Golang

Redis est un système de stockage de structures de données en mémoire open source qui prend en charge une variété de structures de données, telles que des chaînes, des hachages, des listes, des ensembles, etc. Golang est un langage compilé efficace, fortement typé, doté d'excellentes capacités de traitement simultané. Dans le développement Golang, Redis est un excellent choix. Il peut fournir des services de stockage et d'accès aux données hautes performances et haute fiabilité pour les programmes. Cet article explique comment effectuer des opérations de requête par lots Redis dans Golang.

1. Connexion à Redis

Tout d'abord, vous devez utiliser le package redis intégré du langage Go pour vous connecter à Redis. La connexion à Redis est très simple, il suffit d'utiliser la fonction redis.NewClient(). Cette fonction prend en charge la transmission de plusieurs paramètres, tels que l'adresse, le mot de passe, la base de données, le délai d'expiration de la connexion, etc. du serveur Redis. Voici un exemple de code simple :

import "github.com/go-redis/redis"

func main() {
  // 创建连接
  client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "",
    DB:       0,
  })

  // 测试连接
  _, err := client.Ping().Result()
  if err != nil {
    panic(err)
  }
}

Dans cet exemple, nous créons une instance redis.NewClient et nous connectons au serveur Redis local en utilisant la configuration par défaut. Ensuite, la connexion a été testée via la méthode client.Ping et l'erreur a été gérée.

2. Requête par lots

Une fois la connexion Redis établie, vous pouvez effectuer des requêtes par lots. Dans Golang, nous pouvons utiliser les méthodes MGet et HMGet fournies par le package redis pour implémenter des requêtes par lots.

La méthode MGet peut être utilisée pour interroger plusieurs valeurs de type String. Elle accepte un ou plusieurs paramètres comme clé de requête et renvoie un tableau de chaînes. Voici un exemple qui interroge les valeurs de threeKey et fourKey dans Redis :

func batchGetStringValues(client *redis.Client) []string {
  keys := []string{"threeKey", "fourKey"}
  res, err := client.MGet(keys...).Result()
  if err != nil {
    panic(err)
  }
  return res
}

La méthode HMGet peut être utilisée pour interroger plusieurs valeurs de type Hash. Elle accepte un paramètre comme clé de l'objet de hachage de requête et plusieurs. paramètres comme nom du champ de hachage et renvoie un tableau de chaînes. Voici un exemple qui interroge les champs name et age de user3 et user4 dans Redis :

func batchGetHashValues(client *redis.Client) []string {
  keys := []string{"user3", "user4"}
  fields := []string{"name", "age"}
  res, err := client.HMGet(keys, fields...).Result()
  if err != nil {
    panic(err)
  }
  return res
}

Il convient de noter que le résultat renvoyé par la méthode HMGet est un tableau de type interface{}, et non un tableau de chaînes. Si vous devez obtenir des résultats de requête, une conversion de type est requise.

3. Requête simultanée

Grâce aux deux méthodes ci-dessus, nous pouvons implémenter des requêtes par lots. Cependant, si la quantité de données à interroger est importante ou si les données interrogées ne sont pas adjacentes, l'efficacité de l'interrogation par lots peut ne pas être élevée. Afin d'améliorer l'efficacité des requêtes, nous pouvons utiliser les mécanismes de goroutine et de canal uniques du langage Go pour implémenter des requêtes simultanées.

Tout d'abord, définissez une structure de tâches de requête :

type queryTask struct {
  key    string
  fields []string
  result chan interface{}
}

Parmi elles, key représente la clé à interroger, les champs représentent la liste des champs à interroger et le résultat représente le résultat de la requête. Ensuite, définissez une méthode coroutine :

func queryWorker(client *redis.Client, tasks <-chan *queryTask, wg *sync.WaitGroup) {
  defer wg.Done()
  for task := range tasks {
    result, err := client.HMGet(task.key, task.fields...).Result()
    if err != nil {
      task.result <- err
    } else {
      task.result <- result
    }
  }
}

Cette méthode coroutine reçoit les tâches d'un canal de tâches et extrait les tâches du canal pour les interroger. Les résultats de la requête seront écrits dans le canal de résultats de la tâche.

Enfin, générez la tâche de requête et placez-la dans le canal de tâches :

func batchGetHashValuesConcurrent(client *redis.Client, keys []string, fields []string) []interface{} {
  tasks := make(chan *queryTask, len(keys)*len(fields))
  wg := sync.WaitGroup{}

  // 启动任务协程
  for i := 0; i < runtime.NumCPU(); i++ {
    go queryWorker(client, tasks, &wg)
  }

  // 发送任务
  for _, key := range keys {
    task := &queryTask{key, fields, make(chan interface{})}
    tasks <- task
    wg.Add(1)
  }

  // 等待查询完成
  go func() {
    wg.Wait()
    close(tasks)
  }()

  // 收集结果
  results := make([]interface{}, len(keys)*len(fields))
  var i int
  for task := range tasks {
    for _, res := range task.result {
      results[i] = res
      i++
    }
  }
  return results
}

Cette fonction démarrera plusieurs coroutines et placera les tâches de requête dans le canal dans l'ordre. Ensuite, attendez que la coroutine de tâche termine la requête et obtenez les résultats de la requête à partir du canal de résultats de la tâche. Enfin, tous les résultats de la requête sont combinés en une seule tranche et renvoyés.

Ce qui précède est la méthode d'opération de requête par lots et l'optimisation des performances de Redis dans Golang. Bien entendu, en plus des méthodes ci-dessus, nous pouvons également réaliser des opérations de requête par lots plus efficaces grâce à des mécanismes tels que le pipeline et les transactions de Redis.

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!