Jak vytvářet požadavky HTTP v Go

Jedním ze základních principů, kterými se řídí fungování World Wide Web, je výměna požadavků a odpovědí. Když odešlete požadavek na přístup na webovou stránku, server odpoví příslušnými daty.

Mezi oblíbené protokoly, které řídí různé typy internetové komunikace, patří HTTP (Hypertext Transfer Protocol), FTP (Protokol přenosu souborů) a SMTP (Simple Mail Transfer Protocol).

HTTP je protokol, který obvykle používáte, když si prohlížíte web nebo používáte webovou aplikaci. Můžete také pracovat s požadavky HTTP z mnoha programovacích jazyků, včetně Go.

Co je požadavek HTTP?

HTTP definuje, jak klienti, jako jsou webové prohlížeče, odesílají požadavky na servery, které pak vracejí odpověď. Požadavek HTTP obsahuje informace o zdroji, ke kterému se klient pokouší získat přístup. Zpráva požadavku typicky obsahuje URL, která identifikuje zdroj a další volitelná data, jako jsou záhlaví a parametry dotazu.

Existují několik typů HTTP požadavků, včetně GET, POST, PUT, DELETE, HEAD, OPTIONS a CONNECT. První čtyři typy metod jsou nejběžnější; zrcadlí operace CRUD pro čtení, vytváření, aktualizaci a odstraňování.

Typ požadavku PUT se často používá zaměnitelně s typem požadavku PATCH. Dosahují stejného účelu, jen se liší v údajích, které očekávají, že požadavek bude obsahovat.

Odesílání požadavků pomocí běžných metod HTTP

Go je vestavěný http balík poskytuje sadu funkcí a struktur, které můžete použít k vytváření webových serverů a správě požadavků HTTP. Je to velmi robustní balíček a všechny webové rámce Go na něm tak či onak staví. Jedná se o dílčí balíček Go's síť balík.

Chcete-li vytvořit požadavek HTTP v Go, můžete použít http. NewRequest() a nastavte příslušnou metodu, URL, záhlaví a tělo požadavku. Po vytvoření požadavku můžete použít Go net/http balíčky http. klient{} strukturu pro jeho spuštění a přijetí odpovědi.

Následující ukázky kódu používají reqres.in, veřejně dostupné API pro testování HTTP požadavků. Můžete jej použít k testování požadavků GET, POST, PUT a DELETE ve vašich programech Go.

Žádost o POST

Níže uvedený kód je funkce, která odesílá požadavek POST na /api/users koncový bod reqres.in k vytvoření nového uživatele se jménem a úlohou.

balík hlavní
import (
"bajty"
"kódování/json"
"fmt"
"io"
"net/http"
)
funcvytvořit uživatele(jméno, zaměstnání tětiva) {
 fmt. Println("Vytváření uživatele...")
 apiUrl := " https://reqres.in/api/users"
 uživatelská data := []byte(`{"jméno":"` + jméno + `","zaměstnání":"` + práce + `"}`)
// vytvořit nový http požadavek
 požadavek, chyba := http. Nová žádost("POŠTA", apiUrl, bajtů. NewBuffer (userData))
 žádost. Záhlaví. Soubor("Typ obsahu", "aplikace/json; charset=utf-8")
// odešlete žádost
 klient := &http. klient{}
 odpověď, chyba := klient. udělat (žádost)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 responseBody, error := io. ReadAll (odpověď. Tělo)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Stav: ", Odezva. Postavení)
 fmt. Println("Tělo odpovědi: ", formattedData)
// vyčištění paměti po spuštění
odložit Odezva. Tělo. Zavřít()
}

formát JSON je vlastní funkce, kterou můžete zapisovat pro formátování výstupních dat. Zde je návod, jak jej implementovat:

// funkce pro formátování dat JSON
funcformát JSON(údaje []byte)tětiva {
var ven bajtů. Buffer
 chyba := json. Odsadit(&out, data, "", " ")
-li chyba!= nula {
 fmt. Println (chyba)
 }
 d := ven. Bajty()
vrátit setětiva(d)
}

Můžete zavolat na vytvořit uživatele() fungovat v programu jako je tento:

funchlavní() {
 fmt. Println("Vytvářím požadavek POST...")
 vytvořit uživatele("Tim Omolana", "Spisovatel")
}

Když spustíte program v terminálu, pomocí běž příkaz, uvidíte výstup takto:

Žádost GET

Následující kód je funkce, která odesílá požadavek GET k načtení uživatele ze serveru reqres.in pomocí jeho jedinečného ID.

// main.go
funcgetUser(id tětiva) {
 fmt. Println("Získání uživatele podle ID...")
// vytvoří požadavek GET na API, aby získal uživatele podle ID
 apiUrl := " https://reqres.in/api/users/" + id
 požadavek, chyba := http. Nová žádost("DOSTAT", apiUrl, nula)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 žádost. Záhlaví. Soubor("Typ obsahu", "aplikace/json; charset=utf-8")
 klient := &http. klient{}
 odpověď, chyba := klient. udělat (žádost)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 responseBody, error := io. ReadAll (odpověď. Tělo)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Stav: ", Odezva. Postavení)
 fmt. Println("Tělo odpovědi: ", formattedData)
// vyčištění paměti po spuštění
odložit Odezva. Tělo. Zavřít()
}

Požadavek GET neodesílá data na server, takže po provedení nepřijímá ani neodesílá tělo požadavku na server. Takto bude vypadat příklad volání funkce výše:

funchlavní() {
 fmt. Println("Vytvářím požadavek GET...")
 getUser("2")
}

Výstup:

Požadavek PUT

Požadavek PUT je velmi podobný požadavku POST, protože také odesílá data na server. Hlavním rozdílem je, že POST vytváří nový zdroj, zatímco PUT aktualizuje existující.

Zde je implementace požadavku PUT:

// main.go
funcaktualizovat uživatele(jméno, zaměstnání, IČ tětiva) {
 fmt. Println("Aktualizace uživatele...")
// vytvoří požadavek PUT na API pro aktualizaci uživatele
 apiUrl := " https://reqres.in/api/users/" + id
 uživatelská data := []byte(`{"jméno":"` + jméno + `","zaměstnání":"` + práce + `"}`)
// vytvořit nový http požadavek PUT
 požadavek, chyba := http. Nová žádost("DÁT", apiUrl, bajtů. NewBuffer (userData))
 žádost. Záhlaví. Soubor("Typ obsahu", "aplikace/json; charset=utf-8")
// Zbývající tělo funkce z funkce createUser...
// Vytvořit požadavek, získat odpověď a vymazat paměť...
}

Z tohoto kódu můžete vidět jediné rozdíly mezi požadavkem PUT a požadavkem POST výše jsou název metody a adresa URL. Když používáte PUT k aktualizaci stávajících dat, budete muset k URL požadavku připojit ID. Ukázkové volání této funkce by vypadalo takto:

func main() {
// aktualizujte záznam s ID 2.
 updateUser("Tim Newname", "Zaměstnanecký spisovatel", "2")
}

Výše uvedený kód aktualizuje uživatele a vytváří následující výstup:

Požadavek VYMAZAT

K provedení operace odstranění na webovém serveru použijte metodu požadavku DELETE. Požadavek na odstranění odstraní zdroj identifikovaný pomocí URI. Požadavek DELETE v Go vypadá takto:

funcdeleteUser(id tětiva) {
 fmt. Println("Mazání uživatele...")
// vytvoří požadavek DELETE na API pro odstranění uživatele
 apiUrl := " https://reqres.in/api/users/" + id
// vytvořit nový http požadavek
 požadavek, chyba := http. Nová žádost("VYMAZAT", apiUrl, nula)
 žádost. Záhlaví. Soubor("Typ obsahu", "aplikace/json; charset=utf-8")
 klient := &http. klient{}
 odpověď, chyba := klient. udělat (žádost)
-li chyba!= nula {
 fmt. Println (chyba)
 }
 fmt. Println("Stav: ", Odezva. Postavení)
}

Požadavek DELETE nepřijímá ani nevrací tělo, proto není potřeba analyzovat nebo formátovat požadavek a tělo odpovědi JSON. Odpověď pouze vrátí stav označující úspěch nebo neúspěch. Takto vypadá ukázkové volání funkce s jejím výstupem:

funchlavní() {
 fmt. Println("Vytváří se požadavek DELETE...")
 deleteUser("2")
}

Výstup:

Ušetřete čas pomocí http. Pošta() a http. Dostat() metody z net/http balíček vyrobit POŠTA a DOSTAT požadavky přímo, bez nutnosti použití NewRequest() funkce a klient{} vytvořit a zadat požadavek samostatně. Podívejte se na net/http dokumentaci Pro více informací.

Vytváření požadavků HTTP v aplikacích Go

The http balíček v Go poskytuje vše potřebné k vytváření požadavků HTTP a zpracování odpovědí v aplikacích Go. Funkce a struktury poskytované balíčkem vám umožňují vytvářet a odesílat různé druhy požadavků, jako je GET, POST, PUT, DELETE a mnoho dalších.

To usnadňuje vytváření webových aplikací v Go, které mohou spolupracovat s jinými webovými službami a rozhraními API. Dobrý způsob, jak se dostat známější s vytvářením požadavků HTTP v Go je vytvoření aplikace, která odesílá požadavky na jiné REST API vaše.