Go如何使用websocket實現彈幕功能-Golang-PHP中文網

首頁

後端開發

Golang

Go如何使用websocket實現彈幕功能

藏色散人

Aug 20, 2020 pm 01:08 PM

gogolang

##上建立中以

Golang教學專欄為大家提供方面的使用

Go如何使用websocket實現彈幕功能

使用websocket協議，客戶端發送一個訊息，服務端廣播到所有有效連接。

主要想法：
1.封裝*websocket.conn，用client結構表示一個客戶端。
2.維持一個map[client]bool，表示有效的客戶端映射，用於廣播訊息
3.除了處理websocket連接外，還要開啟一個廣播協程，監聽客戶端連接，斷開，發彈幕事件。

推薦：《

go語言教學》

#主要的結構：

type Client struct{
    wsConnect *websocket.Conn
    inChan chan []byte
    outChan chan []byte
    closeChan chan byte
    Name string //客户的名称
    Id string //客户id，唯一
    mutex sync.Mutex  // 对closeChan关闭上锁
    IsClosed bool  // 防止closeChan被关闭多次
}
type Message struct {
    EventType byte  `json:"type"`       // 0表示用户发布消息；1表示用户进入；2表示用户退出
    Name string     `json:"name"`       // 用户名称
    Message string  `json:"message"`    // 消息内容
}
    clients = make(map [*util.Client] bool)      // 用户组映射
    join = make(chan *util.Client, 10)        // 用户加入通道
    leave = make(chan *util.Client, 10)       // 用户退出通道
    message = make(chan Message, 10)    // 消息通道

server端程式碼

package main

import (
    "encoding/json"
    "fmt"
    "github.com/gorilla/websocket"
    "goGin/server/util"
    "net/http"
)

var(
    upgrader = websocket.Upgrader{
        // 允许跨域
        CheckOrigin:func(r *http.Request) bool{
            return true
        },
    }
    clients = make(map [*util.Client] bool)      // 用户组映射
    join = make(chan *util.Client, 10)        // 用户加入通道
    leave = make(chan *util.Client, 10)       // 用户退出通道
    message = make(chan Message, 10)    // 消息通道
)
type Message struct {
    EventType byte  `json:"type"`       // 0表示用户发布消息；1表示用户进入；2表示用户退出
    Name string     `json:"name"`       // 用户名称
    Message string  `json:"message"`    // 消息内容
}

func wsHandler(w http.ResponseWriter , r *http.Request){
    var(
        wsConn *websocket.Conn
        err error
        client *util.Client
        data []byte
    )
    r.ParseForm() //返回一个map,并且赋值给r.Form
    name := r.Form["name"][0]
    id := r.Form["id"][0]

    if wsConn , err = upgrader.Upgrade(w,r,nil); err != nil{
        return
    }

    if client , err = util.InitConnection(wsConn); err != nil{
        goto ERR
    }
    client.Id = id
    client.Name = name

    // 如果用户列表中没有该用户
    if !clients[client] {
        join <- client
    }

    for {
        if data , err = client.ReadMessage();err != nil{ //一直读消息，没有消息就阻塞
            goto ERR
        }
        var msg Message
        msg.EventType = 0
        msg.Name = client.Name
        msg.Message = string(data)
        message <- msg
    }

ERR:
    leave<-client//这个客户断开
    client.Close()

}

func broadcaster() {
    for {
        select {
        // 消息通道中有消息则执行，否则堵塞
        case msg := <-message:
            // 将数据编码成json形式，data是[]byte类型
            // json.Marshal()只会编码结构体中公开的属性(即大写字母开头的属性)
            data, err := json.Marshal(msg)
            if err != nil {
                return
            }
            for client := range clients {
                if client.IsClosed == true {
                    leave<-client//这个客户断开
                    continue
                }
                // fmt.Println("=======the json message is", string(data))  // 转换成字符串类型便于查看
                if client.WriteMessage(data) != nil {
                    continue //发送失败就跳过
                }
            }

        // 有用户加入
        case client := <-join:
            clients[client] = true  // 将用户加入映射
            // 将用户加入消息放入消息通道
            var msg Message
            msg.Name = client.Name
            msg.EventType = 1
            msg.Message = fmt.Sprintf("%s join in, there are %d preson in room", client.Name, len(clients))
            message <- msg

        // 有用户退出
        case client := <-leave:
            // 如果该用户已经被删除
            if !clients[client] {
                break
            }
            delete(clients, client) // 将用户从映射中删除
            // 将用户退出消息放入消息通道
            var msg Message
            msg.Name = client.Name
            msg.EventType = 2
            msg.Message = fmt.Sprintf("%s leave, there are %d preson in room", client.Name, len(clients))
            message <- msg
        }
    }
}

func main(){
    go broadcaster()
    http.HandleFunc("/ws",wsHandler)
    http.ListenAndServe("0.0.0.0:7777",nil)
}

封裝client

package util
import (
    "github.com/gorilla/websocket"
    "sync"
    "errors"
)
type Client struct{
    wsConnect *websocket.Conn
    inChan chan []byte
    outChan chan []byte
    closeChan chan byte
    Name string //客户的名称
    Id string //客户id，唯一

    mutex sync.Mutex  // 对closeChan关闭上锁
    IsClosed bool  // 防止closeChan被关闭多次
}
func InitConnection(wsConn *websocket.Conn)(conn *Client ,err error){
    conn = &Client{
        wsConnect:wsConn,
        inChan: make(chan []byte,1000),
        outChan: make(chan []byte,1000),
        closeChan: make(chan byte,1),
        IsClosed:false,
    }
    // 启动读协程
    go conn.readLoop();
    // 启动写协程
    go conn.writeLoop();
    return
}
func (conn *Client)ReadMessage()(data []byte , err error){
    select{
    case data = <- conn.inChan:
    case <- conn.closeChan:
        err = errors.New("connection is closeed")
    }
    return
}
func (conn *Client)WriteMessage(data []byte)(err error){
    select{
    case conn.outChan <- data:
    case <- conn.closeChan:
        err = errors.New("connection is closeed")
    }
    return
}
func (conn *Client)Close(){
    // 线程安全，可多次调用
    conn.wsConnect.Close()
    // 利用标记，让closeChan只关闭一次
    conn.mutex.Lock()
    if !conn.IsClosed {
        close(conn.closeChan)
        conn.IsClosed = true
    }
    conn.mutex.Unlock()
}

func (conn *Client)readLoop(){
    var(
        data []byte
        err error
    )
    for{
        if _, data , err = conn.wsConnect.ReadMessage(); err != nil{
            goto ERR
        }
        //阻塞在这里，等待inChan有空闲位置
        select{
        case conn.inChan <- data:
        case <- conn.closeChan:        // closeChan 感知 conn断开
            goto ERR
        }

    }

ERR:
    conn.Close()
}

func (conn *Client)writeLoop(){
    var(
        data []byte
        err error
    )

    for{
        select{
        case data= <- conn.outChan:
        case <- conn.closeChan:
            goto ERR
        }
        if err = conn.wsConnect.WriteMessage(websocket.TextMessage , data); err != nil{
            goto ERR
        }
    }

ERR:
    conn.Close()

}

客戶端程式碼

<!DOCTYPE html>
<html>
<head>
    <title>go websocket</title>
    <meta charset="utf-8" />
</head>
<body>
<script type="text/javascript">
    var wsUri ="ws://127.0.0.1:7777/ws?name=aaa&id=112";
    var output;

    function init() {
        output = document.getElementById("output");
        testWebSocket();
    }

    function testWebSocket() {
        websocket = new WebSocket(wsUri);
        websocket.onopen = function(evt) {
            onOpen(evt)
        };
        websocket.onclose = function(evt) {
            onClose(evt)
        };
        websocket.onmessage = function(evt) {
            onMessage(evt)
        };
        websocket.onerror = function(evt) {
            onError(evt)
        };
    }

    function onOpen(evt) {
        writeToScreen("CONNECTED");
        // doSend("WebSocket rocks");
    }

    function onClose(evt) {
        writeToScreen("DISCONNECTED");
    }

    function onMessage(evt) {
        writeToScreen(&#39;<span style="color: blue;">RESPONSE: &#39;+ evt.data+&#39;</span>&#39;);
        // websocket.close();
    }

    function onError(evt) {
        writeToScreen(&#39;<span style="color: red;">ERROR:</span> &#39;+ evt.data);
    }

    function doSend(message) {
        // writeToScreen("SENT: " + message);
        websocket.send(message);
    }

    function writeToScreen(message) {
        var pre = document.createElement("p");
        pre.style.wordWrap = "break-word";
        pre.innerHTML = message;
        output.appendChild(pre);
    }

    window.addEventListener("load", init, false);
    function sendBtnClick(){
        var msg = document.getElementById("input").value;
        doSend(msg);
        document.getElementById("input").value = &#39;&#39;;
    }
    function closeBtnClick(){
        websocket.close();
    }
</script>
<h2 id="WebSocket-nbsp-Test">WebSocket Test</h2>
<input type="text" id="input"></input>
<button onclick="sendBtnClick()" >send</button>
<button onclick="closeBtnClick()" >close</button>
<div id="output"></div>

</body>
</html>

以上是Go如何使用websocket實現彈幕功能的詳細內容。更多資訊請關注PHP中文網其他相關文章！

陳述

本文轉載於：learnku。如有侵權，請聯絡admin@php.cn刪除

Golang vs.C：代碼示例和績效分析Apr 15, 2025 am 12:03 AM

Golang適合快速開發和並發編程，而C 更適合需要極致性能和底層控制的項目。 1)Golang的並發模型通過goroutine和channel簡化並發編程。 2)C 的模板編程提供泛型代碼和性能優化。 3)Golang的垃圾回收方便但可能影響性能，C 的內存管理複雜但控制精細。

Golang的影響：速度，效率和簡單性Apr 14, 2025 am 12:11 AM

goimpactsdevelopmentpositationality throughspeed，效率和模擬性。 1）速度：gocompilesquicklyandrunseff，IdealforlargeProjects.2）效率：效率：ITScomprehenSevestAndardArdardArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdEcceSteral Depentencies，增強的Depleflovelmentimency.3）簡單性。

C和Golang：表演至關重要時Apr 13, 2025 am 12:11 AM

C 更適合需要直接控制硬件資源和高性能優化的場景，而Golang更適合需要快速開發和高並發處理的場景。 1.C 的優勢在於其接近硬件的特性和高度的優化能力，適合遊戲開發等高性能需求。 2.Golang的優勢在於其簡潔的語法和天然的並發支持，適合高並發服務開發。

Golang行動：現實世界中的示例和應用程序Apr 12, 2025 am 12:11 AM

Golang在实际应用中表现出色，以简洁、高效和并发性著称。1)通过Goroutines和Channels实现并发编程，2)利用接口和多态编写灵活代码，3)使用net/http包简化网络编程，4)构建高效并发爬虫，5)通过工具和最佳实践进行调试和优化。

Golang：Go編程語言解釋了Apr 10, 2025 am 11:18 AM

Go語言的核心特性包括垃圾回收、靜態鏈接和並發支持。 1.Go語言的並發模型通過goroutine和channel實現高效並發編程。 2.接口和多態性通過實現接口方法，使得不同類型可以統一處理。 3.基本用法展示了函數定義和調用的高效性。 4.高級用法中，切片提供了動態調整大小的強大功能。 5.常見錯誤如競態條件可以通過gotest-race檢測並解決。 6.性能優化通過sync.Pool重用對象，減少垃圾回收壓力。