HTTP-Client in Go: Anfragen richtig stellen von A bis Z

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

HTTP-Client in Go: Anfragen richtig stellen von A bis Z

Go (Golang) ist eine Sprache, die für ihre Einfachheit und Leistungsfähigkeit bekannt ist, insbesondere im Bereich der Netzwerkprogrammierung. Das integrierte Paket net/http bietet einen leistungsstarken und flexiblen HTTP-Client, der sowohl für einfache Anfragen als auch für komplexe, hochbelastete Systeme geeignet ist. In diesem Artikel werden wir uns ansehen, wie man den HTTP-Client in Go richtig verwendet, angefangen bei grundlegenden Anfragen bis hin zu fortgeschrittenen Einstellungen.

1. Grundlagen: Erstellen und Ausführen einfacher Anfragen

Der einfachste Weg, eine HTTP-Anfrage in Go zu stellen, ist die Verwendung von Hilfsfunktionen aus dem Paket net/http, wie http.Get und http.Post. Für Produktionscode wird jedoch empfohlen, einen Client und eine Anfrage explizit zu erstellen.

Basis-GET-Anfrage:

package main

import (    "fmt"    "io/ioutil"    "net/http")

func main() {    // Erstellen eines neuen Clients    client := &http.Client{}

    // Erstellen einer Anfrage    req, err := http.NewRequest("GET", "https://api.example.com/data", nil)    if err != nil {        fmt.Println("Fehler beim Erstellen der Anfrage:", err)        return    }

    // Ausführen der Anfrage    resp, err := client.Do(req)    if err != nil {        fmt.Println("Fehler beim Ausführen der Anfrage:", err)        return    }    defer resp.Body.Close()

    // Lesen des Antwortkörpers    body, err := ioutil.ReadAll(resp.Body)    if err != nil {        fmt.Println("Fehler beim Lesen der Antwort:", err)        return    }

    fmt.Println("Status:", resp.Status)    fmt.Println("Körper:", string(body))}

POST-Anfrage mit JSON-Körper:

package main

import (    "bytes"    "encoding/json"    "fmt"    "net/http")

type Payload struct {    Name  string `json:"name"`    Email string `json:"email"`}

func main() {    payload := Payload{Name: "John", Email: "john@example.com"}    jsonData, _ := json.Marshal(payload)

    client := &http.Client{}    req, err := http.NewRequest("POST", "https://api.example.com/users", bytes.NewBuffer(jsonData))    if err != nil {        fmt.Println("Fehler:", err)        return    }

    // Setzen der Header    req.Header.Set("Content-Type", "application/json")    req.Header.Set("Authorization", "Bearer your-token")

    resp, err := client.Do(req)    if err != nil {        fmt.Println("Fehler:", err)        return    }    defer resp.Body.Close()

    fmt.Println("Status:", resp.Status)}

2. Verwaltung von Timeouts und Kontexten

Einer der häufigsten Fehler ist das Fehlen von Timeouts. Ohne diese kann Ihr Client unbegrenzt hängen bleiben, während er auf eine Antwort des Servers wartet. In Go gibt es zwei Hauptmethoden zur Verwaltung von Wartezeiten.

Timeout auf Client-Ebene:

client := &http.Client{    Timeout: 10 * time.Second, // Gesamt-Timeout für die gesamte Anfrage}

Timeout mit Kontext (empfohlen):

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)defer cancel()

req, err := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/data", nil)if err != nil {    log.Fatal(err)}

resp, err := client.Do(req)if err != nil {    // Prüfen, ob das Timeout abgelaufen ist    if errors.Is(err, context.DeadlineExceeded) {        fmt.Println("Anfrage hat das Timeout überschritten")    } else {        fmt.Println("Fehler:", err)    }    return}defer resp.Body.Close()

Die Verwendung von Kontexten bietet mehr Flexibilität: Sie können die Anfrage jederzeit abbrechen (z. B. beim Schließen der Anwendung) und Werte über den Kontext übergeben.