Amalan gabungan go-zero dan Apache Camel: membina sistem penghalaan mesej teragih berprestasi tinggi

Dalam beberapa tahun kebelakangan ini, dengan perkembangan pesat teknologi Internet, perusahaan berhadapan dengan peningkatan jumlah data, dan baris gilir mesej terpusat tradisional selalunya tidak dapat memenuhi keperluan sistem teragih Oleh itu, sistem penghalaan mesej teragih semakin banyak popular. Dapatkan perhatian daripada perniagaan.

Artikel ini memperkenalkan cara menggunakan dua rangka kerja sumber terbuka go-zero dan Apache Camel untuk melaksanakan sistem penghalaan mesej teragih berprestasi tinggi.

1. Pengenalan kepada go-zero

go-zero ialah rangka kerja mikro yang menyepadukan banyak komponen (seperti RPC, API, cache, log, dll.). dan Alat yang boleh membina sistem teragih yang sangat tersedia, berprestasi tinggi dan mudah diselenggara.

Ciri utama go-zero adalah seperti berikut:

1 Berdasarkan gRPC: gunakan protobuf untuk mentakrifkan antara muka dan menyokong berbilang bahasa, seperti Go, Java, Python, dll.

2. Menjana kod secara automatik: Mengikut fail proto yang ditentukan, model dan kod perkhidmatan dijana secara automatik.

3. Menyokong storan data berbilang: menyokong MySQL, Redis, MongoDB dan kaedah penyimpanan data lain.

4. Cache terbina dalam: Memcached dan Redis terbina dalam, menyokong pemisahan baca-tulis cache, cache berbilang peringkat, dsb.

5. Ringan: Berbanding dengan rangka kerja lain, go-zero mempunyai jumlah kod yang sangat kecil, keluk pembelajaran yang rendah dan sangat mudah digunakan.

2. Pengenalan kepada Apache Camel

Apache Camel ialah sumber terbuka, penghalaan berasaskan peraturan dan rangka kerja pengantaraan yang boleh digunakan untuk menyambungkan pelbagai komponen aplikasi.

Ciri utama Camel adalah seperti berikut:

1 Mudah dikembangkan: Camel direka dengan sejumlah besar komponen, dan penghala dan penukar data yang sedia ada boleh dikembangkan dengan mudah dengan menambah baharu. komponen.

2. Sokongan berbilang bahasa: Menyokong interaksi antara pelbagai bahasa dan protokol, seperti Java, C#, C++, Python, Scala, Ruby, dll.

3. Ringan: Berbanding dengan rangka kerja lain, Camel mempunyai jumlah kod yang sangat kecil, keluk pembelajaran yang rendah dan sangat mudah digunakan.

4. Sokongan sumber berbilang data: Menyokong penukaran antara pelbagai sumber data, seperti MQ, HTTP, JMS, TCP, FTP, dll.

3. Amalan gabungan go-zero dan Apache Camel

Kami menggunakan go-zero untuk membina pelayan RPC untuk mengendalikan pelbagai permintaan, seperti penghalaan mesej, penukaran data, dsb. Apache Camel bertanggungjawab untuk penukaran dan penghalaan data.

Dalam bahagian pelayan ini, kami menggunakan model go-zero dan alat penjanaan automatik perkhidmatan untuk menjana penghalaan mesej dan perkhidmatan penukaran data. Perkhidmatan ini adalah berdasarkan rangka kerja komunikasi gRPC, dan antara muka ditakrifkan menggunakan protobuf.

Seterusnya, kami akan menggunakan Camel untuk melaksanakan fungsi penghalaan dan penukaran data. Untuk penghalaan, kami menggunakan enjin penghalaan Camel untuk menghalakan mesej ke perkhidmatan sasaran. Untuk penukaran data, kami menggunakan pelbagai penukar data yang disediakan oleh Camel untuk menukar mesej ke dalam format sasaran dan menghantarnya ke sistem sasaran.

Untuk menunjukkan dengan lebih baik proses pembinaan sistem penghalaan mesej teragih ini, kami akan menggambarkan dengan contoh mudah.

Pertama, kami mempunyai senario: sistem pengurusan pesanan perlu menghantar maklumat pesanan kepada sistem ERP untuk diproses. Kita perlu melaksanakan fungsi berikut:

1 Terima pesanan pesanan daripada sistem pengurusan pesanan.

2. Tukar mesej pesanan ke dalam format yang boleh dikenali oleh sistem ERP.

3 Halakan mesej pesanan yang ditukar ke sistem ERP.

Untuk melaksanakan fungsi ini, kita boleh melakukan ini:

1. Gunakan go-zero untuk membina pelayan RPC untuk menerima mesej pesanan daripada sistem pengurusan pesanan.

2. Gunakan komponen JMS yang disediakan oleh Camel sebagai perisian tengah mesej untuk menghantar mesej pesanan kepada sistem ERP.

3. Gunakan penukar data Camel untuk menukar mesej pesanan kepada format yang boleh dikenali oleh sistem ERP.

4. Tentukan peraturan penghalaan Camel untuk menghalakan mesej pesanan yang ditukar ke sistem ERP.

Sekarang, mari lihat langkah pelaksanaan khusus.

Pertama, tentukan antara muka protobuf dan model data dalam 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) {}
}

Gunakan alat penjanaan automatik go-zero untuk menjana model dan kod perkhidmatan:

# 生成model
make service.proto

# 生成service
make service

Kemudian, Di bahagian pelayan RPC, laksanakan kaedah SubmitOrder untuk menerima mesej pesanan daripada sistem pengurusan pesanan:

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)
    }
}

Seterusnya, kami menggunakan komponen JMS Camel untuk menyambung ke perisian tengah mesej 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);
    }
});

Kemudian , Gunakan penukar data Camel untuk menukar mesej pesanan ke dalam format yang sistem ERP boleh kenali:

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);
    }
});

Akhir sekali, tentukan peraturan penghalaan Camel untuk menghalakan mesej pesanan yang ditukar ke sistem 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");

Dalam kod di atas, kami menggunakan enjin penghalaan Camel dan penukar data untuk menukar dan menghalakan mesej pesanan ke dalam sistem ERP.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan dua rangka kerja sumber terbuka go-zero dan Apache Camel untuk melaksanakan sistem penghalaan mesej teragih berprestasi tinggi. Dengan menggunakan ciri dan kelebihan go-zero dan Camel, sistem penghalaan mesej yang diedarkan dengan prestasi tinggi, ketersediaan tinggi dan penyelenggaraan mudah boleh dibangunkan dengan lebih baik, membawa nilai yang lebih besar kepada perusahaan.

Atas ialah kandungan terperinci Amalan gabungan go-zero dan Apache Camel: membina sistem penghalaan mesej teragih berprestasi tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!