How to use Go language to develop a real-time data transmission system based on Websocket-Golang-php.cn

How to use Go language to develop a real-time data transmission system based on Websocket

WBOY

Release： 2023-12-18 18:39:46

Original

657 people have browsed it

How to use Go language to develop a real-time data transmission system based on Websocket

How to use Go language to develop a real-time data transmission system based on Websocket, specific code examples are required

Websocket is a full-duplex protocol, which can be used without refreshing the page Achieve real-time data transmission under the circumstances. In modern web applications, real-time data transfer is a crucial part. This article will introduce how to use Go language to develop a real-time data transmission system based on Websocket, including how to implement server-side and client-side code, and provide specific code examples.

Create WebSocket server

To create a real-time data transmission system based on Websocket, you first need to create a Websocket server. In Go, you can use the gorilla/websocket library to create a Websocket server.

The following is a sample code for a simple Websocket server:

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

// 定义升级器
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func serveWs(w http.ResponseWriter, r *http.Request) {
    // 升级请求为Websocket
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 读取Websocket消息
    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            return
        }

        // 处理消息
        fmt.Println(string(p))

        // 回复消息
        err = conn.WriteMessage(messageType, p)
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

func main() {
    http.HandleFunc("/ws", serveWs)
    http.ListenAndServe(":8080", nil)
}

Copy after login

In this example, we first define an upgrader (upgrader), which is used to upgrade HTTP connections to Websocket connect. Then, we define a function serveWs that receives an HTTP response writer (w) and HTTP request (r) and upgrades the HTTP connection to a Websocket connection.

In the serveWs function, we first upgrade the HTTP connection to a Websocket connection. We then use a loop to read the Websocket messages. Once we have read the message, we process it and send the same message back to the client.

Finally, in the main function, we associate the serveWs function with the path /ws and start the HTTP server on port 8080.

Create Websocket client

Before creating the Websocket client, we need to create an HTML page that will communicate with the server through Websocket. The following is a sample code for a basic HTML page:

<!DOCTYPE html>
<html>
<head>
    <title>Websocket Example</title>
</head>
<body>

    <textarea id="message"></textarea>
    <button onclick="send()">Send</button>

    <script>
    // 创建Websocket对象
    var ws = new WebSocket("ws://localhost:8080/ws");

    // 接收来自服务器的消息
    ws.onmessage = function(event) {
        console.log(event.data);
    };

    // 发送消息到服务器
    function send() {
        var input = document.getElementById("message");
        ws.send(input.value);
        input.value = "";
    }
    </script>

</body>
</html>

Copy after login

In this example, we create a text area (message) and a button (send). When the user clicks the send button, we send the entered text to the server via Websocket.

In JavaScript, we use the WebSocket object to create a Websocket client. In our example, the Websocket client will connect to the /ws path and when it receives messages from the server, it will output them to the console.

Running Websocket Server and Client

To run Websocket Server and Client, follow these steps:

In the terminal, Use the command line to change to the directory containing the sample server code.
Enter the following command to start the server:

go run main.go

Copy after login

In a browser, open the following URL to load the sample HTML page:

http://localhost:8080/

Copy after login

Enter some text in the text area and click the send button. You should see messages being sent to and returned from the server, and output in the browser console.
Real-time data transmission

Now, we have successfully created a simple Websocket server and client, but this is just the beginning. To achieve real-time data transmission, we need to modify the server-side and client-side code and use goroutine on the server-side to handle multiple Websocket connections.

The following is a sample code that implements real-time data transmission:

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/gorilla/websocket"
)

// 定义升级器
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

// 定义客户端
type Client struct {
    conn *websocket.Conn
    send chan []byte
}

// 处理客户端消息
func (c *Client) read() {
    defer func() {
        c.conn.Close()
    }()
    for {
        messageType, p, err := c.conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            return
        }
        // 处理消息
        fmt.Printf("Received: %s
", p)
    }
}

// 发送消息到客户端
func (c *Client) write() {
    defer func() {
        c.conn.Close()
    }()
    for {
        select {
        case message, ok := <-c.send:
            if !ok {
                c.conn.WriteMessage(websocket.CloseMessage, []byte{})
                return
            }
            writer, err := c.conn.NextWriter(websocket.TextMessage)
            if err != nil {
                return
            }
            writer.Write(message)
            if err := writer.Close(); err != nil {
                return
            }
        }
    }
}

// 定义Hub
type Hub struct {
    clients map[*Client]bool
    broadcast chan []byte
    register chan *Client
    unregister chan *Client
}

// 创建Hub
func newHub() *Hub {
    return &Hub{
        clients:    make(map[*Client]bool),
        broadcast:  make(chan []byte),
        register:   make(chan *Client),
        unregister: make(chan *Client),
    }
}

// 运行Hub
func (h *Hub) run() {
    for {
        select {
        case client := <-h.register:
            h.clients[client] = true
            fmt.Println("Client registered")
        case client := <-h.unregister:
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
                close(client.send)
                fmt.Println("Client unregistered")
            }
        case message := <-h.broadcast:
            for client := range h.clients {
                select {
                case client.send <- message:
                    fmt.Printf("Sent: %s
", message)
                default:
                    close(client.send)
                    delete(h.clients, client)
                }
            }
        }
    }
}

func serveWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
    // 升级请求为Websocket
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 创建客户端
    client := &Client{
        conn: conn,
        send: make(chan []byte),
    }

    // 注册客户端
    hub.register <- client

    // 读取Websocket消息
    go client.read()

    // 发送Websocket消息
    go client.write()
}

func main() {
    // 创建Hub
    hub := newHub()

    // 运行Hub
    go hub.run()

    // 定期广播消息
    go func() {
        for {
            hub.broadcast <- []byte(fmt.Sprintf("Server Time: %s", time.Now().Format("2006-01-02 15:04:05")))
            time.Sleep(1 * time.Second)
        }
    }()

    // 启动HTTP服务器
    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        serveWs(hub, w, r)
    })
    http.Handle("/", http.FileServer(http.Dir(".")))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        panic(err)
    }
}

Copy after login

In this example, we define a Hub that manages multiple Websocket clients. Each client has a read (receive) goroutine and a write (send) goroutine, which handle messages read from the client and messages sent to the client respectively.

In addition to processing client messages, Hub also contains a broadcast channel for broadcasting messages to all clients. In our example, the Hub periodically broadcasts the current date and time.

Conclusion

Through the code examples in this article, we have learned how to use Go language to create a real-time data transmission system based on Websocket. We learned how to use the gorilla/websocket library to create a Websocket server and client, and implemented how to handle the client's input, how to send messages to the client, and implemented a Hub that manages multiple Websocket clients, and implemented The logic of broadcast messages.

The above is the detailed content of How to use Go language to develop a real-time data transmission system based on Websocket. For more information, please follow other related articles on the PHP Chinese website!