Kombination von Golang WebSocket und JSON: Realisierung der Datenübertragung und -analyse

Die Kombination von Golang WebSocket und JSON: Datenübertragung und -analyse realisieren

In der modernen Webentwicklung wird die Datenübertragung in Echtzeit immer wichtiger. WebSocket ist ein Protokoll, das zur bidirektionalen Kommunikation verwendet wird. Im Gegensatz zum herkömmlichen HTTP-Anfrage-Antwort-Modell ermöglicht WebSocket dem Server, Daten aktiv an den Client zu übertragen. JSON (JavaScript Object Notation) ist ein leichtes Format für den Datenaustausch, das präzise, ​​leicht zu lesen und zwischen verschiedenen Programmiersprachen leicht zu analysieren ist.

In diesem Artikel wird erläutert, wie Sie mit Golang WebSocket und JSON kombinieren, um eine Datenübertragung und -analyse zu erreichen. Wir werden Golangs integrierte Pakete net/http und github.com/gorilla/websocket verwenden, um WebSocket-Verbindungen zu verarbeiten, und encoding/json dafür Analysieren und generieren Sie JSON-Daten. net/http和github.com/gorilla/websocket来处理WebSocket连接，并使用encoding/json来解析和生成JSON数据。

首先，我们需要安装gorilla/websocket包。你可以使用以下命令来安装：

go get github.com/gorilla/websocket

接下来，我们可以开始编写代码了。

package main

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

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

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

func echoHandler(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
        }

        // 解析JSON数据
        var msg Message
        err = json.Unmarshal(message, &msg)
        if err != nil {
            log.Println(err)
            break
        }

        // 输出收到的消息
        fmt.Println("收到消息:", msg.Content)

        // 发送响应消息
        response := Message{
            Content: "你发送的消息是：" + msg.Content,
        }

        // 将响应转换为JSON格式
        jsonResponse, err := json.Marshal(response)
        if err != nil {
            log.Println(err)
            break
        }

        // 发送JSON响应
        err = conn.WriteMessage(websocket.TextMessage, jsonResponse)
        if err != nil {
            log.Println(err)
            break
        }
    }
}

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

上述代码包含了一个WebSocket处理函数echoHandler，它接收客户端的WebSocket连接并处理消息的收发。在函数内部，我们首先读取客户端发送的消息，并解析为Message结构体。然后，我们输出收到的消息，生成响应消息，并将响应转换为JSON格式。最后，我们使用conn.WriteMessage将JSON响应发送给客户端。

在主函数中，我们将WebSocket处理函数echoHandler注册到/ws

Zuerst müssen wir das Paket gorilla/websocket installieren. Sie können es mit dem folgenden Befehl installieren:

var socket = new WebSocket("ws://localhost:8080/ws");
socket.onopen = function () {
    console.log('连接已打开');
    var message = {
        content: 'Hello Server!'
    };
    socket.send(JSON.stringify(message));
};
socket.onmessage = function (event) {
    console.log('收到服务器的响应：', JSON.parse(event.data));
    socket.close();
};
socket.onclose = function () {
    console.log('连接已关闭');
};

Als nächstes können wir mit dem Schreiben von Code beginnen.

rrreee

Der obige Code enthält eine WebSocket-Verarbeitungsfunktion echoHandler, die die WebSocket-Verbindung des Clients empfängt und das Senden und Empfangen von Nachrichten verarbeitet. Innerhalb der Funktion lesen wir zunächst die vom Client gesendete Nachricht und analysieren sie in eine Message-Struktur. Anschließend geben wir die empfangene Nachricht aus, generieren die Antwortnachricht und konvertieren die Antwort in das JSON-Format. Schließlich verwenden wir conn.WriteMessage, um die JSON-Antwort an den Client zu senden.

In der Hauptfunktion registrieren wir die WebSocket-Verarbeitungsfunktion echoHandler bei der Route /ws und überwachen den lokalen 8080-Port. 🎜🎜Öffnen Sie nach dem Kompilieren und Ausführen des Programms die WebSocket-Verbindung im Browser, und Sie können JSON-Daten über das WebSocket-Objekt von JavaScript senden und empfangen. Hier ist ein einfaches JavaScript-Codebeispiel: 🎜rrreee🎜 Im obigen JavaScript-Code erstellen wir eine WebSocket-Verbindung und senden JSON-Daten mit dem Nachrichteninhalt, wenn die Verbindung geöffnet wird. Wenn die Antwort vom Server empfangen wird, analysieren und drucken wir die Antwortnachricht und schließen die WebSocket-Verbindung. 🎜🎜Das Obige sind einige Beispielcodes für die Verwendung von Golang in Kombination mit WebSocket und JSON, um die Datenübertragung und -analyse zu realisieren. Durch die Verwendung von WebSocket und JSON können wir strukturierte Daten einfach zwischen Clients und Servern übertragen und analysieren und so eine Dateninteraktion in Echtzeit ermöglichen. Denken Sie beim Schreiben von Code, der für Ihren spezifischen Anwendungsfall funktioniert, daran, die erforderliche Fehlerbehandlung und Datenvalidierung einzubeziehen. Ich hoffe, dieser Artikel hilft Ihnen! 🎜

Das obige ist der detaillierte Inhalt vonKombination von Golang WebSocket und JSON: Realisierung der Datenübertragung und -analyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!