How to use WebSocket in Go?

In recent years, WebSocket technology has become an indispensable part of Web development. WebSocket is a protocol for full-duplex communication over a single TCP connection, which makes communication between client and server smoother and more efficient. Today, many modern web applications use WebSocket technology, such as real-time chat, online games, and real-time data visualization.

As a modern programming language, Go language naturally provides good support for WebSocket technology. In this article, we will take a deep dive into how to use WebSocket technology in Go.

Implementation of WebSocket in Go language

The WebSocket protocol is derived from the HTTP upgrade protocol, so using WebSocket in the Go language also requires combining it with the HTTP protocol. Go language has built-in net/http package, which provides various HTTP-related functions. If we want to use WebSocket in Go, just import the net/http and github.com/gorilla/websocket libraries.

Next, let’s take a look at how to use the github.com/gorilla/websocket library to implement WebSocket.

Creating a WebSocket server

In the Go language, the way to create a WebSocket server is relatively simple. Let's look directly at the following code, which shows how to create an HTTP server and wait for the client's WebSocket connection:

package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

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

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Received message: %s
", message)

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Sent message: %s
", message)
    }
}

In the above code, we first create a websocket.Upgrader object, It is responsible for upgrading incoming HTTP connections to WebSocket connections. Then, we created a handleWebSocket function that will be called when the client connects. This function will first upgrade the incoming HTTP connection to a WebSocket connection, then enter a loop, continuously receive information from the client, and pass the received information back to the client. Among them, conn.ReadMessage() and conn.WriteMessage() are used to read and write information respectively.

Finally, we bind the handleWebSocket function to the /ws route and start the HTTP server so that the client can connect to the WebSocket server. If everything goes well, when we start the above code, you will see output similar to the following:

2021/10/13 15:20:06 http: Server started at http://127.0.0.1:8080

This means that you have successfully created a WebSocket server, and the client can use ws:// localhost:8080/ws address to connect to the server.

Creating a WebSocket client

Similar to creating a WebSocket server, we can also easily create a WebSocket client in the Go language. Let's look at the following code, which describes how to create a client that establishes a connection with a WebSocket server:

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "syscall"
    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("Connecting to %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    done := make(chan struct{})
    go func() {
        defer close(done)
        for {
            messageType, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("Received message: %s
", message)
            if err := conn.WriteMessage(messageType, message); err != nil {
                log.Println("write:", err)
                return
            }
            log.Printf("Sent message: %s
", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")

            if err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

In the above code, we use the websocket.Dial method to communicate with WebSocket The server establishes a connection. After the connection is established, we enter an infinite loop, constantly sending and receiving information from the WebSocket server. Among them, conn.ReadMessage() and conn.WriteMessage() are used to read and write information.

It is worth noting that in the above code, we use channels to wait for the operation to complete. If the interrupt signal is received, we will send a websocket.CloseMessage message to the server to close the WebSocket connection.

Conclusion

In this article, we learned how to implement WebSocket in Go language using the github.com/gorilla/websocket library. Using WebSocket technology can add more dynamics and interactions to our web applications, making the application more modern and user-friendly.

If you have any questions or comments about WebSocket technology and how to use it in the Go language, please leave a message below to share your thoughts with us.

The above is the detailed content of How to use WebSocket in Go?. For more information, please follow other related articles on the PHP Chinese website!