Golang WebSocket Programming Guide: Building high-performance real-time applications

Golang WebSocket Programming Guide: Building high-performance real-time applications

Introduction:
With the rapid development of the Internet, the need for real-time communication is becoming more and more urgent. As a two-way communication protocol, WebSocket can establish a persistent connection between the browser and the server, providing an efficient and reliable solution for real-time applications. This article will introduce how to use Golang to build high-performance real-time applications and give specific code examples.

1. What is the WebSocket protocol?
The WebSocket protocol is a TCP-based protocol that establishes a persistent full-duplex connection between the browser and the server, allowing the server to actively communicate with the browser. Push data to achieve real-time communication. Compared with the traditional HTTP protocol, the WebSocket protocol has the following advantages:

1. Compared with the HTTP protocol, the handshake process of the WebSocket protocol is simpler, reducing the delay in connection establishment.
2. The WebSocket protocol can transmit data in both directions within a connection, reducing the overhead of transmitting data.
3. WebSocket protocol supports cross-domain communication and can establish connections under different domain names to realize data sharing and exchange.

2. WebSocket Programming in Golang
As a high-performance programming language, Golang provides a convenient and easy-to-use standard library to handle WebSocket communication. The following is a sample code for a simple WebSocket server:

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func main() {
    http.HandleFunc("/echo", echoHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func echoHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal("upgrade error:", err)
    }
    defer conn.Close()

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("read error:", err)
            break
        }
        log.Println("receive:", string(message))

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("write error:", err)
            break
        }
    }
}

In the above code, the WebSocket request is mapped to # through the http.HandleFunc function and the route /echo ##echoHandlerFunction. In the echoHandler function, we use websocket.Upgrader to upgrade the HTTP connection to a WebSocket connection and get a websocket.Conn instance. Implemented a simple WebSocket Echo server by reading messages from conn and writing the same messages.

3. Real-time chat room example

The above example only implements a simple message echo function. Below, we will show how to use Golang to build a real-time chat room where multiple users can communicate in real-time at the same time.

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

type Message struct {
    Username string `json:"username"`
    Content  string `json:"content"`
}

type Room struct {
    clients  map[*websocket.Conn]bool
    broadcast chan Message
    join     chan *websocket.Conn
    leave    chan *websocket.Conn
}

func (r *Room) start() {
    for {
        select {
        case conn := <-r.join:
            r.clients[conn] = true
        case conn := <-r.leave:
            delete(r.clients, conn)
            close(conn)
        case message := <-r.broadcast:
            for conn := range r.clients {
                err := conn.WriteJSON(message)
                if err != nil {
                    log.Println("write error:", err)
                    delete(r.clients, conn)
                    close(conn)
                }
            }
        }
    }
}

func main() {
    r := Room{
        clients:  make(map[*websocket.Conn]bool),
        broadcast: make(chan Message),
        join:     make(chan *websocket.Conn),
        leave:    make(chan *websocket.Conn),
    }

    go r.start()

    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            log.Fatal("upgrade error:", err)
        }

        r.join <- conn

        defer func() {
            r.leave <- conn
        }()

        for {
            var message Message
            err = conn.ReadJSON(&message)
            if err != nil {
                log.Println("read error:", err)
                break
            }

            r.broadcast <- message
        }
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}

In the above code, we define a

Room type to manage connected clients. The Room type internally contains clients to save all connected clients, broadcast to broadcast messages, join and leave is used to handle client connections and disconnections.

In the

main function, we create a Room instance and start Room# through go r.start() ##Instance message processing coroutine. Map WebSocket requests to anonymous functions through the http.HandleFunc function and route /ws. In the anonymous function, we join the connection to the join channel of Room, and at the end of the function we leave the connection from leave of Room removed from the channel. At the same time, we use conn.ReadJSON and conn.WriteJSON to read and write messages in JSON format respectively. Conclusion:

This article gives a guide to building high-performance real-time applications by introducing the characteristics of the WebSocket protocol and how to use it in Golang. By providing specific code examples, readers can quickly get started with Golang WebSocket programming and apply real-time communication functions in projects. Hope this article helps you!

The above is the detailed content of Golang WebSocket Programming Guide: Building high-performance real-time applications. For more information, please follow other related articles on the PHP Chinese website!