Golang HTTP -Anfrage

Eine HTTP -Anforderung bezieht sich auf eine Aktion, die von einem HTTP -Client in einer bestimmten HTTP (Protocol) -Ressource (Protokoll) ausgeführt wird. Die Ressource wird hauptsächlich von einer URL als Domänenname oder einer IP -Adresse identifiziert.

HTTP -Anfragen sind einer der meisten Bausteine ​​des modernen Webs. Mithilfe der HTTP -Anforderung können wir Ressourcen wie Webseiten, Videos, Bilder und andere Dateien von einem Remote -Server anfordern.

In diesem Artikel lernen wir, wie Sie einen grundlegenden HTTP -Client mithilfe der Go -Programmiersprache erstellen können.

Anforderungen

In diesem Artikel benötigen Sie die folgenden Ressourcen:

1. Der auf Ihrem System installierte Go -Compiler.
2. Grundlegendes GO -Wissen.
3. Ein Texteditor.

Http bekommen

Die erste Methode, die wir implementieren werden, ist die HTTP -GET -Methode. Mit einer GET -Methode können wir Daten aus einer bestimmten Ressource anfordern. Zum Beispiel, wenn wir Artikel von der LinuxHint abholen müssen.com Server verwenden wir eine GET -Methode.

Der erste Schritt besteht darin, sicherzustellen, dass Sie Ihr Projekt einrichten. Wenn Sie nicht mit dem Erstellen und Arbeiten mit einem GO -Projekt vertraut sind, lesen Sie unser Tutorial zum Installieren von Go.

Öffnen Sie nach dem Erstellen des Projekts Ihre Hauptdatei und importieren Sie das NET/HTTP -Paket aus der GO -Standardbibliothek.

Das NET/HTTP -Paket bietet uns die Funktionalität und Dienstprogramme, um die HTTP -Anforderung an Remote -Server zu stellen.

Importieren Sie das NET/HTTP -Paket, indem Sie die folgende Zeile in Ihrer GO -Datei hinzufügen.

importieren (
"net/http"
)

Im Net/HTTP. Die Funktionssyntax ist wie unten gezeigt:

Func get (URL -Zeichenfolge) (resp *Antwort, Fehler Fehler)

Die Funktion nimmt eine URL als Argument an und gibt die Antwort als Zeiger auf die Struktur und einen Fehler zurück (falls vorhanden).

Wenn die Methode keinen Fehler auftritt, enthält die zurückgegebene Antwort die Antwortkörper aus der angeforderten Ressource.

Um die GET -Methode zu verwenden, können wir Code wie gezeigt erstellen:

resp, err: = http.Get ("https: // api.SpaceXData.com/v4/startet/letztendlich ")
Wenn er irrt != nil
Protokoll.Tödlich (arr)

Im obigen Beispiel nennen wir die GET -Methode und übergeben die URL an die Ressource, auf die wir als Zeichenfolge zugreifen möchten.

In unserem Beispiel verwenden wir die SpaceX -API.

Wie Sie bemerken werden, gibt die Funktion zwei Werte zurück, die wir in zwei Variablen speichern: resp und erre, die die zurückgegebene Antwort bzw. den Fehler halten.

Denken Sie daran, dass der Resp nichts als einen Zeiger auf die Struktur enthält, die die tatsächlichen Daten hält. Wenn wir also versuchen, es auszudrucken, erhalten wir ein paar durcheinandergebrachte Daten.

Eine Beispielausgabe aus der obigen Anforderung ist wie unten gezeigt:

Damit wir die tatsächlichen Daten anzeigen können, müssen wir auf die zurückgegebene Struktur auf die Körpereigenschaft zugreifen. Wir müssen es dann lesen und in die Konsole ausdrucken oder in einer Datei speichern.

Dafür können wir die Ioutil verwenden.Readme -Methode. Diese Methode ist im Ioutil -Paket definiert. Es gibt den Reaktionskörper und einen Fehler zurück.

HINWEIS: Nach dem Lesen des Reaktionskörper.

Wir können dies tun, indem wir die schließende Methode festlegen, um nach der Hauptfunktion abzunehmen. Das Defer-Schlüsselwort in Go kommt in Hand in Hand.

Der Bdr.Körper.Mit Close () können wir den Reaktionskörper nach dem Lesen schließen. Sobald wir das Antwortkörper gelesen haben, können wir sie in der Konsole ausdrucken, wie im folgenden Code implementiert:

Schauen Sie sich unser Tutorial über Golang Defer an, um mehr zu erfahren

Paket Main
importieren (
"fmt"
"io/ioutil"
"Protokoll"
"net/http"
)
func main ()
resp, err: = http.Get ("https: // api.SpaceXData.com/v4/startet/letztendlich ")
Wenn er irrt != nil
Protokoll.Tödlich (arr)

// Körper schließen
aufschieben resp.Körper.Schließen()
// Körper lesen
Körper, ähm: = ioutil.Readeall (resp.Körper)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

Der obige Code implementiert einen HTTP -Client in Go, der in der Lage ist, eine HTTP -Anforderung an die angegebene Methode zu stellen.

Ein Beispiel für den Rückgabewert ist wie gezeigt:

Für eine bessere Lesbarkeit können Sie die Antwort in das Lesbar-JSON-Format formatieren oder Marschall und Unmarshal ausführen, um die gewünschte Ausgabe auszuwählen.

Sehen Sie sich unser Tutorial über JSON Marschall und Unmarshal an, um mehr zu erfahren.

Http Post

Der nächste Teil eines HTTP -Clients besteht darin, die Postmethode zu erstellen. Mit einer HTTP -Methode können Sie Daten an den Server senden und eine Aktion auf der angegebenen Ressource ausführen. Dies kann eine Ressource erstellen, löschen oder aktualisieren.

In Go können wir nach dem NET/HTTP -Paket eine Postanforderung stellen. Es bietet uns die Post -Methode und ermöglicht es uns, Daten an einen Server zu senden.

Die Funktionssyntax ist wie unten gezeigt:

Func Post (URL, ContentType String, Body IO.Leser) (resp *Antwort, Fehler Fehler)

Die Funktion enthält drei Argumente:

1. Die Adresse der Ressource.
2. Der Inhaltstyp des Körpers zum Senden an den Server, eine Zeichenfolge,
3. Der Antragsbestand vom Typ IO.Leser

Die Funktion sollte dann die Antwort und einen Fehler zurückgeben. Denken Sie daran, dass wir die Daten umwandeln müssen, um an den Server in ein akzeptables Format zu senden. Wir können dies tun, indem wir die JSON -Daten in IO konvertieren.Leser, der im Grunde eine Schnittstelle in Go ist.

Überprüfen Sie den Quellcode, um mehr zu erfahren.

Konvertieren von JSON -Daten in IO.Der Lesertyp umfasst zwei Schritte:

Das erste besteht darin, die JSON -Daten in das Byte -Format zu codieren. Wir können dies von JSON Marshaling tun, wie in unserem Tutorial erläutert.

Sobald wir codiert sind, können wir die Daten in Typen umwandeln, wie von IO implementiert.Leserschnittstelle mit der Newbuffer -Methode. Diese Methode gibt die IO zurück.Lesertyp, den wir dann an die Post -Methode übergeben können.

Ein Beispielcode -Block ist wie unten gezeigt:

Körper, _: = json.Marschall (Karte [String] String
"ID": "1",
"Site": "LinuxHint"
)
coded_json: = bytes.Neuling (Körper)

Sobald wir alle Teile in Ordnung haben, können wir die Postmethode in die angegebene Ressource aufrufen. Denken Sie daran, dass dieses Tutorial Dummy -Daten und -Links verwendet.

Paket Main
importieren (
"Bytes"
"Codierung/JSON"
"fmt"
"io/ioutil"
"Protokoll"
"net/http"
)
func main ()
Körper, _: = json.Marschall (Karte [String] String
"ID": "1",
"Site": "LinuxHint"
)
resp, err: = http.Post ("http: // Beispiel.com/v4/endpoint/post "," application/json ", Körper)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

aufschieben resp.Körper.Schließen()
return_body, err: = ioutil.Readeall (resp.Körper)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

fmt.Println (String (Körper))

Die obige Methode implementiert einen einfachen HTTP -Client, mit dem HTTP -Postmethoden eine bestimmte Ressource herstellen können.

Abschluss

Dieser Artikel zeigt, wie Sie einen grundlegenden HTTP -Client mit der Go -Programmiersprache erstellen können. Go ist außergewöhnlich schnell, wenn es um die HTTP -Portion geht. Mit dem Wissen in diesem Artikel können Sie den Kunden auf eine vollwertige Anwendung erweitern.

Codieren weiter.