Cara menggunakan Golang untuk melaksanakan pemajuan mesej

Golang ialah bahasa pengaturcaraan yang cekap, ringkas dan berkuasa dengan mekanisme kawalan serentak yang sempurna dan fungsi perpustakaan standard yang kaya. Ia telah digunakan secara meluas dalam pengkomputeran awan, pengaturcaraan rangkaian, sistem teragih, perkhidmatan mikro dan bidang lain. Dalam senario aplikasi ini, pemajuan mesej adalah fungsi yang sangat penting. Artikel ini memperkenalkan cara menggunakan Golang untuk melaksanakan pemajuan mesej.

1. Model Mesej

Dalam aplikasi pemajuan mesej, perkara yang paling penting ialah model mesej. Model mesej merujuk kepada struktur data dan kaedah interaksi yang digunakan untuk menyampaikan mesej dalam sistem. Biasanya, model mesej harus mempunyai ciri-ciri berikut:

1.1 Fleksibiliti

Model mesej perlu mempunyai tahap fleksibiliti tertentu untuk menyokong pelbagai jenis mesej. Sebagai contoh, mesej mungkin teks, data binari, gambar, video, dsb.

1.2 Kebolehpercayaan

Model mesej perlu mempunyai tahap kebolehpercayaan tertentu untuk memastikan penghantaran mesej. Dalam sistem yang diedarkan, mesej mungkin perlu melalui berbilang nod rangkaian untuk mencapai nod destinasi. Oleh itu, adalah perlu untuk memastikan bahawa mesej tidak hilang disebabkan oleh masalah rangkaian atau keadaan abnormal yang lain.

1.3 Kecekapan

Model mesej perlu mempunyai tahap kecekapan tertentu untuk memastikan prestasi sistem dan pengalaman pengguna. Dalam aplikasi pemajuan mesej, mesej perlu dihantar ke nod sasaran dengan cepat tanpa menyebabkan sistem membeku atau kelewatan akibat penghantaran mesej.

Berdasarkan ciri di atas, kita boleh mereka bentuk model mesej asas, seperti yang ditunjukkan dalam rajah di bawah:

Model mesej dalam rajah termasuk bahagian berikut :

• Pengepala mesej: Mengandungi meta-maklumat mesej, seperti jenis mesej, ID pengirim, ID penerima, dsb.
• Isi mesej: Mengandungi kandungan sebenar mesej, seperti teks, gambar, data binari, dsb.
• Baris gilir mesej: digunakan untuk cache mesej untuk memastikan penghantaran mesej yang stabil Ini boleh dicapai menggunakan teknologi baris gilir seperti Redis, Kafka dan RocketMQ.
• Penghalaan mesej: digunakan untuk menghantar mesej ke nod sasaran, yang boleh dilaksanakan menggunakan RPC, HTTP dan protokol lain.

2. Pelaksanaan pemajuan mesej

Selepas reka bentuk model mesej selesai, kita perlu mempertimbangkan pelaksanaan khusus pemajuan mesej. Secara umumnya, dua kaedah berikut boleh digunakan untuk pemajuan mesej:

2.1 Kaedah titik ke titik

Kaedah titik ke titik bermaksud penghantar mesej menghantar mesej terus kepada penerima mesej. Kelebihan kaedah ini adalah pelaksanaan yang mudah dan penghantaran mesej yang cepat. Walau bagaimanapun, dalam sistem yang diedarkan, ia mungkin menghadapi masalah seperti kegagalan nod dan kehilangan paket rangkaian, menyebabkan mesej tidak dihantar dengan betul.

2.2 Kaedah terbitkan dan langgan

Kaedah terbitkan dan langgan merujuk kepada menghantar mesej kepada pelayan mesej pusat, dan kemudian pelanggan (penerima) melanggan mesej yang mereka minati daripada pelayan. Kelebihan kaedah ini ialah kebolehpercayaan mesej adalah tinggi, dan masalah seperti kegagalan nod boleh dikendalikan secara automatik oleh pelayan pusat. Kelemahannya ialah pelaksanaannya agak kompleks dan akan meningkatkan kelewatan penghantaran rangkaian tertentu.

Di bawah ini kami akan menggunakan Golang untuk melaksanakan modul pemajuan mesej berdasarkan penerbitan dan langganan. Kami akan menggunakan Redis sebagai baris gilir mesej dan protokol RPC untuk penghalaan mesej.

2.3 Reka bentuk baris gilir mesej

Redis ialah pangkalan data cache memori yang pantas dan stabil yang juga boleh digunakan sebagai baris gilir mesej. Berikut ialah coretan kod teras untuk menggunakan Redis sebagai baris gilir mesej:

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> Dalam kod di atas, kami melaksanakan struktur yang dipanggil RedisBroker, yang merangkum kaedah LPush dan Langgan Redis dan digunakan untuk menghantar mesej kepada baris gilir mesej Tolak mesej dan langgan baris gilir mesej. Selepas contoh Broker dibuat, anda boleh menggunakan kaedah Terbitkan untuk menolak mesej ke baris gilir Redis, dan kaedah Langgan untuk melanggan mesej dalam baris gilir Redis. Dalam fungsi pemprosesan mesej, kami akan menghuraikan objek Mesej dalam mesej Redis dan menghantarnya ke perkhidmatan RPC. </p><p>2.4 Reka bentuk penghalaan mesej </p><p>Protokol RPC ialah protokol panggilan prosedur jauh berdasarkan protokol TCP/IP Ia menyampaikan panggilan fungsi ke nod jauh melalui rangkaian dan mengembalikan hasil. Kami akan menggunakan protokol RPC untuk melaksanakan penghalaan mesej Berikut ialah coretan kod teras berdasarkan pelaksanaan 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)
    }
}

Dalam kod di atas, kami melaksanakan struktur Pelayan berdasarkan protokol gRPC, yang merangkumkan Kaedah hantar untuk Hantar mesej yang diterima ke baris gilir Redis. Dalam kaedah Hantar, kami akan menghuraikan mesej gRPC dan menukarnya menjadi objek Mesej, dan kemudian menghantar mesej ke baris gilir Redis melalui kaedah Terbitkan RedisBroker. Apabila memulakan perkhidmatan RPC, kami memulakan perkhidmatan RPC melalui kaedah s.Serve dan mendengar sambungan TCP pada alamat alamat.

3. Contoh Penggunaan

Sekarang kami telah melaksanakan modul pemajuan mesej berdasarkan penerbitan dan langgan, kami boleh mengujinya. Kita boleh memulakan perkhidmatan RPC di terminal:

func main() {
    // New Redis broker
    broker := NewRedisBroker("localhost:6379", "", "go-message-broker")

    // Start RPC service
    StartRPCService(":9090", broker)
}

Kemudian tulis program klien, laksanakan penerima dalam program klien, dan langgan mesej dengan ID penerima "receiver-01" daripada baris gilir 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>Pada masa yang sama, kami juga memerlukan penghantar untuk mensimulasikan tingkah laku menghantar mesej: </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)
    }
}

Jalankan tiga program di atas, pengirim menghantar mesej, dan penerima akan menerima Pada masa yang sama, anda boleh Output log berkaitan dilihat pada terminal penghantar dan penerima.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan Golang untuk melaksanakan modul pemajuan mesej berdasarkan penerbitan dan langganan. Dengan menggunakan baris gilir Redis dan protokol RPC, kami telah melaksanakan sistem pemajuan mesej yang cekap, fleksibel dan boleh dipercayai. Sudah tentu, ini hanyalah pelaksanaan mudah Dalam persekitaran pengeluaran sebenar, lebih banyak isu perlu ditangani, seperti tandatangan mesej, jaminan keselamatan, pengimbangan beban, dsb. Walau bagaimanapun, dengan mengkaji kandungan yang diterangkan dalam artikel ini, anda boleh menguasai teknologi teras dan idea Golang dalam penghantaran mesej, dan memberikan sokongan untuk pembangunan sistem pengedaran yang lebih cekap dan boleh dipercayai.

Atas ialah kandungan terperinci Cara menggunakan Golang untuk melaksanakan pemajuan mesej. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!