Golang builds websocket-Golang-php.cn

Home

Backend Development

Golang

Golang builds websocket

WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB

May 22, 2023 pm 07:21 PM

Golang is a fast-compilation, efficient, and safe programming language that is also widely used in Web development. Among them, using Golang to build Websocket is a very popular application scenario. This article will introduce how to use Golang to build a Websocket application.

1. What is Websocket

Websocket is a protocol that allows the establishment of a two-way communication connection between the browser and the server. The traditional HTTP protocol can only send requests to the server by the browser and receive responses from the server. However, using Websocket allows the server to actively send messages to the browser, realizing full-duplex communication between the server and the browser.

2. How Golang implements Websocket

Golang comes with a standard library net/http. This package provides a http.Server structure body, which can be used to build web servers. In addition, net/http also provides a websocket sub-package, which provides us with all the functions needed to build a WebSocket server.

Establishing a WebSocket connection

To establish a WebSocket connection, the client needs to send an HTTP request to the server and carry the Upgrade header to indicate that the request is upgraded to the WebSocket protocol. After receiving this request, the server needs to check the Upgrade header and process it accordingly depending on whether it is a WebSocket request.

The server can use the websocket.IsWebSocketUpgrade function to check whether the request is a WebSocket request, and use the websocket.Upgrade function to upgrade the request. After the upgrade is successful, the server can communicate with the client through the connection object of type *websocket.Conn.

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()
    // 使用conn进行通信
}

Among them, upgrader is a websocket.Upgrader type variable. By setting its properties, you can control the processing method of WebSocket connection. UpgradeThe function will block when upgrading the request, so it must be run in a goroutine.

Sending and receiving WebSocket messages

Once the WebSocket connection is successfully established, both the client and the server can communicate through the *websocket.Conn object. Use this object to send and receive WebSocket messages.

Sending a message is very simple, just call the WriteMessage method:

err := conn.WriteMessage(websocket.TextMessage, []byte("hello"))

There are three ways to receive messages:

ReadMessage: Blocks reading until a message arrives
NextReader: Blocks and waits for the next message to arrive
NextWriter: Returns a io.WriteCloser object, you can use this object to send messages

Generally use the ReadMessage method to receive WebSocket messages:

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

3. One Simple WebSocket application

In this example, we will create a simple chat room application. After the client sends a message, the server broadcasts the message to all connected clients.

Client side code: (using JavaScript)

<!DOCTYPE html>
<html>
<head>
    <title>Chatroom</title>
</head>
<body>
    <input type="text" id="input-message"/>
    <button onclick="sendMessage()">发送</button>
    <ul id="message-list"></ul>

    <script>
        var ws = new WebSocket("ws://localhost:8080/ws");
        ws.onmessage = function(event) {
            var message = event.data;
            var li = document.createElement("li");
            li.appendChild(document.createTextNode(message));
            document.getElementById("message-list").appendChild(li);
        };

        function sendMessage() {
            var message = document.getElementById("input-message").value;
            ws.send(message);
        }
    </script>
</body>
</html>

Server side code:

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func main() {
    http.HandleFunc("/ws", wsHandler)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

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

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        fmt.Printf("recv: %s
", message)

        // 广播给所有客户端
        for _, conn := range conns {
            err := conn.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println(err)
                break
            }
        }
    }
}

In the above code, we connect all connected websocket.ConnObjects are stored in conns variables. Whenever a new message arrives, the server broadcasts the message to all clients.

Summary

It is very simple to build a WebSocket application using Golang. You only need to import the net/http and websocket packages and use the standard library directly. The provided API can complete the development of WebSocket applications. I hope this article can be helpful to Golang Websocket development.

The above is the detailed content of Golang builds websocket. For more information, please follow other related articles on the PHP Chinese website!

Statement

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Go language pack import: What is the difference between underscore and without underscore?Mar 03, 2025 pm 05:17 PM

This article explains Go's package import mechanisms: named imports (e.g., import "fmt") and blank imports (e.g., import _ "fmt"). Named imports make package contents accessible, while blank imports only execute t

How to implement short-term information transfer between pages in the Beego framework?Mar 03, 2025 pm 05:22 PM

This article explains Beego's NewFlash() function for inter-page data transfer in web applications. It focuses on using NewFlash() to display temporary messages (success, error, warning) between controllers, leveraging the session mechanism. Limita

How to convert MySQL query result List into a custom structure slice in Go language?Mar 03, 2025 pm 05:18 PM

This article details efficient conversion of MySQL query results into Go struct slices. It emphasizes using database/sql's Scan method for optimal performance, avoiding manual parsing. Best practices for struct field mapping using db tags and robus

How do I write mock objects and stubs for testing in Go?Mar 10, 2025 pm 05:38 PM

This article demonstrates creating mocks and stubs in Go for unit testing. It emphasizes using interfaces, provides examples of mock implementations, and discusses best practices like keeping mocks focused and using assertion libraries. The articl

How can I define custom type constraints for generics in Go?Mar 10, 2025 pm 03:20 PM

This article explores Go's custom type constraints for generics. It details how interfaces define minimum type requirements for generic functions, improving type safety and code reusability. The article also discusses limitations and best practices

How to write files in Go language conveniently?Mar 03, 2025 pm 05:15 PM

This article details efficient file writing in Go, comparing os.WriteFile (suitable for small files) with os.OpenFile and buffered writes (optimal for large files). It emphasizes robust error handling, using defer, and checking for specific errors.

How do you write unit tests in Go?Mar 21, 2025 pm 06:34 PM

The article discusses writing unit tests in Go, covering best practices, mocking techniques, and tools for efficient test management.

How can I use tracing tools to understand the execution flow of my Go applications?Mar 10, 2025 pm 05:36 PM

This article explores using tracing tools to analyze Go application execution flow. It discusses manual and automatic instrumentation techniques, comparing tools like Jaeger, Zipkin, and OpenTelemetry, and highlighting effective data visualization

See all articles

Hot AI Tools

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress images for free

Clothoff.io

AI clothes remover

AI Hentai Generator

Generate AI Hentai for free.

Hot Article

R.E.P.O. Energy Crystals Explained and What They Do (Yellow Crystal)

2 weeks agoBy尊渡假赌尊渡假赌尊渡假赌

Repo: How To Revive Teammates

1 months agoBy尊渡假赌尊渡假赌尊渡假赌

Hello Kitty Island Adventure: How To Get Giant Seeds

4 weeks agoBy尊渡假赌尊渡假赌尊渡假赌

How Long Does It Take To Beat Split Fiction?

3 weeks agoByDDD

R.E.P.O. Save File Location: Where Is It & How to Protect It?

3 weeks agoByDDD

Hot Tools

mPDF

mPDF is a PHP library that can generate PDF files from UTF-8 encoded HTML. The original author, Ian Back, wrote mPDF to output PDF files "on the fly" from his website and handle different languages. It is slower than original scripts like HTML2FPDF and produces larger files when using Unicode fonts, but supports CSS styles etc. and has a lot of enhancements. Supports almost all languages, including RTL (Arabic and Hebrew) and CJK (Chinese, Japanese and Korean). Supports nested block-level elements (such as P, DIV),

Safe Exam Browser

Safe Exam Browser is a secure browser environment for taking online exams securely. This software turns any computer into a secure workstation. It controls access to any utility and prevents students from using unauthorized resources.

MinGW - Minimalist GNU for Windows

This project is in the process of being migrated to osdn.net/projects/mingw, you can continue to follow us there. MinGW: A native Windows port of the GNU Compiler Collection (GCC), freely distributable import libraries and header files for building native Windows applications; includes extensions to the MSVC runtime to support C99 functionality. All MinGW software can run on 64-bit Windows platforms.