Pratique d'application de go-zero et RabbitMQ

Aujourd'hui, de plus en plus d'entreprises commencent à adopter le modèle d'architecture de microservices, et dans cette architecture, les files d'attente de messages sont devenues une méthode de communication importante, parmi laquelle RabbitMQ est largement utilisé. Dans le langage Go, go-zero est un framework qui a émergé ces dernières années. Il fournit de nombreux outils et méthodes pratiques pour permettre aux développeurs d'utiliser plus facilement les files d'attente de messages. Ci-dessous, nous présenterons le go-zero basé sur des applications pratiques et son utilisation. et pratique d'application de RabbitMQ.

1. Présentation de RabbitMQ

RabbitMQ est un logiciel de file d'attente de messages open source, fiable et efficace. Il est largement utilisé dans les applications de niveau entreprise, améliorant considérablement l'évolutivité et la stabilité du système d'application. RabbitMQ utilise le protocole AMQP, qui est une spécification qui définit les messages d'opération, qui permet à différentes applications d'échanger des informations sans restrictions de langue.

Il existe quatre concepts dans RabbitMQ : producteur, consommateur, file d'attente et échange. Le producteur est l'expéditeur des messages, le consommateur est le récepteur des messages, la file d'attente est le conteneur de stockage des messages et le commutateur est le centre du routage des messages, acheminant les messages vers la file d'attente correspondante.

2. Introduction à go-zero

go-zero est un framework de microservices basé sur le langage go. Il fournit de nombreux outils et méthodes pratiques, permettant aux développeurs de concevoir et de développer plus facilement des applications de microservices hautes performances et haute fiabilité. Le framework go-zero adopte des principes de conception légers pour simplifier le processus de développement et améliorer l’efficacité du développement.

Le module de file d'attente de messages de go-zero utilise RabbitMQ, qui fournit une prise en charge complète de la file d'attente de messages, y compris les producteurs, les consommateurs, les files d'attente et les commutateurs, etc., permettant aux développeurs d'utiliser rapidement et facilement RabbitMQ pour la communication de messages. Dans le même temps, go-zero fournit également sa propre fonction de journalisation, qui permet de suivre et d'analyser efficacement le fonctionnement du système.

3. Comment utiliser go-zero et RabbitMQ

Ci-dessous, nous présenterons l'utilisation de go-zero et RabbitMQ sur la base d'un cas pratique. Ce cas est un simple système d'enregistrement et de connexion d'utilisateur. Lorsqu'un utilisateur s'inscrit, le système stockera les informations de l'utilisateur dans la base de données et enverra en même temps le message à RabbitMQ, qui sera finalement transmis au consommateur pour traitement. Le consommateur est responsable du stockage des informations utilisateur dans Redis pour améliorer les performances du système.

3.1 Producteur

Nous définissons d'abord une structure d'informations utilisateur pour stocker les informations d'enregistrement des utilisateurs.

type User struct {
    Name     string `json:"name"`
    Password string `json:"password"`
    Email    string `json:"email"`
}

Ensuite, nous définissons une interface producteur pour envoyer les informations utilisateur à RabbitMQ.

type Producer interface {
    Publish(ctx context.Context, data []byte) error
}

Nous utilisons l'implémentation RabbitMQ dans la bibliothèque "go-zero/messaging" pour implémenter l'interface producteur. Le code spécifique est le suivant.

import (
    "context"
    "encoding/json"
    "time"

    "github.com/gomodule/redigo/redis"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/core/stores/cache"
    "github.com/tal-tech/go-zero/core/stores/redis/redisc"
    "github.com/tal-tech/go-zero/messaging"
    "github.com/tal-tech/go-zero/messaging/rabbitmq"
)

type mqProducer struct {
    publisher messaging.Publisher
    cache     cache.Cache
}

func NewMqProducer(amqpUrl, queueName, exchangeName string) Producer {
    pub := rabbitmq.NewPublisher(amqpUrl, rabbitmq.ExchangeOption(exchangeName))
    cacheConn := redisc.MustNewCache("localhost:6379", "")
    return &mqProducer{
        publisher: pub,
        cache:     cache.NewCache(cacheConn),
    }
}

func (producer *mqProducer) Publish(ctx context.Context, data []byte) error {
    defer producer.cache.Close()
    user := new(User)
    err := json.Unmarshal(data, &user)
    if err != nil {
        return err
    }
    err = producer.cache.Remember(user.Name, func() (interface{}, error) {
        return user, time.Second*3600
    })
    if err != nil {
        logx.Errorf("[Producer]remember cache first:%s", err.Error())
        return err
    }
    return producer.publisher.Publish(ctx, messaging.Message{
        Topic: producer.publisher.GetExchange() + "." + producer.publisher.GetQueue(),
        Body:  data,
    })
}

Nous utilisons les modules Redis et Cache dans la bibliothèque "go-zero/stores" pour stocker les informations utilisateur dans Redis et mettre en cache les informations utilisateur dans Cache. Dans le même temps, nous utilisons l'implémentation de RabbitMQ dans la bibliothèque « go-zero/messaging » pour envoyer les informations utilisateur à RabbitMQ. La fonction "NewMqProducer" est utilisée pour créer une instance de producteur, où "amqpUrl" est l'URL de connexion de RabbitMQ, "queueName" est le nom de la file d'attente de messages et "exchangeName" est le nom du commutateur. La fonction "Publier" est utilisée pour envoyer des informations utilisateur à RabbitMQ.

3.2 Consommateur

Ensuite, nous définissons une interface consommateur pour recevoir des messages de RabbitMQ et stocker les messages dans Redis.

type Consumer interface {
    Consume(ctx context.Context, handler Handler) error
}

type Handler func(data []byte) error

Nous utilisons l'implémentation RabbitMQ dans la bibliothèque "go-zero/messaging" pour implémenter l'interface consommateur. Le code spécifique est le suivant.

type mqConsumer struct {
    consumer messaging.Consumer
    cache    cache.Cache
}

func NewMqConsumer(amqpUrl, queueName, exchangeName, routingKey string) (Consumer, error) {
    sub := rabbitmq.NewSubscriber(amqpUrl, rabbitmq.ExchangeOption(exchangeName))
    err := sub.Subscribe(context.Background(), "", func(msg messaging.Message) error {
        cacheConn := redisc.MustNewCache("localhost:6379", "")
        defer cacheConn.Close()
        user := new(User)
        err := json.Unmarshal(msg.Body, &user)
        if err != nil {
            return err
        }
        err = cacheConn.Remember(user.Name, func() (interface{}, error) {
            return user, time.Second*3600
        })
        if err != nil {
            logx.Errorf("[Consumer]remember cache:%s", err.Error())
            return err
        }
        return nil
    }, rabbitmq.QueueOption(queueName), rabbitmq.QueueDurable())
    if err != nil {
        return nil, err
    }
    return &mqConsumer{
        consumer: sub,
        cache:    cache.NewCache(redisc.MustNewCache("localhost:6379", "")),
    }, nil
}

func (consumer *mqConsumer) Consume(ctx context.Context, handler Handler) error {
    return consumer.consumer.StartConsuming(ctx, func(msg messaging.Message) error {
        return handler(msg.Body)
    })
}

Nous utilisons les modules Redis et Cache dans la bibliothèque "go-zero/stores" pour stocker les informations utilisateur dans Redis. En même temps, nous utilisons l'implémentation de RabbitMQ dans la bibliothèque "go-zero/messaging" pour recevoir des messages de RabbitMQ. La fonction "NewMqConsumer" est utilisée pour créer une instance de consommateur, où "amqpUrl" est l'URL de connexion de RabbitMQ, "queueName" est le nom de la file d'attente de messages, "exchangeName" est le nom du commutateur et "routingKey" est la clé de routage, utilisée pour acheminer les messages vers la file d'attente spécifiée. La fonction "Consume" est utilisée pour recevoir des messages de RabbitMQ et envoyer les messages à la fonction de traitement des messages "handler".

4. Résumé

Dans cet article, nous avons présenté les pratiques d'utilisation et d'application de go-zero et RabbitMQ sur la base d'exemples d'application spécifiques. go-zero fournit une prise en charge complète de la file d'attente de messages et peut utiliser rapidement et facilement RabbitMQ pour la communication de messages. Dans le même temps, les modules Redis et Cache de la bibliothèque « go-zero/stores » sont utilisés pour améliorer les performances du système à un nouveau niveau. Avec la popularité et l'application progressives du go-zero, je pense que de plus en plus d'entreprises et de développeurs utiliseront go-zero et RabbitMQ pour créer des applications de microservices hautes performances et haute fiabilité.

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!