Kuinka luoda CRUD-sovellusliittymä Golang's Ginin ja MongoDB: n avulla

Golang on yksi eniten maksavista, kysytyistä ohjelmointikielistä, jossa on monia sovelluksia. Kun yhdistät kehykset, kuten Gin, Revel ja gorilla/mux, voit helposti luoda API: n Golla.

Opi luomaan CRUD API Golangissa Gin HTTP -kehyksen avulla.

Alkuasennus ja asennus

Aloita Golangin kanssa asentamalla sen tietokoneellesi, jos et ole jo tehnyt niin.

Asennuksen jälkeen seuraava vaihe on luoda projektin juurikansio koneellesi ja alustaa Go-moduuli kyseiseen juurihakemistoon.

Voit tehdä tämän avaamalla CLI, siirry projektisi juurikansioon ja suorita:

go mod init moduulin_nimi

Näet moduulisi nimen (esim. CRUD_API) ja sen versio, kun avaat go.mod tiedosto. Kaikki mukautetut paketit tulevat tästä ylämoduulista. Joten mikä tahansa tuotu mukautettu paketti on muodossa:

tuonti(paketti CRUD_API/paketti-hakemiston nimi)

Asenna seuraavaksi CRUD API: n luomiseen tarvittavat paketit. Käytä tässä tapauksessa Gin Gonic reitittääksesi API-päätepisteet:

mennä saada github.com/gin-gonic/gin

Asenna nyt MongoDB-ohjain tietojen tallentamiseksi:

mennä saada go.mongodb.org/mongo-driver/mongo

Yhteyden muodostaminen Siirry MongoDB: hen

Tarvitset vain MongoDB URI: si yhdistääksesi Golangin tietokantaan. Se näyttää yleensä tältä, jos muodostat yhteyden MongoDB Atlasiin paikallisesti:

Mongo_URL = "mongodb://127.0.0.1:27017"

Luo nyt uusi kansio projektisi juurihakemistoon ja kutsu se tietokannat. Luo Go-tiedosto tähän kansioon ja nimeä se tietokanta.go.

Tämä on tietokantapakettisi, ja se alkaa tuomalla tarvittavat kirjastot:

paketti tietokanta
tuonti (
"yhteydessä"
"fmt"
"Hirsi"
"aika"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func ConnectDB() *mongo. Asiakas {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	asiakas, err := mongo. NewClient (valinnat. Asiakas().ApplyURI(Mongo_URL))
jos err != nolla {
HirsiKohtalokas(err)
	}
ctx, peruuta := konteksti. WithTimeout (konteksti. Tausta(), 10 * aika. Toinen)
	err = asiakas. Yhdistä (ctx)
	lykätä peruuttaa ()
jos err != nolla {
HirsiKohtalokas(err)
	}
fmt. Println("Yhdistetty mongoDB: hen")
palata asiakas
}

On paras käytäntö piilottaa ympäristömuuttujat, kuten tietokantayhteysmerkkijono a: ssa .env tiedosto käyttämällä dotenv-pakettia. Tämä tekee koodistasi kannettavamman ja on kätevä, kun käytät a MongoDB-pilviklusterin ilmentymä, esimerkiksi.

The ConnectDB toiminto muodostaa yhteyden ja palauttaa uuden MongoDB Client -objektin.

Luo tietokantakokoelma

MongoDB tallentaa tiedot kokoelmiin, jotka tarjoavat käyttöliittymän taustalla oleviin tietokantatietoihin.

Voit hoitaa kokoelman noutotoiminnon luomalla uuden kansion, Kokoelma, projektisi juuressa. Luo nyt uusi Go-tiedosto, getCollection.go, joka saa kokoelman tietokannasta:

paketti saada kokoelma
tuonti (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(asiakas *mongo.Asiakas, kokoelman nimimerkkijono) *mongo.Kokoelma {
	kokoelma := asiakas. Tietokanta("myGoappDB").Kokoelma("Viestit")
palata kokoelma
}

Tämä toiminto saa kokoelman MongoDB-tietokannasta. Tietokannan nimi tässä tapauksessa on myGoappDB, kanssa Viestit sen kokoelmana.

Luo tietokantamalli

Tee uusi kansio juurihakemistoosi ja kutsu se malli-. Tämä kansio käsittelee tietokantamalliasi.

Luo uusi Go-tiedosto kyseiseen kansioon ja kutsu se model.go. Mallisi on tässä tapauksessa blogikirjoitus, jonka otsikko on:

paketti malli-
tuonti (
"go.mongodb.org/mongo-driver/bson/primitive"
)
tyyppi Post struct {
IDprimitiivinen.ObjectID
	Otsikkomerkkijono
	Artikkelimerkkijono
}

CRUD API: n luominen Golla

Seuraavaksi luodaan CRUD API. Aloita tästä osiosta luomalla projektisi juurihakemistoon uusi kansio päätepisteiden käsittelemistä varten. Kutsu sitä reitit.

Luo erillinen Go-tiedosto tähän kansioon kullekin toiminnolle. Voit esimerkiksi nimetä ne luo.go, read.go, update.go, ja delete.go. Vie nämä käsittelijät nimellä reitit paketti.

POST-päätepisteen luominen Gossa

Aloita määrittämällä POST-päätepiste tietojen kirjoittamiseksi tietokantaan.

Sisällä routes/create.go, lisää seuraavat:

paketti reitit
tuonti (
	saada kokoelma "CRUD_API/kokoelma"
	tietokanta "CRUD_API/tietokannat"
	malli- "CRUD_API/malli"
"yhteydessä"
"Hirsi"
"net/http"
"aika"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func Luo viesti(c *gin. konteksti){
var DB = tietokanta. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Viestit")
	ctx, peruuta := konteksti. WithTimeout (konteksti. Tausta(), 10*aika. Toinen)
	postaus := Uusi(malli. Viestit)
	lykätä peruuttaa ()
jos err := c. BindJSON(&lähettää); err != nolla {
 c. JSON(http. StatusBadRequest, gin. H{"viesti": err})
HirsiKohtalokas(err)
palata
	}
postPayload := malli. Viestit{
Id: primitiivinen.NewObjectID(),
Otsikko: lähettää.Title,
Artikla: lähettää.Artikla,
	}
tulos, err := postCollection. InsertOne (ctx, postPayload)
jos err != nolla {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": err})
palata
	}
c. JSON(http. TilaLuotu, gin. H{"viesti": "Lähetetty onnistuneesti", "Data": kartta[merkkijono]käyttöliittymä{}{"tiedot": tulos}})
}

Tämä koodi alkaa tuomalla projektin mukautetut moduulit. Sitten se tuo kolmannen osapuolen paketteja, mukaan lukien Gin ja MongoDB-ohjain.

Edelleen, postCollection sisältää tietokantakokoelman. Erityisesti c. BindJSON("viesti") on JSONified-mallin ilmentymä, joka kutsuu jokaista mallikenttää nimellä postPayload; tämä menee tietokantaan.

Kuinka luoda GET-päätepiste

GET-päätepiste, sisään routes/read.go, lukee yksittäisen asiakirjan tietokannasta yksilöllisen tunnuksensa kautta. Se alkaa myös tuomalla mukautettuja ja kolmannen osapuolen paketteja:

paketti reitit
tuonti (
	saada kokoelma "CRUD_API/kokoelma"
	tietokanta "CRUD_API/tietokannat"
	malli- "CRUD_API/malli"
"yhteydessä"
"net/http"
"aika"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func ReadOnePost(c *gin. konteksti){
	ctx, peruuta := konteksti. WithTimeout (konteksti. Tausta(), 10*aika. Toinen)
var DB = tietokanta. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Viestit")
postId := c. Param("postId")
var tulosmalli. Viestit
lykätä peruuttaa ()
objId, _ := primitiivinen. ObjectIDFromHex (postId)
err := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&tulos)
res := kartta[merkkijono]käyttöliittymä{}{"data": tulos}
jos err != nolla {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": err})
palata
	}
c. JSON(http. TilaLuotu, gin. H{"viesti": "menestys!", "Data": res})
}

The postId muuttuja on parametrimääritys. Se saa asiakirjan objektitunnuksen muodossa objId.

Kuitenkin, tulos on tietokantamallin esiintymä, joka sisältää myöhemmin palautetun asiakirjan muodossa res.

Kuinka luoda PUT-päätepiste

PUT-käsittelijä, sisään routes/update.go, on samanlainen kuin POST-käsittelijä. Tällä kertaa se päivittää olemassa olevan viestin ainutlaatuisella objektitunnuksellaan:

paketti reitit
tuonti (
	saada kokoelma "CRUD_API/kokoelma"
	tietokanta "CRUD_API/tietokannat"
	malli- "CRUD_API/malli"
"yhteydessä"
"net/http"
"aika"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func UpdatePost(c *gin. konteksti){
	ctx, peruuta := konteksti. WithTimeout (konteksti. Tausta(), 10 * aika. Toinen)
var DB = tietokanta. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Viestit")
postId := c. Param("postId")
var post malli. Viestit
lykätä peruuttaa ()
objId, _ := primitiivinen. ObjectIDFromHex (postId)
jos err := c. BindJSON(&lähettää); err != nolla {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": err})
palata
	}
muokattu := bson. M{"otsikko": viesti. Otsikko, "artikla": viesti. Artikla}
tulos, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": muokattu})
res := kartta[merkkijono]käyttöliittymä{}{"data": tulos}
jos err != nolla {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": err})
palata
	}
jos tulos. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": "Data ei't olemassa"})
palata
	}
c. JSON(http. TilaLuotu, gin. H{"viesti": "tiedot päivitetty onnistuneesti!", "Data": res})
}

Mallin esiintymän JSON-muoto (lähettää) kutsuu jokaista mallikenttää tietokannasta. Tulosmuuttuja käyttää MongoDB: tä $set operaattori päivittää vaaditun asiakirjan, jota kutsutaan sen objektitunnuksella.

The tulos. MatchedCount ehto estää koodin suorittamisen, jos tietokannassa ei ole tietueita tai välitetty tunnus on virheellinen.

Luodaan DELETE-päätepistettä

DELETE-päätepiste delete.go, poistaa asiakirjan URL-parametrina välitetyn objektitunnuksen perusteella:

paketti reitit
tuonti (
	saada kokoelma "CRUD_API/kokoelma"
	tietokanta "CRUD_API/tietokannat"
"yhteydessä"
"net/http"
"aika"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func PoistaPost(c *gin. konteksti){
	ctx, peruuta := konteksti. WithTimeout (konteksti. Tausta(), 10*aika. Toinen)
var DB = tietokanta. ConnectDB()
	postId := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Viestit") 
	lykätä peruuttaa ()
	objId, _ := primitiivinen. ObjectIDFromHex (postId) 
	tulos, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := kartta[merkkijono]käyttöliittymä{}{"data": tulos}
jos err != nolla {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": err})
palata
	}
jos tulos. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"viesti": "Ei poistettavia tietoja"})
palata
	}
c. JSON(http. TilaLuotu, gin. H{"viesti": "Artikkelin poistaminen onnistui", "Data": res})
}

Tämä koodi poistaa tietueen käyttämällä DeleteOne toiminto. Se käyttää myös tulos. DeletedCount -ominaisuus estää koodin suorittamisen, jos tietokanta on tyhjä tai objektin tunnus on virheellinen.

Luo API Runner -tiedosto

Luo lopuksi a main.go projektisi juurihakemistossa. Lopullisen projektisi rakenteen pitäisi näyttää tältä:

Tämä tiedosto käsittelee reitittimen suorittamisen jokaiselle päätepisteelle:

paketti pää
tuonti (
 reitit "CRUD_API/reitit"
"github.com/gin-gonic/gin"
)
func pää(){
 reititin := gin.Oletus()
reititin. LÄHETTÄÄ("/", reittejä. Luo viesti)
// kutsutaan localhostiksi: 3000/getOne/{id}
 reititin. SAADA("getOne/:postId", reittejä. ReadOnePost)
// kutsutaan localhostiksi: 3000/päivittää/{id}
 reititin. LAITTAA("/update/:postId", reittejä. UpdatePost)
// kutsutaan localhostiksi: 3000/poistaa/{id}
 reititin. POISTAA("/poistaa/:postId", reitit. Poista viesti)
reititin. Juosta("paikallinen isäntä: 3000")
}

Tämä tiedosto on pääpaketti, joka suorittaa muita tiedostoja. Se alkaa tuomalla reittikäsittelijät. Seuraava on reititin muuttuja, a gin esiintymä, joka herättää HTTP-toiminnot ja kutsuu jokaista päätepistettä sen funktion nimellä reitit paketti.

CRUD-projektisi jatkuu paikallinen isäntä: 3000. Palvelimen ajamiseen ja testaa CRUD API: ta, suorita seuraava komento perushakemistossasi:

mennäjuostapää.mennä

Tee Golang CRUD -projektistasi käyttökelpoinen tuote

Olet onnistuneesti luonut CRUD API: n Golla; Onnittelut, Vaikka tämä on pieni projekti, olet nähnyt, mitä tavallisten HTTP-pyyntöjen suorittaminen vaatii Gossa.

Voit saada lisää luovuutta laajentamalla tätä käytännöllisemmäksi sovellukseksi, joka tuottaa arvoa käyttäjille. Go on sopiva ohjelmointikieli useisiin käyttötarkoituksiin.