Golang sendet Anfrage

Go ist eine Open-Source-Programmiersprache, die sich sehr gut zum Schreiben effizienter, zuverlässiger und gleichzeitiger Netzwerkanwendungen eignet. Aufgrund seiner hervorragenden Leistung und einfachen Schreibbarkeit ist Go für viele Anwendungen zur Programmiersprache der Wahl geworden. In diesem Artikel erfahren Sie, wie Sie HTTP-Anfragen mit Go senden.

1. Führen Sie zunächst das Net/http-Paket ein

Der erste Schritt zum Senden von HTTP-Anfragen in Go ist die Einführung des Net/http-Pakets. Es bietet viele Funktionen, einschließlich der Erstellung von HTTP-Clients und -Servern usw.

import „net/http“

2. HTTP-Client erstellen

Um einen HTTP-Client zu erstellen, müssen wir die http.Client-Struktur verwenden. Kann erstellt werden mit:

client := &http.Client{}

Es gibt auch viele Optionen zum Ändern im Client. Sie können beispielsweise Zeitüberschreitungen festlegen, Proxyserver verwenden usw. Hier ist ein Beispiel mit Timeouts und einem Proxyserver.

timeout := time.Duration(5 * time.Second)
transport := &http.Transport{

Proxy: http.ProxyURL(proxyUrl),

}
client := &http.Client{

Timeout:   timeout,
Transport: transport,

}

Bitte beachten Sie, dass der Proxyserver optional ist. Wenn Sie keinen Proxyserver verwenden müssen, können Sie direkt eine leere Proxy-URL verwenden:

proxyUrl, err := url.Parse("")

3. HTTP-GET-Anfrage senden

Jetzt haben wir die erstellt HTTP-Client, wir können mit dem Senden von Requests beginnen. Die einfachste Anfrage ist die HTTP-GET-Anfrage. Wir verwenden die Get-Funktion, um die GET-Anfrage zu senden.

resp, err := client.Get("https://www.example.com/path/to/resource")

func main() {

resp, err := http.Get("https://www.example.com/path/to/resource")
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

Wenn die Anfrage erfolgreich ist, wird der Server wird eine Antwort zurückgeben. Inhalte wie der Antwortstatuscode und der Antworttext können aus der Antwort gelesen werden. Hinweis: Die Methode resp.Body.Close() muss nach dem Lesen des Antworttexts aufgerufen werden, um die Ressourcen des Antworttexts freizugeben.

4. HTTP-POST-Anfrage senden

Zusätzlich zu GET-Anfragen können Sie auch HTTP-POST-Anfragen senden. POST-Anfragen werden normalerweise verwendet, um Daten an den Server zu senden. Wir können die Post-Funktion verwenden, um eine POST-Anfrage wie folgt zu erstellen:

values ​​​​:= map[string]string{"username": "Administrator", "password": "Password"}
jsonValue, _ := json . Marshal(values)
url := "http://example.com/login"
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonValue))
req.Header.Set( „ Content-Type“, „application/json“)

func main() {

values := map[string]string{"username": "管理员", "password": "密码"}
jsonValue, _ := json.Marshal(values)
resp, err := http.Post("http://example.com/login", "application/json", bytes.NewBuffer(jsonValue))
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

Im obigen Code erstellen wir eine POST-Anfrage mit der NewRequest-Funktion. Wir übergeben den Anforderungstext an die Funktion bytes.NewBuffer, wo der Text im JSON-Format codiert wird. Anschließend setzen wir den Content-Type-Header auf „application/json“, damit der Server weiß, dass der Hauptteil der Anfrage im JSON-Format vorliegt.

5. Andere Arten von HTTP-Anfragen senden

In Go können Sie andere Arten von HTTP-Anfragen senden, z. B. PUT, DELETE, PATCH, OPTIONS, HEAD usw. Um diese Anfragen zu senden, können wir die Funktion http.NewRequest verwenden. Hier ist ein Beispiel für das Senden einer JSON-Datei mithilfe einer PUT-Anfrage:

values ​​​​:= map[string]string{"name": "John Doe", "age": "29"}
jsonValue, _ := json.Marshal( Werte)
req, err := http.NewRequest("PUT", "http://example.com/users/123", bytes.NewBuffer(jsonValue))
req.Header.Set("Content -Type", "application/json")

func main() {

values := map[string]string{"name": "John Doe", "age": "29"}
jsonValue, _ := json.Marshal(values)
req, err := http.NewRequest("PUT", "http://example.com/users/123", bytes.NewBuffer(jsonValue))
if err != nil {
        // handle error
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
        // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
        // handle error
}
fmt.Println(string(body))

}

Um DELETE-, PATCH-, OPTIONS- und HEAD-Anfragen zu senden, ändern Sie einfach den ersten Parameter in der http.NewRequest-Funktion in die entsprechende HTTP-Methode . Um beispielsweise eine DELETE-Anfrage zu senden, ändern Sie den ersten Parameter in „DELETE“.

6. Fazit

In diesem Artikel haben wir behandelt, wie man HTTP-Anfragen mit Go sendet. Wir haben einen HTTP-Client erstellt und HTTP-GET- und POST-Anfragen an den Server gesendet. Wir haben auch erläutert, wie andere Arten von HTTP-Anfragen gesendet werden, z. B. PUT, DELETE, PATCH, OPTIONS, HEAD usw.

In der tatsächlichen Entwicklung ist es meist notwendig, mehr Optionen und Funktionen zu nutzen. Dies kann durch Festlegen verschiedener Eigenschaften der http.Client-Struktur erreicht werden. Mit diesen Methoden können Sie problemlos HTTP-Anfragen in Go senden und die Antworten verarbeiten. Egal, ob Sie eine Webanwendung, ein verteiltes System, einen Backend-Dienst oder eine andere Netzwerkanwendung erstellen, mit Go können Sie Ihre Arbeit ganz einfach erledigen.

Das obige ist der detaillierte Inhalt vonGolang sendet Anfrage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!