How to use Websocket in golang to forward data

In recent years, with the rapid development of Internet technology, Websocket technology has attracted increasing attention and attention. Websocket is a full-duplex communication protocol based on the TCP protocol, which enables two-way communication between web applications and servers. Using Websocket technology, critical real-time connections can be established while reducing network delays and improving data transmission efficiency. This article will introduce how to use Websocket technology to forward data in golang.

1. Working principle of Websocket

The process of Websocket communication has four steps:

1. Establish a connection: the client sends an HTTP request to the server and upgrades to the Websocket protocol.

2. Handshake: The server confirms the request and establishes a Websocket connection.

3. Communication: As we all know, HTTP is a stateless protocol. Once an HTTP connection is established between the client and the server, they will immediately disconnect. So according to this protocol, when the client and server communicate, they must send request and response messages. However, in the Websocket protocol, once the client establishes a connection with the server, they can maintain a long-lasting connection without sending HTTP request and response messages multiple times.

4. Close: The client or server disconnects the Websocket connection.

It can be seen that Websocket is different from the HTTP protocol. The HTTP protocol only supports the transmission of request and response messages, while the Websocket protocol supports real-time, two-way communication.

2. Using Websocket technology in golang

In golang, you can use the third-party library golang.org/x/net/websocket to implement Websocket communication. golang.org/x/net/websocket is a standard library of golang that can easily implement the Websocket communication protocol.

1. Installation

In golang, installing golang.org/x/net/websocket is very simple. Just enter the following command on the command line:

go get golang.org/x/net/websocket

After the installation is complete, we can use the API provided in this package to implement the Websocket communication function.

2. Websocket server

The following is an example of the server code of Websocket in golang:

package main

import (
    "golang.org/x/net/websocket"
    "log"
    "net/http"
)

func echoHandler(ws *websocket.Conn) {
    if err := websocket.Message.Send(ws, "Hello, Client!"); err != nil {
        log.Fatal(err)
    }
}

func main() {
    http.Handle("/", websocket.Handler(echoHandler))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

In the above example, we defined a function named echoHandler , this function handles the websocket connection and sends the message "Hello, Client!" to the client. Finally, we use the ListenAndServe function in the http package to start the Websocket server.

3. Websocket client

The following is an example of the client code for Websocket in golang:

package main

import (
    "fmt"
    "golang.org/x/net/websocket"
    "log"
)

func main() {
    origin := "http://localhost"
    url := "ws://localhost:8080/"
    ws, err := websocket.Dial(url, "", origin)
    if err != nil {
        log.Fatal(err)
    }
    var msg = make([]byte, 512)
    var n int
    if n, err = ws.Read(msg); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Received: %s.\n", msg[:n])
}

In this example, we use the WebSocket.Dial function to establish a connection with the Websocket server Connect, and then read the message returned from the server through WebSocket's Read method.

3. Implement Websocket data forwarding

When multiple clients establish connections with the Websocket server, the server must have a certain data forwarding function to meet the real-time communication needs between clients. . The following is a method to implement Websocket data forwarding, using the golang.org/x/net/websocket package:

package main

import (
    "golang.org/x/net/websocket"
    "log"
    "net/http"
)

// 保存所有的客户端连接
var clients []*websocket.Conn

func broadcast() {
    for {
        var data []byte
        // 从所有客户端接收数据
        for i := range clients {
            if err := websocket.Message.Receive(clients[i], &data); err != nil {
                // 如果有任何错误，则断开客户端连接
                clients[i].Close()
                log.Printf("Client %v disconnected\n", clients[i].RemoteAddr())
                // 将已关闭客户端从clients中删除
                clients = append(clients[:i], clients[i+1:]...)
                continue
            }
            // 向其他所有客户端广播数据
            for j := range clients {
                if err := websocket.Message.Send(clients[j], data); err != nil {
                    log.Printf("Unable to send message to %v: %v\n", clients[j].RemoteAddr(), err)
                }
            }
        }
    }
}

func main() {
    // 启动一个广播协程
    go broadcast()
    http.Handle("/", websocket.Handler(func(ws *websocket.Conn) {
        // 保存每个新连接
        clients = append(clients, ws)
        log.Printf("Client %v connected\n", ws.RemoteAddr())
    }))

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

In this example, we use a goroutine named broadcast to handle the data forwarding function. When any client connects, forward it to other clients. At the same time, when a client disconnects, the broadcast coroutine will delete it from clients.

To sum up, golang is an excellent Websocket implementation language, and you can easily implement the Websocket communication protocol using the golang.org/x/net/websocket package. When using Websocket to establish a real-time communication connection, instant communication between clients can be achieved by implementing the data forwarding function.

The above is the detailed content of How to use Websocket in golang to forward data. For more information, please follow other related articles on the PHP Chinese website!