Kuidas teha Go-s HTTP-päringuid

Üks ülemaailmse veebi toimimise põhiprintsiipe on päringute ja vastuste vahetamine. Kui saadate veebilehele juurdepääsu taotluse, vastab server vastavate andmetega.

Populaarsed protokollid, mis reguleerivad erinevat tüüpi Interneti-suhtlust, hõlmavad HTTP (hüperteksti edastusprotokoll), FTP (Failiedastusprotokoll) ja SMTP (Simple Mail Transfer Protocol).

HTTP on protokoll, mida tavaliselt kasutate veebisaidi vaatamisel või veebitoega rakenduse kasutamisel. Samuti saate töötada paljude programmeerimiskeelte, sealhulgas Go HTTP-päringutega.

Mis on HTTP-päring?

HTTP määrab, kuidas kliendid, nagu veebibrauserid, saadavad päringuid serveritele, mis seejärel vastuse tagastavad. HTTP-päring sisaldab teavet ressursi kohta, millele klient üritab juurde pääseda. Päringusõnum sisaldab tavaliselt URL-i, mis identifitseerib ressursi, ja muid valikulisi andmeid, nagu päised ja päringuparameetrid.

Seal on mitut tüüpi HTTP-päringud, sealhulgas HANGI, POSTITUS, PANEMINE, KUSTUTAMINE, HEAD, OPTIONS ja CONNECT. Neli esimest meetodit on kõige levinumad; need peegeldavad vastavalt CRUD-i toiminguid, mida lugeda, luua, värskendada ja kustutada.

PUT-päringu tüüpi kasutatakse sageli vaheldumisi PATCH-päringu tüübiga. Nad saavutavad sama eesmärgi, erinevad lihtsalt andmete poolest, mida nad eeldavad, et taotlus sisaldab.

Päringute saatmine tavaliste HTTP-meetodite abil

Go on sisseehitatud http pakett pakub hulga funktsioone ja struktuure, mida saate kasutada veebiserverite loomiseks ja HTTP-päringute haldamiseks. See on väga tugev pakett ja kõik Go veebiraamistikud ehitatakse ühel või teisel viisil sellele peale. See on Go's alampakett net pakett.

HTTP-päringu loomiseks rakenduses Go saate kasutada http. NewRequest() funktsiooni ja määrake sobiv meetod, URL, päised ja päringu keha. Pärast päringu loomist saate kasutada nuppu Go net/http paketi omad http. Klient{} selle käivitamiseks ja vastuse saamiseks.

Kasutatakse järgmisi koodinäidiseid reqres.in, avalikult saadaval olev API HTTP-päringute testimiseks. Saate seda kasutada GET, POST, PUT ja DELETE taotluste testimiseks oma Go programmides.

POSTITUSE taotlus

Allolev kood on funktsioon, mis saadab POST-päringu aadressile /api/users reqres.in lõpp-punkti, et luua uus kasutaja nime ja tööga.

pakett peamine
importida (
"baidid"
"kodeering/json"
"fmt"
"io"
"net/http"
)
funcLoo kasutaja(nimi, töökoht string) {
 fmt. Println("Kasutaja loomine...")
 apiUrl := " https://reqres.in/api/users"
 kasutajaandmed := []bait(`{"nimi":"` + nimi + `","töö":"` + töö + `"}`)
// loo uus http-päring
 taotlus, viga := http. NewRequest("POSTITA", apiUrl, baidid. Uus puhver (kasutajaandmed))
 nõuda. Päis. Set("Sisu tüüp", "rakendus/json; charset=utf-8")
// saada päring
 klient := &http. Klient{}
 vastus, viga := klient. Tee (taotle)
kui viga != null {
 fmt. Println (viga)
 }
 responseBody, error := io. Loe kõike (vastus. keha)
kui viga != null {
 fmt. Println (viga)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Olek:", vastus. olek)
 fmt. Println("Vastuse keha:", vormindatudandmed)
// mälu puhastamine pärast täitmist
edasi lükata vastuseks. Keha. Sulge()
}

formaatJSON on kohandatud funktsioon, mille saate kirjutada väljundandmete vormindamiseks. Siin on, kuidas saate seda rakendada:

// funktsioon JSON-andmete vormindamiseks
funcformaatJSON(andmed []bait)string {
var välja baidid. Puhver
 eksitus := json. Taane(&välja, andmed, "", " ")
kui eks!= null {
 fmt. Println (viga)
 }
 d := välja. Baitid ()
tagasistring(d)
}

Võite helistada createUser() funktsioon sellises programmis:

funcpeamine() {
 fmt. Println("POST-i päringu tegemine...")
 createUser("Tim Omolana", "Kirjanik")
}

Kui käivitate programmi terminalis, kasutage mine jookse käsk, näete sellist väljundit:

HANGI taotlus

Järgmine kood on funktsioon, mis saadab GET-päringu kasutaja toomiseks serverist reqres.in, kasutades nende kordumatut ID-d.

// main.go
funcgetUser(id string) {
 fmt. Println("Kasutaja hankimine ID järgi...")
// tehke API-le GET-i taotlus, et saada kasutaja ID järgi
 apiUrl := " https://reqres.in/api/users/" + id
 taotlus, viga := http. NewRequest("HANGI", apiUrl, null)
kui viga != null {
 fmt. Println (viga)
 }
 nõuda. Päis. Set("Sisu tüüp", "rakendus/json; charset=utf-8")
 klient := &http. Klient{}
 vastus, viga := klient. Tee (taotle)
kui viga != null {
 fmt. Println (viga)
 }
 responseBody, error := io. Loe kõike (vastus. keha)
kui viga != null {
 fmt. Println (viga)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Olek:", vastus. olek)
 fmt. Println("Vastuse keha:", vormindatudandmed)
// mälu puhastamine pärast täitmist
edasi lükata vastuseks. Keha. Sulge()
}

GET-i päring ei saada serverisse andmeid, mistõttu see ei aktsepteeri ega saada serverisse päringu keha, kui see on tehtud. Ülaltoodud funktsiooni näidiskutse näeb välja järgmine:

funcpeamine() {
 fmt. Println("Hangimise taotluse esitamine...")
 getUser("2")
}

Väljund:

PUT taotlus

PUT-päring on väga sarnane POST-päringule, kuna see saadab andmeid ka serverisse. Peamine erinevus seisneb selles, et POST loob uue ressursi, samal ajal kui PUT värskendab olemasolevat.

Siin on PUT-päringu rakendamine:

// main.go
funcvärskenduskasutaja(nimi, töökoht, id string) {
 fmt. Println("Kasutaja värskendamine...")
// kasutaja värskendamiseks esitage API-le PUT-päring
 apiUrl := " https://reqres.in/api/users/" + id
 kasutajaandmed := []bait(`{"nimi":"` + nimi + `","töö":"` + töö + `"}`)
// looge uus http PUT-i päring
 taotlus, viga := http. NewRequest("PANE", apiUrl, baidid. Uus puhver (kasutajaandmed))
 nõuda. Päis. Set("Sisu tüüp", "rakendus/json; charset=utf-8")
// Funktsiooni createUser järelejäänud kehaosa...
// Esitage taotlus, hankige vastus ja tühjendage mälu...
}

Sellest koodist näete ainsad erinevused ülaltoodud PUT-päringu ja POST-päringu vahel meetodi nimes ja URL-is. Kui kasutate olemasolevate andmete värskendamiseks PUT-i, peate lisama päringu URL-ile ID. Selle funktsiooni näidiskutse näeb välja järgmine:

func main() {
// värskendage kirjet ID-ga 2.
 updateUser("Tim Newname", "Personali kirjanik", "2")
}

Ülaltoodud kood värskendab kasutajat ja annab järgmise väljundi:

Kustuta taotlus

Kasutage veebiserveris kustutamistoimingu tegemiseks taotlusmeetodit DELETE. Kustutustaotlus kustutab URI-ga tuvastatud ressursi. Kustutustaotlus rakenduses Go näeb välja selline:

funckustuta kasutaja(id string) {
 fmt. Println("Kasutaja kustutamine...")
// tee kasutaja kustutamiseks API-le taotlus DELETE
 apiUrl := " https://reqres.in/api/users/" + id
// loo uus http-päring
 taotlus, viga := http. NewRequest("DELETE", apiUrl, null)
 nõuda. Päis. Set("Sisu tüüp", "rakendus/json; charset=utf-8")
 klient := &http. Klient{}
 vastus, viga := klient. Tee (taotle)
kui viga != null {
 fmt. Println (viga)
 }
 fmt. Println("Olek:", vastus. olek)
}

DELETE-päring ei aktsepteeri ega tagasta keha, mistõttu pole vaja JSON-i päringu ja vastuse keha sõeluda ega vormindada. Vastus tagastab ainult oleku, mis näitab edu või ebaõnnestumist. Funktsiooni näidiskutse koos selle väljundiga näeb välja järgmine:

funcpeamine() {
 fmt. Println("DELETE taotluse esitamine...")
 deleteUser("2")
}

Väljund:

Säästke aega, kasutades http. Postitus() ja http. Hangi () meetodid alates net/http pakk teha POSTITA ja SAADA päringuid otse, ilma et peaks kasutama NewRequest() funktsioon ja Klient{} päringu eraldi loomiseks ja esitamiseks. Tutvuge net/http dokumentatsioon rohkem informatsiooni.

HTTP-päringute tegemine Go rakendustes

The http Go pakett sisaldab kõike, mis on vajalik HTTP-päringute tegemiseks ja vastuste käsitlemiseks Go rakendustes. Paketi pakutavad funktsioonid ja struktuurid võimaldavad teil luua ja saata erinevat tüüpi päringuid, nagu GET, POST, PUT, DELETE ja palju muud.

See muudab Go's lihtsaks veebirakenduste loomise, mis saavad suhelda teiste veebiteenuste ja API-dega. Hea viis saada HTTP-päringute tegemisega Go's paremini tuttavaks on luua rakendus, mis teeb päringuid teisele REST API-le sinu oma.