Publier des données binaires (flux d'application/d'octets)

Contenu de la question

Je souhaite télécharger un fichier avec le type de contenu défini sur application/octet-stream et les données binaires du fichier dans le corps de la requête. Comment ferais-je cela en golang, voici mon code de départ :

package main

import (
    "fmt"
    "log"
    "net/http"
    "net/http/httputil"
    "os"
)

func main() {
    file, err := os.Open("file.pdf")
    if err != nil {
        log.Fatalln(err)
    }

    req, err := http.NewRequest("POST", fmt.Sprintf("https://example.com/upload"), nil)
    req.Header.Add("Content-Type", "application/octet-stream")

    if err != nil {
        log.Fatalln(err)
    }

    client := &http.Client{
        Transport: &http.Transport{
            DisableCompression: true,
        },
    }

    resp, err := client.Do(req)
    if err != nil {
        log.Fatalln(err)
    }
    defer resp.Body.Close()

    reqDump, err := httputil.DumpRequest(req, true)
    if err != nil {
        log.Fatalln(err)
    }

    fmt.Println(reqDump)
}

Bonne réponse

J'ai préparé une réponse qui peut vous aider à résoudre votre problème. Tout le code appartient aux fonctions main.go 文件，只是为了演示。它有两个主要部分：handler 和 main. Commençons par le gestionnaire.

gestionnaire http

func handlefile(w http.responsewriter, r *http.request) {
    if r.method != http.methodpost {
        w.writeheader(http.statusmethodnotallowed)
        return
    }
    fmt.println("handlefile")
    data, err := io.readall(r.body)
    if err != nil {
        panic(err)
    }
    defer r.body.close()
    w.write(data)
}

Ici, je me base uniquement sur ce que vous utilisez (allez à la bibliothèque standard uniquement : http、io和fmt package). Nous avons juste besoin d'écrire la charge utile entrante lue à partir de la requête http dans le flux de réponse.

Fonctions principales

func main() {
    r := http.NewServeMux()
    r.HandleFunc("/example", HandleFile)
    srv := http.Server{
        Addr:    ":8000",
        Handler: r,
    }

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        if err := srv.ListenAndServe(); err != nil {
            fmt.Println(err.Error())
        }
    }()

    file, err := os.Open("file.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    req, err := http.NewRequest(http.MethodPost, "http://localhost:8000/example", file)
    if err != nil {
        panic(err)
    }
    req.Header.Set("Content-Type", "application/octet-stream")
    client := &http.Client{
        Transport: &http.Transport{
            DisableCompression: true,
        },
    }
    res, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer res.Body.Close()
    data, err := io.ReadAll(res.Body)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))

    srv.Shutdown(context.Background())
    wg.Wait()
}

En revanche, les fonctions main ont plus de logique à gérer. Passons-les en revue dans la liste :

1. Il crée un serveur http pour répondre aux demandes entrantes. Nous l'instrumentons pour les requêtes en utilisant le point de terminaison handlefile 处理程序来回复针对 /example que nous avons créé précédemment.
2. Nous utilisons sync.waitgroup pour exécuter le serveur dans une goroutine distincte. Grâce à cela, le serveur est opérationnel, mais nous pouvons continuer notre programme et y envoyer des requêtes http.
3. Nous préparons une requête http avec le contenu du fichier lu depuis le système de fichiers local (dans notre cas, la fonction file.txt）。我们将 content-type 标头设置为 application/octet-stream 并将文件句柄传递给 newrequest.
4. Nous faisons une requête et imprimons le contenu de la charge utile de la réponse http.
5. Nous arrêtons le serveur et utilisons la méthode wg.wait pour dire au groupe d'attente d'attendre toutes les goroutines.

Considérations finales

Le code écrit ici peut certainement être amélioré. Quoi qu'il en soit, juste à titre de démonstration, je préfère le garder aussi proche que possible du fichier original pour vous permettre de mieux comprendre comment publier des binaires sur un serveur http et comment exécuter le même programme client et serveur. S'il y a quelque chose qui n'est pas clair, dites-le-moi, merci !

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!