Mula Pantas: Gunakan fungsi bahasa Go untuk melaksanakan fungsi tolak mesej ringkas

Mula Pantas: Gunakan fungsi bahasa Go untuk melaksanakan fungsi tolak mesej ringkas

Dalam era Internet mudah alih hari ini, tolak mesej telah menjadi ciri standard pelbagai APP. Bahasa Go ialah bahasa pengaturcaraan yang pantas dan cekap, yang sangat sesuai untuk membangunkan fungsi tolak mesej. Artikel ini akan memperkenalkan cara menggunakan fungsi bahasa Go untuk melaksanakan fungsi tolak mesej ringkas dan menyediakan contoh kod yang sepadan untuk membantu pembaca bermula dengan cepat.

Sebelum kita mula, kita perlu memahami prinsip asas tolakan mesej. Lazimnya, fungsi tolak mesej memerlukan dua komponen utama: pelayan tolak dan klien penerima. Pelayan push bertanggungjawab untuk menerima mesej yang dihantar oleh pelanggan dan menolaknya kepada pelanggan penerima yang sepadan. Klien penerima bertanggungjawab untuk menerima mesej yang ditolak dan memprosesnya dengan sewajarnya.

Pertama, mari buat pelayan tolak yang mudah. Kami menggunakan pakej net/http dalam bahasa Go untuk mencipta pelayan HTTP dan menggunakan protokol WebSocket untuk menolak mesej. Berikut ialah contoh kod untuk pelayan tolak mudah:

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var clients = make(map[*websocket.Conn]bool) // 存储所有连接的客户端

var broadcast = make(chan []byte) // 接收消息的通道

var upgrader = websocket.Upgrader{} // WebSocket升级器

func main() {
    http.HandleFunc("/", handleMessage)
    go handleMessages()
    log.Println("Server running on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func handleMessage(w http.ResponseWriter, r *http.Request) {
    // 将HTTP连接升级为WebSocket连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }

    // 将连接添加到clients映射表中
    clients[conn] = true

    // 关闭连接时从clients映射表中删除连接
    defer func() {
        delete(clients, conn)
        conn.Close()
    }()

    for {
        // 读取客户端发送的消息
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }

        // 将消息发送到broadcast通道中
        broadcast <- message
    }
}

func handleMessages() {
    for {
        // 从broadcast通道中读取消息
        message := <-broadcast

        // 向所有连接的客户端发送消息
        for client := range clients {
            err := client.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println(err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

Kod di atas mencipta pelayan WebSocket dan melaksanakan logik untuk mengendalikan sambungan, menerima mesej dan menghantar mesej. Apabila pelanggan baharu menyambung ke pelayan, pelayan akan menambahkannya pada jadual pemetaan pelanggan dan memproses mesej yang diterima melalui coroutine dan menghantarnya kepada semua pelanggan.

Seterusnya, mari tulis klien mudah untuk menerima dan memaparkan mesej yang ditolak oleh pelayan. Berikut ialah contoh kod untuk klien mudah berdasarkan baris arahan:

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "time"

    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/"}
    log.Printf("connecting to %s", u.String())

    c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()

    done := make(chan struct{})

    // 接收和显示服务器推送的消息
    go func() {
        defer close(done)
        for {
            _, message, err := c.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            fmt.Printf("received: %s
", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")
            // 断开与服务器的连接
            err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
            if err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

Kod di atas mencipta klien WebSocket, menyambung ke pelayan yang kami buat sebelum ini, dan menerima serta memaparkan mesej yang ditolak oleh pelayan dalam masa nyata melalui coroutine. Apabila isyarat gangguan diterima, pelanggan akan memutuskan sambungan dari pelayan.

Dengan menjalankan dua keping kod di atas, kami boleh mensimulasikan sistem tolak mesej ringkas dalam baris arahan. Apabila pengguna memasukkan mesej, pelayan akan menolaknya kepada semua pelanggan dan memaparkannya pada klien. Ini hanyalah contoh mudah, anda boleh melanjutkan dan menyesuaikannya mengikut keperluan sebenar anda.

Ringkasan
Artikel ini memperkenalkan cara menggunakan fungsi bahasa Go untuk melaksanakan fungsi tolak mesej ringkas. Kami mencipta pelayan tolak WebSocket dan menulis klien mudah untuk menerima dan memaparkan mesej yang ditolak oleh pelayan. Melalui kod sampel dalam artikel ini, pembaca boleh mulakan dengan cepat dan memahami prinsip asas bahasa Go untuk melaksanakan fungsi tolak mesej.

Atas ialah kandungan terperinci Mula Pantas: Gunakan fungsi bahasa Go untuk melaksanakan fungsi tolak mesej ringkas. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!