Go
HTTP-Client
Suche…
Syntax
- resp. err: = http.Get (url) // Erstellt eine HTTP-GET-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.
- resp. err: = http.Post (URL, bodyType, body) // Erstellt eine HTTP-POST-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.
- resp. err: = http.PostForm (URL, Werte) // Erstellt eine HTTP-Formular-POST-Anforderung mit dem Standard-HTTP-Client. Wenn die Anforderung fehlschlägt, wird ein Nicht-Null-Fehler zurückgegeben.
Parameter
Parameter | Einzelheiten |
---|---|
bzw | Eine Antwort vom Typ *http.Response auf eine HTTP-Anfrage |
Irr | Ein error Wenn nicht gleich null, stellt dies einen Fehler dar, der beim Aufruf der Funktion aufgetreten ist. |
URL | Eine URL vom Typ string an die eine HTTP-Anforderung gesendet werden soll. |
Körpertyp | Der MIME-Typ der string der Body-Payload einer POST-Anforderung. |
Karosserie | Ein io.Reader (implementiert Read() ), aus dem gelesen wird, bis ein Fehler erreicht ist, der als Body-Payload einer POST-Anforderung übermittelt wird. |
Werte | Eine Schlüsselwertzuordnung des Typs url.Values . Der zugrunde liegende Typ ist eine map[string][]string . |
Bemerkungen
Es ist wichtig, defer resp.Body.Close()
nach jeder HTTP-Anforderung zu defer resp.Body.Close()
, die keinen Nicht-Null-Fehler defer resp.Body.Close()
Ressourcen verloren.
Basic GET
Führen Sie eine grundlegende GET-Anforderung aus und drucken Sie den Inhalt einer Site (HTML).
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
resp, err := http.Get("https://example.com/")
if err != nil {
panic(err)
}
// It is important to defer resp.Body.Close(), else resource leaks will occur.
defer resp.Body.Close()
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
panic(err)
}
// Will print site contents (HTML) to output
fmt.Println(string(data))
}
GET mit URL-Parametern und einer JSON-Antwort
Eine Anforderung für die Top 10 der zuletzt aktiven StackOverflow-Posts unter Verwendung der Stack Exchange-API.
package main
import (
"encoding/json"
"fmt"
"net/http"
"net/url"
)
const apiURL = "https://api.stackexchange.com/2.2/posts?"
// Structs for JSON decoding
type postItem struct {
Score int `json:"score"`
Link string `json:"link"`
}
type postsType struct {
Items []postItem `json:"items"`
}
func main() {
// Set URL parameters on declaration
values := url.Values{
"order": []string{"desc"},
"sort": []string{"activity"},
"site": []string{"stackoverflow"},
}
// URL parameters can also be programmatically set
values.Set("page", "1")
values.Set("pagesize", "10")
resp, err := http.Get(apiURL + values.Encode())
if err != nil {
panic(err)
}
defer resp.Body.Close()
// To compare status codes, you should always use the status constants
// provided by the http package.
if resp.StatusCode != http.StatusOK {
panic("Request was not OK: " + resp.Status)
}
// Example of JSON decoding on a reader.
dec := json.NewDecoder(resp.Body)
var p postsType
err = dec.Decode(&p)
if err != nil {
panic(err)
}
fmt.Println("Top 10 most recently active StackOverflow posts:")
fmt.Println("Score", "Link")
for _, post := range p.Items {
fmt.Println(post.Score, post.Link)
}
}
Timeout-Anforderung mit Kontext
1,7+
Das Zeitlimit für eine HTTP-Anforderung mit einem Kontext kann nur mit der Standardbibliothek (nicht mit den untergeordneten Ordnern) in 1.7+ ausgeführt werden:
import (
"context"
"net/http"
"time"
)
req, err := http.NewRequest("GET", `https://example.net`, nil)
ctx, _ := context.WithTimeout(context.TODO(), 200 * time.Milliseconds)
resp, err := http.DefaultClient.Do(req.WithContext(ctx))
// Be sure to handle errors.
defer resp.Body.Close()
Vor 1.7
import (
"net/http"
"time"
"golang.org/x/net/context"
"golang.org/x/net/context/ctxhttp"
)
ctx, err := context.WithTimeout(context.TODO(), 200 * time.Milliseconds)
resp, err := ctxhttp.Get(ctx, http.DefaultClient, "https://www.example.net")
// Be sure to handle errors.
defer resp.Body.Close()
Lesen Sie weiter
Weitere Informationen zum context
Sie unter Kontext .
PUT-Anforderung eines JSON-Objekts
Folgendes aktualisiert ein Benutzerobjekt über eine PUT-Anforderung und gibt den Statuscode der Anforderung aus:
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)
type User struct {
Name string
Email string
}
func main() {
user := User{
Name: "John Doe",
Email: "[email protected]",
}
// initialize http client
client := &http.Client{}
// marshal User to json
json, err := json.Marshal(user)
if err != nil {
panic(err)
}
// set the HTTP method, url, and request body
req, err := http.NewRequest(http.MethodPut, "http://api.example.com/v1/user", bytes.NewBuffer(json))
if err != nil {
panic(err)
}
// set the request header Content-Type for json
req.Header.Set("Content-Type", "application/json; charset=utf-8")
resp, err := client.Do(req)
if err != nil {
panic(err)
}
fmt.Println(resp.StatusCode)
}
Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow