Golang est un langage de programmation efficace, concis et puissant avec un mécanisme de contrôle de concurrence parfait et de riches fonctions de bibliothèque standard. Il a été largement utilisé dans le cloud computing, la programmation réseau, les systèmes distribués, les microservices et d'autres domaines. Dans ces scénarios d'application, le transfert de messages est une fonction très importante. Cet article explique comment utiliser Golang pour implémenter le transfert de messages.
- Modèle de message
Dans les applications de transfert de messages, la chose la plus importante est le modèle de message. Le modèle de message fait référence à la structure des données et à la méthode d'interaction utilisées pour transmettre les messages dans le système. Normalement, un modèle de message doit avoir les caractéristiques suivantes :
1.1 Flexibilité
Le modèle de message doit avoir un certain degré de flexibilité pour prendre en charge différents types de messages. Par exemple, un message peut être du texte, des données binaires, une image, une vidéo, etc.
1.2 Fiabilité
Le modèle de message doit avoir un certain degré de fiabilité pour assurer la livraison du message. Dans un système distribué, un message peut devoir traverser plusieurs nœuds de réseau pour atteindre le nœud de destination. Par conséquent, il est nécessaire de s'assurer que les messages ne sont pas perdus en raison de problèmes de réseau ou d'autres conditions anormales.
1.3 Efficacité
Le modèle de message doit avoir un certain degré d'efficacité pour garantir les performances du système et l'expérience utilisateur. Dans les applications de transfert de messages, les messages doivent être envoyés rapidement au nœud cible sans provoquer de gels ou de retards du système dus à la transmission des messages.
Sur la base des caractéristiques ci-dessus, nous pouvons concevoir un modèle de message de base, comme le montre la figure ci-dessous :
Le modèle de message dans la figure comprend les parties suivantes :
- En-tête du message : contient les méta-informations du message, par exemple, le type de message, l'ID de l'expéditeur, l'ID du destinataire, etc.
- Corps du message : contient le contenu réel du message, tel que du texte, des images, des données binaires, etc.
- File d'attente de messages : utilisée pour mettre en cache les messages afin d'assurer une livraison stable des messages. Ceci peut être réalisé à l'aide de technologies de file d'attente telles que Redis, Kafka et RocketMQ.
- Routage des messages : utilisé pour envoyer des messages au nœud cible, qui peuvent être implémentés à l'aide de RPC, HTTP et d'autres protocoles.
- Mise en œuvre du transfert de messages
Une fois la conception du modèle de message terminée, nous devons considérer la mise en œuvre spécifique du transfert de messages. De manière générale, le transfert de messages peut utiliser les deux méthodes suivantes :
2.1 Méthode point à point
La méthode point à point signifie que l'expéditeur du message envoie directement un message au destinataire du message. Les avantages de cette méthode sont une mise en œuvre simple et une transmission rapide des messages. Cependant, dans un système distribué, il peut rencontrer des problèmes tels qu'une défaillance de nœud et une perte de paquets réseau, entraînant une transmission incorrecte des messages.
2.2 Méthode publication-abonnement
La méthode publication-abonnement signifie envoyer des messages à un serveur de messagerie central, puis les abonnés (destinataires) s'abonnent aux messages qui les intéressent depuis le serveur. L'avantage de cette méthode est que la fiabilité du message est élevée et que les problèmes tels que les pannes de nœuds peuvent être automatiquement traités par le serveur central. L'inconvénient est que la mise en œuvre est relativement complexe et augmentera un certain délai de transmission sur le réseau.
Ci-dessous, nous utiliserons Golang pour implémenter un module de transfert de messages basé sur la publication et l'abonnement. Nous utiliserons Redis comme file d'attente des messages et le protocole RPC pour le routage des messages.
2.3 Conception de file d'attente de messages
Redis est une base de données de cache mémoire rapide et stable qui peut également être utilisée comme file d'attente de messages. Voici l'extrait de code principal pour utiliser Redis comme file d'attente de messages :
type RedisBroker struct {
client *redis.Client
topic string
}
func NewRedisBroker(address, password, topic string) *RedisBroker {
client := redis.NewClient(&redis.Options{
Addr: address,
Password: password,
})
return &RedisBroker{
client: client,
topic: topic,
}
}
func (b *RedisBroker) Publish(msg *Message) error {
data, err := json.Marshal(msg)
if err != nil {
return err
}
_, err = b.client.LPush(b.topic, data).Result()
if err != nil {
return err
}
return nil
}
func (b *RedisBroker) Subscribe() (<p>Dans le code ci-dessus, nous avons implémenté une structure appelée RedisBroker, qui encapsule les méthodes LPush et Subscribe de Redis, qui sont utilisées pour envoyer des messages vers la file d'attente de messages. et Abonnez-vous à la file d'attente des messages. Une fois l'instance Broker créée, vous pouvez utiliser la méthode Publish pour envoyer des messages vers la file d'attente Redis et la méthode Subscribe pour vous abonner aux messages dans la file d'attente Redis. Dans la fonction de traitement des messages, nous analyserons l'objet Message dans le message Redis et l'enverrons au service RPC. </p><p>2.4 Conception du routage des messages</p><p>Le protocole RPC est un protocole d'appel de procédure à distance basé sur le protocole TCP/IP. Il envoie des appels de fonction aux nœuds distants via le réseau et renvoie les résultats. Nous utiliserons le protocole RPC pour implémenter le routage des messages. Voici l'extrait de code principal basé sur l'implémentation de gRPC : </p><pre class="brush:php;toolbar:false">type Server struct {
brok *RedisBroker
}
func (s *Server) Send(ctx context.Context, msg *proto.Message) (*proto.Response, error) {
log.Printf("Receive message from %v to %v: %v", msg.Sender, msg.Receiver, msg.Text)
// Publish message to Redis
err := s.brok.Publish(&Message{
Sender: msg.Sender,
Receiver: msg.Receiver,
Text: msg.Text,
})
if err != nil {
log.Println("failed to publish message:", err)
}
return &proto.Response{Ok: true}, nil
}
func StartRPCService(address string, brok *RedisBroker) {
lis, err := net.Listen("tcp", address)
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
proto.RegisterMessageServiceServer(s, &Server{
brok: brok,
})
log.Println("start rpc service at", address)
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}Copier après la connexion
Dans le code ci-dessus, nous avons implémenté une structure de serveur basée sur le protocole gRPC, qui encapsule la méthode Send et est utilisée. pour envoyer les messages reçus sont envoyés à la file d'attente Redis. Dans la méthode Send, nous analyserons le message gRPC et le convertirons en un objet Message, puis enverrons le message à la file d'attente Redis via la méthode Publish de RedisBroker. Lors du démarrage du service RPC, nous démarrons le service RPC via la méthode s.Serve et écoutons les connexions TCP sur l'adresse adresse.
- Exemple d'utilisation
Maintenant que nous avons implémenté le module de transfert de messages basé sur la publication-abonnement, nous pouvons le tester. Nous pouvons démarrer le service RPC dans le terminal :
func main() {
// New Redis broker
broker := NewRedisBroker("localhost:6379", "", "go-message-broker")
// Start RPC service
StartRPCService(":9090", broker)
}Copier après la connexion
Ensuite, écrire un programme client, implémenter le récepteur dans le programme client et nous abonner au message avec l'ID du récepteur "receiver-01" depuis la file d'attente Redis :
func main() {
// New Redis broker
broker := NewRedisBroker("localhost:6379", "", "go-message-broker")
// Receive message
ch, err := broker.Subscribe()
if err != nil {
log.Fatal("subscribe error:", err)
}
for {
select {
case message := <p>At en même temps, nous avons également besoin d'un expéditeur pour simuler le comportement d'envoi de messages : </p><pre class="brush:php;toolbar:false">func main() {
// New RPC client
conn, err := grpc.Dial(":9090", grpc.WithInsecure())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := proto.NewMessageServiceClient(conn)
// Send message
_, err = c.Send(context.Background(), &proto.Message{
Sender: "sender-01",
Receiver: "receiver-01",
Text: "hello go message broker",
})
if err != nil {
log.Fatalf("could not send message: %v", err)
}
}Copier après la connexion
Exécutez les trois programmes ci-dessus, l'expéditeur envoie un message, le destinataire recevra le message et vous pourrez voir les informations pertinentes sur les terminaux de l'expéditeur et le destinataire.
- Résumé
Cet article explique comment utiliser Golang pour implémenter un module de transfert de messages basé sur la publication et l'abonnement. En utilisant la file d'attente Redis et le protocole RPC, nous avons mis en place un système de transfert de messages efficace, flexible et fiable. Bien entendu, il ne s'agit que d'une simple implémentation. Dans les environnements de production réels, d'autres problèmes doivent être traités, tels que les signatures de messages, les garanties de sécurité, l'équilibrage de charge, etc. Cependant, en étudiant le contenu décrit dans cet article, vous pouvez maîtriser les technologies et idées de base de Golang en matière de transmission de messages et fournir un support au développement de systèmes distribués plus efficaces et plus fiables.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
