How to use WebSocket for file transfer in golang

WebSocket is a network protocol that supports two-way communication and can establish a persistent connection between the browser and the server . In golang, we can use the third-party library gorilla/websocket to implement WebSocket functionality. This article will introduce how to use golang and gorilla/websocket libraries for file transfer.

First, we need to install the gorilla/websocket library. You can use the following command to install:

go get github.com/gorilla/websocket

Next, we create a golang server-side program to receive and handle WebSocket connections. The following is a sample 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
        }
    }
}

The above code creates an HTTP processing function to handle WebSocket connection requests. In this handler function, we first upgrade the HTTP connection to a WebSocket connection, and then enter an infinite loop to continuously receive messages from the client and return a simple response. The sample code here does not perform file transfer, but simply demonstrates the process of receiving and sending messages.

Next, we create a golang client program to connect to the server and send files to the server. The following is the sample 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")
}

The above code creates a WebSocket client, connects to the server and sends the file. In this client, we first send the file name to the server, then read the file content in a loop and send it to the server until the file is read. Finally, we send an end message to the server to indicate that the transfer is complete.

Note that the client program needs to prepare a file named test.txt in advance, which will be sent to the server. You can change the file name and path according to actual needs.

The above is a simple example of using WebSocket for file transfer. By using the gorilla/websocket library, WebSocket functions can be easily implemented in golang. However, in actual applications, more scenarios need to be handled, such as disconnection processing, file fragmentation transfer, etc. During the development process, issues such as security and performance also need to be considered. I hope this article can be helpful to you and inspire you to use WebSocket for file transfer in golang.

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