Comment utiliser WebSocket pour le transfert de fichiers dans Golang

Comment utiliser WebSocket pour le transfert de fichiers dans Golang

WebSocket est un protocole réseau qui prend en charge la communication bidirectionnelle et est capable d'établir une connexion persistante entre le navigateur et le serveur. Dans Golang, nous pouvons utiliser la bibliothèque tierce gorilla/websocket pour implémenter la fonctionnalité WebSocket. Cet article explique comment utiliser les bibliothèques Golang et Gorilla/Websocket pour le transfert de fichiers.

Tout d’abord, nous devons installer la bibliothèque gorilla/websocket. Il peut être installé à l'aide de la commande suivante :

go get github.com/gorilla/websocket

Ensuite, nous créons un programme côté serveur Golang pour recevoir et gérer les connexions WebSocket. Voici un exemple de code :

package main

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

    "github.com/gorilla/websocket"
)

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

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

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

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

        err = conn.WriteMessage(websocket.TextMessage, []byte("Message received!"))
        if err != nil {
            log.Print("write error: ", err)
            break
        }
    }
}

Le code ci-dessus crée une fonction de traitement HTTP pour gérer les demandes de connexion WebSocket. Dans cette fonction de gestionnaire, nous mettons d'abord à niveau la connexion HTTP vers une connexion WebSocket, puis entrons dans une boucle infinie pour recevoir en continu des messages du client et renvoyer une réponse simple. L'exemple de code ici n'effectue pas de transfert de fichiers, mais démontre simplement le processus de réception et d'envoi de messages.

Ensuite, nous créons un programme client Golang pour nous connecter au serveur et envoyer des fichiers au serveur. Voici l'exemple de code :

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"

    "github.com/gorilla/websocket"
)

func main() {
    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/"}
    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial error: ", err)
    }
    defer conn.Close()

    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal("open file error: ", err)
    }
    defer file.Close()

    fileInfo, _ := file.Stat()
    fileSize := fileInfo.Size()
    fileName := fileInfo.Name()

    err = conn.WriteMessage(websocket.TextMessage, []byte(fileName))
    if err != nil {
        log.Fatal("write error: ", err)
    }

    buffer := make([]byte, 1024)
    for {
        bytesRead, err := file.Read(buffer)
        if err != nil {
            break
        }

        err = conn.WriteMessage(websocket.BinaryMessage, buffer[:bytesRead])
        if err != nil {
            log.Fatal("write error: ", err)
        }
    }

    err = conn.WriteMessage(websocket.TextMessage, []byte("Transmission finished"))
    if err != nil {
        log.Fatal("write error: ", err)
    }

    fmt.Println("File transmission completed")
}

Le code ci-dessus crée un client WebSocket, se connecte au serveur et envoie le fichier. Dans ce client, nous envoyons d'abord le nom du fichier au serveur, puis lisons le contenu du fichier en boucle et l'envoyons au serveur jusqu'à ce que le fichier soit lu. Enfin, nous envoyons un message de fin au serveur pour indiquer que le transfert est terminé.

Notez que le programme client doit préparer à l'avance un fichier nommé test.txt, qui sera envoyé au serveur. Vous pouvez modifier le nom et le chemin du fichier en fonction des besoins réels.

Ce qui précède est un exemple simple d'utilisation de WebSocket pour le transfert de fichiers. En utilisant la bibliothèque gorilla/websocket, les fonctions WebSocket peuvent être facilement implémentées dans Golang. Cependant, dans les applications réelles, davantage de scénarios doivent être gérés, tels que le traitement des déconnexions, le transfert par fragmentation de fichiers, etc. Au cours du processus de développement, des questions telles que la sécurité et les performances doivent également être prises en compte. J'espère que cet article pourra vous être utile et vous inciter à utiliser WebSocket pour le transfert de fichiers dans Golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!