Binärdaten posten (Anwendung/Oktett-Stream)

Frageninhalt

Ich möchte eine Datei hochladen, deren Inhaltstyp auf application/octet-stream eingestellt ist und die Binärdaten der Datei im Anforderungstext enthalten sind. Wie würde ich das in Golang machen? Hier ist mein Startcode:

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)
}

Richtige Antwort

Ich habe eine Antwort zusammengestellt, die Ihnen bei der Lösung Ihres Problems helfen kann. Der gesamte Code gehört zu main.go 文件，只是为了演示。它有两个主要部分：handler 和 main Funktionen. Beginnen wir mit dem Handler.

http-Handler

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)
}

Hier verlasse ich mich einfach auf das, was Sie verwenden (nur Standardbibliothek: http、io和fmt Paket). Wir müssen lediglich die eingehende Nutzlast, die von der http-Anfrage gelesen wurde, in den Antwortstream schreiben.

Hauptfunktionen

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()
}

Im Gegensatz dazu müssen mainFunktionen mit mehr Logik umgehen. Schauen wir sie uns in der Liste an:

1. Es erstellt einen http-Server zur Bearbeitung eingehender Anfragen. Wir instrumentieren es für Anfragen mithilfe des handlefile 处理程序来回复针对 /example-Endpunkts, den wir zuvor erstellt haben.
2. Wir verwenden sync.waitgroup, um den Server in einer separaten Goroutine auszuführen. Dadurch ist der Server betriebsbereit, wir können jedoch unser Programm fortsetzen und darin http-Anfragen senden.
3. Wir bereiten eine http-Anfrage mit den aus dem lokalen Dateisystem gelesenen Dateiinhalten vor (in unserem Fall die file.txt）。我们将 content-type 标头设置为 application/octet-stream 并将文件句柄传递给 newrequest-Funktion.
4. Wir stellen eine Anfrage und drucken den Inhalt der HTTP-Antwortnutzlast aus.
5. Wir fahren den Server herunter und verwenden die wg.wait-Methode, um die Wartegruppe anzuweisen, auf alle Goroutinen zu warten.

Abschließende Überlegungen

Der hier geschriebene Code kann definitiv verbessert werden. Wie auch immer, nur zur Veranschaulichung, ich halte es lieber so nah wie möglich an der Originaldatei, um Ihnen ein besseres Verständnis dafür zu vermitteln, wie man Binärdateien auf einem http-Server veröffentlicht und wie man dasselbe Programm sowohl auf dem Client als auch auf dem Server ausführt. Wenn etwas unklar ist, sagen Sie es mir bitte, danke!

Das obige ist der detaillierte Inhalt vonBinärdaten posten (Anwendung/Oktett-Stream). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!