pelaksanaan benteng golang

Barrage, dengan pembangunan berterusan siaran langsung, video dan bidang lain, secara beransur-ansur mengembangkan skop aplikasinya dan menjadi komponen yang sangat diperlukan dalam siaran langsung, video dan bidang lain. Barrage boleh meningkatkan interaktiviti, meningkatkan pengalaman pengguna dan menjadikan tontonan lebih menarik. Menggunakan bahasa Golang untuk melaksanakan fungsi barrage boleh meningkatkan keselarasan dan prestasi program, dan juga menyumbang kepada kebolehbacaan dan kebolehselenggaraan kod.

Artikel ini akan memperkenalkan cara menggunakan Golang untuk melaksanakan fungsi barrage dan melampirkan contoh kod yang sepadan. Mula-mula, anda perlu memahami seni bina platform barrage: klien (pengirim) menghantar barrage ke pelayan melalui protokol barrage, dan pelayan menerima permintaan barrage dan menghuraikan dan menyimpannya, sambil menyiarkan barrage kepada semua penonton (penerima). ).

Berdasarkan perkara ini, kami boleh membahagikan rentetan kepada tiga modul: modul siaran klien, pelayan dan mesej. Dalam pelaksanaan bahagian pelayan, konkurensi, kebolehbacaan dan kebolehselenggaraan perlu dipertimbangkan.

1. Pelaksanaan pihak pelanggan

Golang, sebagai bahasa pengaturcaraan serentak yang cekap, sangat sesuai untuk melaksanakan logik perniagaan pihak pelanggan. Dari segi pelaksanaan pelanggan, Golang menyediakan pakej bersih dan bufio untuk memudahkan komunikasi rangkaian dan caching baca-tulis.

Berikut ialah contoh kod untuk pelanggan mudah untuk menghantar rentetan:

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
)

func main() {
    var (
        addr     = "127.0.0.1:9090"
        inputStr string
    )

    conn, err := net.Dial("tcp", addr)
    if err != nil {
        fmt.Println("Connect failed:", err)
        os.Exit(1)
    }
    defer conn.Close()

    reader := bufio.NewReader(os.Stdin)
    for {
        fmt.Print("请输入发送的弹幕：")
        inputStr, _ = reader.ReadString('
')
        conn.Write([]byte(inputStr))
    }
}

Perlu diingatkan bahawa di sini kita menyambung ke pelayan melalui kaedah net.Dial() dan bufio.NewReader () Dapatkan input konsol.

2. Pelaksanaan bahagian pelayan

Apabila melaksanakan program bahagian pelayan, anda perlu memberi perhatian kepada keselarasan dan prestasi. Di Golang, anda boleh menggunakan goroutine dan saluran untuk mencapai keselarasan, yang juga merupakan ciri utama Golang.

Dalam pelaksanaan bahagian pelayan, dua gorout perlu dilaksanakan: satu untuk menerima permintaan bertubi-tubi dan satu lagi untuk menyiarkan mesej bertubi-tubi. Mesej bertubi-tubi yang diterima akan disiarkan kepada semua pelanggan.

Berikut ialah logik teras bahagian pelayan:

package main

import (
    "bufio"
    "fmt"
    "net"
)

type Client struct {
    C    chan string
    Name string
}

var (
    entering = make(chan Client)
    leaving  = make(chan Client)
    messages = make(chan string)
    clients  = make(map[Client]bool)
)

func main() {
    var (
        addr = "127.0.0.1:9090"
    )

    listener, err := net.Listen("tcp", addr)
    if err != nil {
        fmt.Println("Listen failed:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Server is running on", addr)

    go broadcaster()

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Accept failed:", err)
            continue
        }

        go handleClient(conn)
    }
}

func broadcaster() {
    clients := make(map[Client]bool)
    for {
        select {
        case msg := <-messages:
            for cli := range clients {
                cli.C <- msg
            }
        case cli := <-entering:
            clients[cli] = true
            for c := range clients {
                c.C <- fmt.Sprintf("%s 加入房间", cli.Name)
            }
        case cli := <-leaving:
            delete(clients, cli)
            close(cli.C)
            for c := range clients {
                c.C <- fmt.Sprintf("%s 离开房间", cli.Name)
            }
        }
    }
}

func handleClient(conn net.Conn) {
    ch := make(chan string, 1)
    defer close(ch)

    client := Client{ch, conn.RemoteAddr().String()}
    clients[client] = true

    ch <- "欢迎 " + client.Name + " 加入房间"

    entering <- client

    input := bufio.NewScanner(conn)
    for input.Scan() {
        messages <- client.Name + ": " + input.Text()
    }

    if err := input.Err(); err != nil {
        fmt.Println("reading error:", err)
    }

    leaving <- client
}

Seperti yang ditunjukkan dalam kod di atas, fungsi handleClient() digunakan untuk memproses permintaan klien tunggal dan menyiarkan mesej yang diterima ke semua pelanggan melalui saluran mesej Tambah maklumat pelanggan ke senarai pelanggan. Mesej masuk atau keluar dari bilik disiarkan melalui saluran masuk dan keluar.

Fungsi penyiaran broadcaster() bergelung secara berterusan, terus menerima mesej daripada tiga saluran dan sebaik sahaja terdapat mesej, ia disiarkan kepada semua pelanggan. Perlu diingatkan bahawa anda perlu menggunakan julat untuk melintasi semua objek Klien dalam klien.

3. Pelaksanaan siaran mesej

Dalam kod di atas, kami menggunakan tiga saluran masuk, keluar dan mesej untuk penghantaran. Dalam fungsi broadcaster(), penggunaan pernyataan terpilih mengurangkan gangguan goroutine dan mengelakkan situasi kebuntuan.

Mesej yang diterima daripada saluran masuk menunjukkan bahawa pelanggan telah menyertai bilik itu perlu ditambahkan pada senarai pelanggan dan disiarkan kepada pelanggan lain bahawa pengguna telah menyertai bilik. Mesej yang diterima daripada saluran keluar menunjukkan bahawa pelanggan telah meninggalkan bilik dan perlu dialih keluar daripada senarai pelanggan dan disiarkan kepada pelanggan lain bahawa pengguna telah meninggalkan bilik. Mesej yang diterima daripada saluran mesej adalah bertubi-tubi yang dihantar oleh pelanggan dan perlu disiarkan kepada semua pengguna yang menonton siaran langsung.

Dalam fungsi handleClient(), kami membaca mesej yang dihantar oleh klien dan menghantarnya ke saluran mesej, sekali gus merealisasikan siaran rentetan.

4. Ringkasan

Di atas ialah kaedah pelaksanaan khusus menggunakan Golang untuk melaksanakan fungsi baraj. Melalui penggunaan goroutine dan saluran, fungsi baraj dapat dilaksanakan dengan mudah dan cekap. Dalam aplikasi sebenar, fungsi barrage boleh dikembangkan dan kod diubah suai mengikut keperluan.

Atas ialah kandungan terperinci pelaksanaan benteng golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!