HTTP-Client in Go: Anfragen richtig stellen

Einleitung: Warum der HTTP-Client in Go Beachtung verdient

Moderne Webanwendungen arbeiten selten isoliert. Praktisch jeder Dienst interagiert über HTTP mit externen APIs, Microservices oder Drittanbieter-Ressourcen. Die Sprache Go (Golang) bietet eine integrierte leistungsstarke Bibliothek net/http, mit der Sie effiziente und leistungsfähige HTTP-Clients ohne externe Abhängigkeiten erstellen können.

In diesem Artikel werden wir uns ansehen, wie man mit dem HTTP-Client in Go richtig arbeitet: von einfachen GET-Anfragen bis zur Fehlerbehandlung und Verwaltung von Timeouts. Sie erfahren, wie Sie typische Fehler vermeiden und zuverlässigen Code schreiben.

Grundlagen der Arbeit mit dem HTTP-Client in Go

Die Bibliothek net/http in Go ist auf Leistung ausgelegt. Im Gegensatz zu vielen anderen Sprachen, bei denen jede Anfrage eine neue Verbindung erstellt, verwendet Go standardmäßig einen Verbindungspool (connection pool). Das bedeutet, dass TCP-Verbindungen wiederverwendet werden, was die Arbeit erheblich beschleunigt.

Einfachste GET-Anfrage

Beginnen wir mit dem einfachsten Beispiel – dem Senden einer GET-Anfrage mit der Funktion http.Get():

package main

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

func main() {    // Einfache GET-Anfrage    resp, err := http.Get("https://api.github.com")    if err != nil {        fmt.Printf("Fehler bei der Ausführung der Anfrage: %v", err)        os.Exit(1)    }    defer resp.Body.Close()

    // Antwortbody lesen    body, err := io.ReadAll(resp.Body)    if err != nil {        fmt.Printf("Fehler beim Lesen der Antwort: %v", err)        os.Exit(1)    }

    fmt.Printf("Status: %s", resp.Status)    fmt.Printf("Antwortbody: %s", string(body))}

Wichtig: Schließen Sie immer den Antwortbody (resp.Body.Close()). Verwenden Sie defer für das garantierte Schließen, auch wenn ein Fehler auftritt.

GET-Anfrage mit Parametern und Headern

Für komplexere Anfragen ist es besser, die vollständige Syntax mit der Erstellung eines http.Request-Objekts zu verwenden:

package main

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

func main() {    // Neuen Client erstellen    client := &http.Client{        Timeout: 10 * time.Second,    }

    // Anfrage erstellen    req, err := http.NewRequest("GET", "https://api.example.com/users", nil)    if err != nil {        fmt.Printf("Fehler beim Erstellen der Anfrage: %v", err)        return    }

    // Header hinzufügen    req.Header.Set("Authorization", "Bearer your-token-here")    req.Header.Set("Accept", "application/json")    req.Header.Set("User-Agent", "Go-http-client/1.0")

    // Query-Parameter hinzufügen    q := req.URL.Query()    q.Add("limit", "10")    q.Add("offset", "0")    req.URL.RawQuery = q.Encode()

    // Anfrage ausführen    resp, err := client.Do(req)    if err != nil {        fmt.Printf("Fehler bei der Ausführung der Anfrage: %v", err)        return    }    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)    fmt.Printf("Antwort: %s", string(body))}

Arbeit mit POST-Anfragen und JSON

POST-Anfragen mit JSON-Body sind eine Standardaufgabe bei der Arbeit mit REST APIs. Go bietet praktische Werkzeuge zur Serialisierung von Daten.

Senden von JSON mit POST

package main

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

type User struct {    Name  string `json:"name"`    Email string `json:"email"`    Age   int    `json:"age"`}

func main() {    user := User{        Name:  "Ivan Petrov",        Email: "ivan@example.com",        Age:   30,    }

    // Struktur in JSON serialisieren    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Printf("Fehler bei der JSON-Serialisierung: %v", err)        return    }

    client := &http.Client{Timeout: 5 * time.Second}