Pratique combinée de go-zero et Apache Camel : création d'un système de routage de messages distribué hautes performances

Ces dernières années, avec le développement rapide de la technologie Internet, les entreprises sont confrontées à une quantité croissante de données et les files d'attente de messages centralisées traditionnelles ne peuvent souvent pas répondre aux besoins des systèmes distribués. Par conséquent, les systèmes de routage de messages distribués sont de plus en plus favorisés par les entreprises. attention.

Cet article explique comment utiliser les deux frameworks open source go-zero et Apache Camel pour implémenter un système de routage de messages distribué hautes performances.

1. Introduction à go-zero

go-zero est un framework de microservices qui intègre de nombreux composants (tels que RPC, API, cache, journaux, etc.). Il fournit une multitude de bibliothèques et d'outils pour créer rapidement des performances élevées. disponibilité, systèmes distribués performants et faciles à entretenir.

Les principales fonctionnalités de go-zero sont les suivantes :

1. Basé sur gRPC : utilisez protobuf pour définir des interfaces et prendre en charge plusieurs langages, tels que Go, Java, Python, etc.

2. Générer automatiquement du code : générer automatiquement des codes de modèle et de service en fonction du fichier proto défini.

3. Prend en charge plusieurs stockages de données : prend en charge MySQL, Redis, MongoDB et d'autres méthodes de stockage de données.

4. Cache intégré : Memcached et Redis intégrés, prenant en charge la séparation en lecture-écriture du cache, le cache multi-niveaux, etc.

5. Léger : comparé à d'autres frameworks, go-zero a une très petite quantité de code, une faible courbe d'apprentissage et est très pratique à utiliser.

2. Introduction à Apache Camel

Apache Camel est un framework de routage et de médiation open source basé sur des règles qui peut être utilisé pour connecter différents composants de diverses applications.

Les principales caractéristiques de Camel sont les suivantes :

1. Facile à étendre : Camel est conçu avec un grand nombre de composants, et les routeurs et convertisseurs de données existants peuvent être facilement étendus en ajoutant de nouveaux composants.

2. Prise en charge multilingue : prend en charge l'interaction entre différents langages et protocoles, tels que Java, C#, C++, Python, Scala, Ruby, etc.

3. Léger : comparé à d'autres frameworks, Camel a une très petite quantité de code, une faible courbe d'apprentissage et est très pratique à utiliser.

4. Prise en charge de plusieurs sources de données : prend en charge la conversion entre diverses sources de données, telles que MQ, HTTP, JMS, TCP, FTP, etc.

3. Pratique combinée de go-zero et Apache Camel

Nous avons utilisé go-zero pour créer un serveur RPC afin de gérer diverses requêtes, telles que le routage des messages, la conversion de données, etc. Apache Camel est responsable de la conversion et du routage des données.

Côté serveur, nous utilisons les outils de génération automatique de modèles et de services de go-zero pour générer des services de routage de messages et de conversion de données. Ces services sont basés sur le framework de communication gRPC et les interfaces sont définies à l'aide de protobuf.

Ensuite, nous utiliserons Camel pour implémenter des fonctions de routage et de conversion de données. Pour le routage, nous utilisons le moteur de routage de Camel pour acheminer les messages vers le service cible. Pour la conversion des données, nous utilisons divers convertisseurs de données fournis par Camel pour convertir le message au format cible et le transmettre au système cible.

Afin de mieux démontrer le processus de construction de ce système de routage de messages distribué, nous allons illustrer avec un exemple simple.

Tout d'abord, nous avons un scénario : un système de gestion des commandes doit envoyer les informations de commande au système ERP pour traitement. Nous devons mettre en œuvre les fonctions suivantes :

1. Recevoir les messages de commande du système de gestion des commandes.

2. Convertissez le message de commande dans un format reconnaissable par le système ERP.

3. Acheminez le message de commande converti vers le système ERP.

Pour implémenter ces fonctions, nous pouvons faire ceci :

1. Utilisez go-zero pour créer un serveur RPC afin de recevoir les messages de commande du système de gestion des commandes.

2. Utilisez le composant JMS fourni par Camel comme middleware de message pour transmettre le message de commande au système ERP.

3. Utilisez le convertisseur de données de Camel pour convertir le message de commande dans un format pouvant être reconnu par le système ERP.

4. Définissez les règles de routage Camel pour acheminer les messages de commande convertis vers le système ERP.

Maintenant, examinons les étapes spécifiques de mise en œuvre.

Tout d'abord, définissez l'interface protobuf et le modèle de données en go-zero :

syntax = "proto3";

package order;

option go_package = "order";

message OrderInfo {
    string orderId = 1;
    string customerName = 2;
    string address = 3;
    string phone = 4;
}

service OrderService {
    // 接收订单信息
    rpc SubmitOrder(OrderInfo) returns (Empty) {}
}

Utilisez l'outil de génération automatique go-zero pour générer le modèle et le code de service :

# 生成model
make service.proto

# 生成service
make service

Ensuite, côté serveur RPC, implémentez la méthode SubmitOrder pour recevoir commandes du message de commande du système de gestion :

func (s *Service) SubmitOrder(ctx context.Context, req *order.OrderInfo) (*status.Empty, error) {
    orders := make([]string, 0)
    orders = append(orders, req.OrderId)
    orders = append(orders, req.CustomerName)
    orders = append(orders, req.Address)
    orders = append(orders, req.Phone)

    // 通过RPC发送消息到消息中间件
    go sendToMQ(orders)

    return &status.Empty{}, nil
}

func sendToMQ(order []string) {
    // 发送MQ消息
    orderInfo := map[string]interface{}{
        "orderId":      order[0],
        "customerName": order[1],
        "address":      order[2],
        "phone":        order[3],
    }
    fmt.Printf("Send to MQ: %v
", orderInfo)

    message := &jms.TextMessage{
        Body: fmt.Sprintf("%v", orderInfo),
    }
    err := producer.Send(message)
    if err != nil {
        fmt.Printf("Failed to send message: %v
", err)
    }
}

Ensuite, nous utilisons le composant JMS de Camel pour connecter le middleware de message ActiveMQ :

from("activemq:queue:order.queue").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        // 接收MQ消息，转换数据格式
        Map<String, Object> orderInfo = new HashMap<String, Object>();
        orderInfo = exchange.getIn().getBody(Map.class);

        exchange.getIn().setBody(orderInfo);
    }
});

Ensuite, utilisons le convertisseur de données de Camel pour convertir le message de commande dans un format que le système ERP peut reconnaître :

from("activemq:queue:order.queue").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        // 接收MQ消息，转换数据格式
        Map<String, Object> orderInfo = new HashMap<String, Object>();
        orderInfo = exchange.getIn().getBody(Map.class);

        // 数据转换
        String json = "{"order_id": "" + orderInfo.get("orderId") + """ +
                ", "customer_name": "" + orderInfo.get("customerName") + """ +
                ", "address": "" + orderInfo.get("address") + """ +
                ", "phone": "" + orderInfo.get("phone") + """ +
                "}";

        exchange.getIn().setBody(json);
    }
});

Enfin, définissez les règles de routage Camel pour acheminer les messages de commande convertis vers le système ERP :

from("activemq:queue:order.queue").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        // 接收MQ消息，转换数据格式
        Map<String, Object> orderInfo = new HashMap<String, Object>();
        orderInfo = exchange.getIn().getBody(Map.class);

        // 数据转换
        String json = "{"order_id": "" + orderInfo.get("orderId") + """ +
                ", "customer_name": "" + orderInfo.get("customerName") + """ +
                ", "address": "" + orderInfo.get("address") + """ +
                ", "phone": "" + orderInfo.get("phone") + """ +
                "}";

        exchange.getIn().setBody(json);
    }
}).to("http://erp.com/order");

Dans le code ci-dessus, nous utilisons le moteur de routage et le convertisseur de données de Camel pour convertir et acheminer les messages de commande vers le système ERP central.

4. Résumé

Cet article présente comment utiliser les deux frameworks open source go-zero et Apache Camel pour implémenter un système de routage de messages distribué hautes performances. En utilisant les fonctionnalités et les avantages de go-zero et Camel, un système de routage de messages distribué offrant des performances élevées, une haute disponibilité et une maintenance facile peut être mieux développé, apportant ainsi une plus grande valeur aux entreprises.

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!