So stellen Sie HTTP-Anforderungen in Go

Eines der Grundprinzipien, die das Funktionieren des World Wide Web bestimmen, ist der Austausch von Anfragen und Antworten. Wenn Sie eine Anfrage zum Zugriff auf eine Webseite senden, antwortet der Server mit entsprechenden Daten.

Zu den gängigen Protokollen, die verschiedene Arten der Internetkommunikation regeln, gehören: HTTP (Hypertext Transfer Protocol), FTP (File Transfer Protocol) und SMTP (Simple Mail Transfer Protocol).

HTTP ist das Protokoll, das Sie normalerweise verwenden, wenn Sie eine Website anzeigen oder eine webfähige App verwenden. Sie können auch mit HTTP-Anforderungen aus vielen Programmiersprachen arbeiten, einschließlich Go.

Was ist eine HTTP-Anfrage?

HTTP definiert, wie Clients wie Webbrowser Anfragen an Server senden, die dann eine Antwort zurückgeben. Eine HTTP-Anforderung enthält Informationen zu einer Ressource, auf die der Client zuzugreifen versucht. Die Anforderungsnachricht umfasst typischerweise eine URL, die die Ressource und andere optionale Daten wie Header und Abfrageparameter identifiziert.

Es gibt mehrere Arten von HTTP-Anforderungen, einschließlich GET, POST, PUT, DELETE, HEAD, OPTIONS und CONNECT. Die ersten vier Methodentypen sind die häufigsten; sie spiegeln die CRUD-Operationen read, create, update bzw. delete wider.

Der PUT-Anforderungstyp wird häufig synonym mit dem PATCH-Anforderungstyp verwendet. Sie erreichen denselben Zweck, sie unterscheiden sich lediglich in den Daten, die die Anfrage enthalten soll.

Senden von Anfragen mit gängigen HTTP-Methoden

Go ist integriert http Paket bietet eine Reihe von Funktionen und Strukturen, mit denen Sie Webserver erstellen und HTTP-Anforderungen verwalten können. Es ist ein sehr robustes Paket und alle Go-Web-Frameworks bauen auf die eine oder andere Weise darauf auf. Es ist ein Unterpaket von Go’s Netz Paket.

Um eine HTTP-Anfrage in Go zu erstellen, können Sie die verwenden http. Neue Anfrage() -Funktion und legen Sie die entsprechende Methode, URL, Header und den Anforderungstext fest. Nachdem Sie die Anfrage erstellt haben, können Sie Go net/http Pakete http. Klient{} Struktur, um es auszuführen und die Antwort zu erhalten.

Die folgenden Codebeispiele verwenden reqres.in, eine öffentlich verfügbare API zum Testen von HTTP-Anforderungen. Sie können damit GET-, POST-, PUT- und DELETE-Anforderungen in Ihren Go-Programmen testen.

POST-Anfrage

Der folgende Code ist eine Funktion, die eine POST-Anfrage an die sendet /api/users Endpunkt von reqres.in, um einen neuen Benutzer mit einem Namen und einem Job zu erstellen.

Paket hauptsächlich
importieren (
"Bytes"
"Codierung/json"
"fmt"
"io"
"net/http"
)
FunkBenutzer erstellen(Name, Beruf Schnur) {
 fmt. Println("Benutzer erstellen...")
 apiUrl := " https://reqres.in/api/users"
 Benutzerdaten := []Byte(`{"name":"` + Namen + `","job":"` + Beruf + `"}`)
// neue HTTP-Anfrage erstellen
 Anfrage, Fehler := http. Neue Anfrage("POST", apiUrl, Bytes. NewBuffer (Benutzerdaten))
 Anfrage. Header. Satz("Inhaltstyp", "application/json; Zeichensatz=utf-8")
// Anfrage senden
 Kunde := &http. Klient{}
 Antwort, Fehler := Client. Tun (bitten)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 AntwortBody, Fehler := io. ReadAll (Antwort. Körper)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Zustand:", Antwort. Status)
 fmt. Println("Antworttext: ", formatierte Daten)
// Speicher nach der Ausführung bereinigen
verschieben Antwort. Körper. Schließen()
}

FormatJSON ist eine benutzerdefinierte Funktion, die Sie schreiben können, um die Ausgabedaten zu formatieren. So können Sie es implementieren:

// Funktion zum Formatieren von JSON-Daten
FunkFormatJSON(Daten []Byte)Schnur {
Var Byte aus. Puffer
 Fehler := json. Einrücken(&aus, Daten, "", " ")
Wenn äh != Null {
 fmt. Println (err)
 }
 d := aus. Bytes()
zurückkehrenSchnur(D)
}

Sie können die anrufen createUser() Funktion in einem Programm wie diesem:

Funkhauptsächlich() {
 fmt. Println("POST-Anforderung wird erstellt...")
 createUser("Tim Omolana", "Schriftsteller")
}

Wenn Sie das Programm in einem Terminal ausführen, verwenden Sie die geh Rennen Befehl, sehen Sie eine Ausgabe wie diese:

GET-Anfrage

Der folgende Code ist eine Funktion, die eine GET-Anforderung sendet, um einen Benutzer mithilfe seiner eindeutigen ID vom reqres.in-Server abzurufen.

// main.go
FunkgetUser(Ausweis Schnur) {
 fmt. Println("Benutzer nach ID abrufen...")
// GET-Anfrage an die API stellen, um Benutzer nach ID abzurufen
 apiUrl := " https://reqres.in/api/users/" + ID
 Anfrage, Fehler := http. Neue Anfrage("ERHALTEN", apiUrl, Null)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 Anfrage. Header. Satz("Inhaltstyp", "application/json; Zeichensatz=utf-8")
 Kunde := &http. Klient{}
 Antwort, Fehler := Client. Tun (bitten)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 AntwortBody, Fehler := io. ReadAll (Antwort. Körper)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Zustand:", Antwort. Status)
 fmt. Println("Antworttext: ", formatierte Daten)
// Speicher nach der Ausführung bereinigen
verschieben Antwort. Körper. Schließen()
}

Eine GET-Anforderung sendet keine Daten an den Server, daher akzeptiert oder sendet sie keinen Anforderungstext an den Server, wenn sie gestellt wird. So sieht ein Beispielaufruf der obigen Funktion aus:

Funkhauptsächlich() {
 fmt. Println("GET-Anforderung wird erstellt...")
 getUser("2")
}

Ausgang:

PUT-Anfrage

Die PUT-Anforderung ist einer POST-Anforderung sehr ähnlich, da sie auch Daten an den Server sendet. Der Hauptunterschied besteht darin, dass POST eine neue Ressource erstellt, während PUT eine vorhandene aktualisiert.

Hier ist eine Implementierung einer PUT-Anfrage:

// main.go
FunkBenutzer aktualisieren(Name, Beruf, ID Schnur) {
 fmt. Println("Aktualisiere Benutzer...")
// PUT-Anforderung an die API senden, um den Benutzer zu aktualisieren
 apiUrl := " https://reqres.in/api/users/" + ID
 Benutzerdaten := []Byte(`{"name":"` + Namen + `","job":"` + Beruf + `"}`)
// neue HTTP-PUT-Anforderung erstellen
 Anfrage, Fehler := http. Neue Anfrage("SETZEN", apiUrl, Bytes. NewBuffer (Benutzerdaten))
 Anfrage. Header. Satz("Inhaltstyp", "application/json; Zeichensatz=utf-8")
// Verbleibender Funktionsrumpf der createUser-Funktion...
// Anfrage stellen, Antwort erhalten und Speicher löschen...
}

Aus diesem Code können Sie sehen, dass die einzigen Unterschiede zwischen der PUT-Anforderung und der POST-Anforderung oben der Methodenname und die URL sind. Wenn Sie einen PUT verwenden, um vorhandene Daten zu aktualisieren, müssen Sie die ID an die Anforderungs-URL anhängen. Ein Beispielaufruf dieser Funktion würde wie folgt aussehen:

func main() {
// Eintrag mit der ID 2 aktualisieren.
 updateUser("Tim Neuer Name", "Angestellter Autor", "2")
}

Der obige Code aktualisiert den Benutzer und erzeugt die folgende Ausgabe:

Anfrage LÖSCHEN

Verwenden Sie die Anforderungsmethode DELETE, um einen Löschvorgang auf einem Webserver auszuführen. Eine Löschanforderung löscht die durch den URI identifizierte Ressource. Eine DELETE-Anfrage in Go sieht so aus:

FunkBenutzer löschen(Ausweis Schnur) {
 fmt. Println("Benutzer löschen...")
// DELETE-Anfrage an API stellen, um Benutzer zu löschen
 apiUrl := " https://reqres.in/api/users/" + ID
// neue HTTP-Anfrage erstellen
 Anfrage, Fehler := http. Neue Anfrage("LÖSCHEN", apiUrl, Null)
 Anfrage. Header. Satz("Inhaltstyp", "application/json; Zeichensatz=utf-8")
 Kunde := &http. Klient{}
 Antwort, Fehler := Client. Tun (bitten)
Wenn Fehler != Null {
 fmt. Println (Fehler)
 }
 fmt. Println("Zustand:", Antwort. Status)
}

Eine DELETE-Anforderung akzeptiert weder einen Text noch gibt er einen Text zurück, daher besteht keine Notwendigkeit, den JSON-Anforderungs- und -Antworttext zu analysieren oder zu formatieren. Die Antwort gibt nur einen Status zurück, um Erfolg oder Misserfolg anzuzeigen. So sieht ein Beispielaufruf der Funktion mit ihrer Ausgabe aus:

Funkhauptsächlich() {
 fmt. Println("DELETE-Anfrage wird gestellt...")
 Benutzer löschen("2")
}

Ausgang:

Sparen Sie Zeit mit der http. Post() Und http. Erhalten() Methoden aus der net/http Paket zu machen POST Und ERHALTEN Anfragen direkt, ohne die verwenden zu müssen Neue Anfrage() Funktion und die Klient{} Struktur zu erstellen und die Anfrage separat zu stellen. Besuche die net/http-Dokumentation für mehr Informationen.

Erstellen von HTTP-Anforderungen in Go-Anwendungen

Der http -Paket in Go bietet alles, was zum Erstellen von HTTP-Anforderungen und zum Verarbeiten von Antworten in Go-Anwendungen erforderlich ist. Die vom Paket bereitgestellten Funktionen und Strukturen ermöglichen es Ihnen, verschiedene Arten von Anfragen wie GET, POST, PUT, DELETE und viele mehr zu erstellen und zu senden.

Dies erleichtert das Erstellen von Webanwendungen in Go, die mit anderen Webdiensten und APIs interagieren können. Ein guter Weg zu bekommen Besser vertraut mit dem Erstellen von HTTP-Anforderungen in Go ist das Erstellen einer Anwendung, die Anforderungen an eine andere REST-API stellt dein.