mise en œuvre du barrage de Golang

Barrage, avec le développement continu de la diffusion en direct, de la vidéo et d'autres domaines, a progressivement élargi son champ d'application et est devenu un composant indispensable dans la diffusion en direct, la vidéo et d'autres domaines. Barrage peut augmenter l’interactivité, améliorer l’expérience utilisateur et rendre le visionnage plus intéressant. L'utilisation du langage Golang pour implémenter la fonction de barrage peut améliorer la concurrence et les performances du programme, et également contribuer à la lisibilité et à la maintenabilité du code.

Cet article expliquera comment utiliser Golang pour implémenter la fonction de barrage et joindra des exemples de code correspondants. Tout d'abord, vous devez comprendre l'architecture de la plateforme de barrage : le client (l'expéditeur) envoie le barrage au serveur via le protocole de barrage. Le serveur reçoit la demande de barrage, l'analyse et la stocke, et en même temps diffuse le barrage à tous. téléspectateurs (récepteurs).

Sur cette base, nous pouvons diviser le barrage en trois modules : client, serveur et module de diffusion de messages. Dans la mise en œuvre côté serveur, la concurrence, la lisibilité et la maintenabilité doivent être prises en compte.

1. Implémentation côté client

Golang, en tant que langage de programmation simultanée efficace, est très approprié pour implémenter une logique métier côté client. En termes d'implémentation client, Golang fournit des packages net et bufio pour faciliter la communication réseau et la mise en cache en lecture-écriture.

Ce qui suit est un exemple de code permettant à un client simple d'envoyer des barrages :

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

Il convient de noter qu'ici, nous nous connectons au serveur via la méthode net.Dial() et obtenons l'entrée de la console via bufio.NewReader().

2. Implémentation côté serveur

Lors de la mise en œuvre de programmes côté serveur, vous devez faire attention à la concurrence et aux performances. Dans Golang, vous pouvez utiliser goroutine et canal pour obtenir la concurrence, ce qui est également une fonctionnalité majeure de Golang.

Dans l'implémentation côté serveur, deux goroutines doivent être implémentées : une pour recevoir les demandes de barrage et l'autre pour diffuser les messages de barrage. Les messages de barrage reçus seront diffusés à tous les clients.

Ce qui suit est la logique de base du côté serveur :

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
}

Comme le montre le code ci-dessus, la fonction handleClient() est utilisée pour traiter une seule demande client, diffuser le message reçu à tous les clients via le canal de messages et ajoutez les informations du client à la liste des clients en même temps. Les messages entrant ou sortant d'une pièce sont diffusés via les canaux d'entrée et de sortie.

La fonction de diffusion Broadcaster() continue de tourner en boucle, recevant continuellement des messages des trois canaux, et une fois qu'il y a un message, il est diffusé à tous les clients. Il convient de noter que vous devez utiliser range pour parcourir tous les objets Client dans les clients.

3. Implémentation de la diffusion des messages

Dans le code ci-dessus, nous utilisons trois canaux d'entrée, de sortie et de transmission de messages. Dans la fonction Broadcaster(), l'utilisation d'instructions select réduit les interférences de goroutine et évite les situations de blocage.

Le message reçu du canal entrant indique qu'un client a rejoint la salle. Il doit être ajouté à la liste des clients et diffuser aux autres clients que l'utilisateur a rejoint la salle. Le message reçu du canal de sortie indique que le client a quitté la salle et doit être supprimé de la liste des clients et diffusé aux autres clients que l'utilisateur a quitté la salle. Les messages reçus du canal de messages sont des barrages envoyés par le client et doivent être diffusés à tous les utilisateurs qui regardent la diffusion en direct.

Dans la fonction handleClient(), nous lisons les messages envoyés par le client et les envoyons au canal de messages, réalisant ainsi la diffusion des barrages.

4. Résumé

Ce qui précède est la méthode d'implémentation spécifique d'utilisation de Golang pour implémenter la fonction de barrage. Grâce à l'utilisation de goroutine et de canal, la fonction de barrage peut être mise en œuvre de manière simple et efficace. Dans les applications réelles, la fonction de barrage peut être étendue et le code modifié en fonction des besoins.

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!