HTTP-pyyntöjen tekeminen Gossa

Yksi World Wide Webin toimintaa ohjaavista perusperiaatteista on pyyntöjen ja vastausten vaihto. Kun lähetät pyynnön päästä verkkosivulle, palvelin vastaa asiaankuuluvilla tiedoilla.

Suosittuja protokollia, jotka hallitsevat erityyppistä Internet-viestintää, ovat mm HTTP (Hypertext Transfer Protocol), FTP (Tiedostonsiirtoprotokolla) ja SMTP (Simple Mail Transfer Protocol).

HTTP on protokolla, jota yleensä käytät, kun tarkastelet verkkosivustoa tai käytät verkkosovellusta. Voit myös käsitellä HTTP-pyyntöjä useilta ohjelmointikieliltä, ​​mukaan lukien Go.

Mikä on HTTP-pyyntö?

HTTP määrittää, kuinka asiakkaat, kuten verkkoselaimet, lähettävät pyyntöjä palvelimille, jotka sitten palauttavat vastauksen. HTTP-pyyntö sisältää tietoja resurssista, jota asiakas yrittää käyttää. Pyyntösanoma sisältää tyypillisesti URL-osoitteen, joka identifioi resurssin, ja muita valinnaisia ​​tietoja, kuten otsikoita ja kyselyparametreja.

On useita HTTP-pyyntötyyppejä, mukaan lukien GET, POST, PUT, DELETE, HEAD, OPTIONS ja CONNECT. Ensimmäiset neljä menetelmätyyppiä ovat yleisimpiä; ne heijastavat CRUD-toimintoja, jotka lukevat, luovat, päivittävät ja poistavat vastaavasti.

PUT-pyyntötyyppiä käytetään usein vaihtokelpoisesti PATCH-pyyntötyypin kanssa. Niillä saavutetaan sama tarkoitus, ne eroavat vain tiedoista, joita he odottavat pyynnön sisältävän.

Pyyntöjen lähettäminen yleisillä HTTP-menetelmillä

Go on sisäänrakennettu http paketti tarjoaa joukon toimintoja ja rakenteita, joiden avulla voit luoda verkkopalvelimia ja hallita HTTP-pyyntöjä. Se on erittäin vankka paketti, ja kaikki Go-verkkokehykset rakentuvat sen päälle tavalla tai toisella. Se on Go: n alapaketti netto paketti.

Voit luoda HTTP-pyynnön Gossa käyttämällä http. NewRequest() funktio ja aseta sopiva menetelmä, URL-osoite, otsikot ja pyynnön runko. Kun olet luonut pyynnön, voit käyttää Go net/http paketin http. Asiakas{} rakennetta sen suorittamiseksi ja vastauksen vastaanottamiseksi.

Seuraavat koodiesimerkit käyttävät reqres.in, julkisesti saatavilla oleva API HTTP-pyyntöjen testaamiseen. Voit käyttää sitä GET-, POST-, PUT- ja DELETE-pyyntöjen testaamiseen Go-ohjelmissasi.

POST-pyyntö

Alla oleva koodi on toiminto, joka lähettää POST-pyynnön /api/users reqres.in-päätepiste luodaksesi uuden käyttäjän, jolla on nimi ja työ.

paketti pää
tuonti (
"tavua"
"koodaus/json"
"fmt"
"io"
"net/http"
)
funcluo käyttäjä(nimi, työpaikka merkkijono) {
 fmt. Println("Luodaan käyttäjää...")
 apiUrl := " https://reqres.in/api/users"
 käyttäjätiedot := []tavu(`{"nimi":"` + nimi + `","työ":"` + työpaikka + `"}`)
// luo uusi http-pyyntö
 pyyntö, virhe := http. NewRequest("LÄHETTÄÄ", apiUrl, tavua. NewBuffer (käyttäjätiedot))
 pyyntö. Otsikko. Aseta("Sisältötyyppi", "sovellus/json; charset=utf-8")
// lähetä pyyntö
 asiakas := &http. Asiakas{}
 vastaus, virhe := asiakas. Tee (pyydä)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 responseBody, error := io. Lue kaikki (vastaus. runko)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Tila: ", vastaus. Tila)
 fmt. Println("Vastausteksti:", muotoiltu data)
// puhdistaa muisti suorituksen jälkeen
lykätä vastaus. Runko. Kiinni()
}

muotoJSON on mukautettu funktio, jonka avulla voit muotoilla lähtötiedot. Näin voit toteuttaa sen:

//-funktio JSON-tietojen alustamiseksi
funcmuotoJSON(tiedot []tavu)merkkijono {
var ulos tavuja. Puskuri
 virhe := json. Sisennys(&out, data, "", " ")
jos virhe! = nolla {
 fmt. Println (err)
 }
 d := ulos. Tavua()
palatamerkkijono(d)
}

Voit soittaa luo käyttäjä() toimii tällaisessa ohjelmassa:

funcpää() {
 fmt. Println("Tehdään POST-pyyntö...")
 luo käyttäjä("Tim Omolana", "Kirjailija")
}

Kun suoritat ohjelman päätteessä, käytä mene juoksemaan -komento, näet seuraavanlaisen lähdön:

HAE Pyyntö

Seuraava koodi on toiminto, joka lähettää GET-pyynnön käyttäjän hakemiseksi reqres.in-palvelimelta käyttämällä hänen yksilöllistä tunnusta.

// main.go
funcgetUser(id merkkijono) {
 fmt. Println("Haetaan käyttäjää tunnuksella...")
// tee GET-pyyntö API: lle saadaksesi käyttäjän tunnuksella
 apiUrl := " https://reqres.in/api/users/" + id
 pyyntö, virhe := http. NewRequest("SAADA", apiUrl, nolla)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 pyyntö. Otsikko. Aseta("Sisältötyyppi", "sovellus/json; charset=utf-8")
 asiakas := &http. Asiakas{}
 vastaus, virhe := asiakas. Tee (pyydä)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 responseBody, error := io. Lue kaikki (vastaus. runko)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Tila: ", vastaus. Tila)
 fmt. Println("Vastausteksti:", muotoiltu data)
// puhdistaa muisti suorituksen jälkeen
lykätä vastaus. Runko. Kiinni()
}

GET-pyyntö ei lähetä tietoja palvelimelle, joten se ei hyväksy tai lähetä pyynnön runkoa palvelimelle tehtäessä. Tältä näyttää esimerkkikutsu yllä olevaan funktioon:

funcpää() {
 fmt. Println("Tee GET-pyyntöä...")
 getUser("2")
}

Lähtö:

PUT-pyyntö

PUT-pyyntö on hyvin samanlainen kuin POST-pyyntö, koska se lähettää myös tietoja palvelimelle. Suurin ero on, että POST luo uuden resurssin, kun taas PUT päivittää olemassa olevan.

Tässä on PUT-pyynnön toteutus:

// main.go
funcpäivitäKäyttäjä(nimi, työpaikka, tunnus merkkijono) {
 fmt. Println("Päivitetään käyttäjää...")
// tee PUT-pyyntö API: lle päivittääksesi käyttäjän
 apiUrl := " https://reqres.in/api/users/" + id
 käyttäjätiedot := []tavu(`{"nimi":"` + nimi + `","työ":"` + työpaikka + `"}`)
// luo uusi http PUT -pyyntö
 pyyntö, virhe := http. NewRequest("LAITTAA", apiUrl, tavua. NewBuffer (käyttäjätiedot))
 pyyntö. Otsikko. Aseta("Sisältötyyppi", "sovellus/json; charset=utf-8")
// Jäljellä oleva funktion runko CreateUser-funktiosta...
// Tee pyyntö, vastaanota vastaus ja tyhjennä muisti...
}

Tästä koodista näet, että ainoat erot yllä olevan PUT-pyynnön ja POST-pyynnön välillä ovat menetelmän nimi ja URL-osoite. Kun käytät PUT: ta olemassa olevien tietojen päivittämiseen, sinun on liitettävä tunnus pyynnön URL-osoitteeseen. Esimerkkikutsu tälle funktiolle näyttäisi tältä:

func main() {
// päivitä merkintä tunnuksella 2.
 updateUser("Tim Newname", "Henkilökunnan kirjoittaja", "2")
}

Yllä oleva koodi päivittää käyttäjän ja tuottaa seuraavan tulosteen:

POISTA pyyntö

Käytä DELETE-pyyntömenetelmää poistaaksesi verkkopalvelimen. Poistopyyntö poistaa URI: n tunnistaman resurssin. POISTA-pyyntö Goissa näyttää tältä:

funcpoistaKäyttäjä(id merkkijono) {
 fmt. Println("Poistetaan käyttäjää...")
// tee DELETE-pyyntö API: lle käyttäjän poistamiseksi
 apiUrl := " https://reqres.in/api/users/" + id
// luo uusi http-pyyntö
 pyyntö, virhe := http. NewRequest("POISTAA", apiUrl, nolla)
 pyyntö. Otsikko. Aseta("Sisältötyyppi", "sovellus/json; charset=utf-8")
 asiakas := &http. Asiakas{}
 vastaus, virhe := asiakas. Tee (pyydä)
jos virhe! = nolla {
 fmt. Println (virhe)
 }
 fmt. Println("Tila: ", vastaus. Tila)
}

DELETE-pyyntö ei hyväksy eikä palauta runkoa, joten JSON-pyyntö- ja vastausrunkoa ei tarvitse jäsentää tai muotoilla. Vastaus palauttaa vain tilan, joka osoittaa onnistumisen tai epäonnistumisen. Tältä näyttää esimerkkikutsu funktiolle tulostensa kanssa:

funcpää() {
 fmt. Println("Tehdään POISTA-pyyntöä...")
 deleteUser("2")
}

Lähtö:

Säästä aikaa käyttämällä http. Lähettää() ja http. Saada() menetelmät net/http tehdä paketti LÄHETTÄÄ ja SAADA pyytää suoraan ilman, että sinun tarvitsee käyttää NewRequest() toiminto ja Asiakas{} rakenne luoda ja tehdä pyyntö erikseen. Tutustu net/http-dokumentaatio Lisätietoja.

HTTP-pyyntöjen tekeminen Go-sovelluksissa

The http paketti Go tarjoaa kaiken tarvittavan HTTP-pyyntöjen tekemiseen ja vastausten käsittelemiseen Go-sovelluksissa. Paketin tarjoamien toimintojen ja rakenteiden avulla voit luoda ja lähettää erilaisia ​​pyyntöjä, kuten GET, POST, PUT, DELETE ja monia muita.

Tämän ansiosta Gossa on helppo rakentaa verkkosovelluksia, jotka voivat olla vuorovaikutuksessa muiden verkkopalvelujen ja sovellusliittymien kanssa. Hyvä tapa saada HTTP-pyyntöjen tekeminen Gossa on tutumpi rakentamalla sovellus, joka tekee pyyntöjä toiselle REST API: lle sinun.