Kako stvoriti CRUD API s Golangovim Ginom i MongoDB-om

Golang je jedan od najplaćenijih i traženih programskih jezika s mnogo aplikacija. U kombinaciji s okvirima kao što su Gin, Revel i gorilla/mux, možete jednostavno izraditi API s Go-om.

Naučite kako stvoriti CRUD API u Golangu pomoću Gin HTTP okvira.

Početno postavljanje i instalacija

Započnite s Golangom tako da ga instalirate na svoje računalo ako to već niste učinili.

Nakon instalacije, sljedeći korak je stvaranje korijenske mape projekta na vašem računalu i inicijalizacija Go modula u tom korijenskom direktoriju.

Da biste to učinili, otvorite a CLI, dođite do korijenske mape projekta i pokrenite:

go mod init ime_modula

Vidjet ćete naziv svog modula (npr. CRUD_API) i njegovu verziju kada otvorite go.mod datoteka. Svi prilagođeni paketi dolazit će iz ovog nadređenog modula. Dakle, svaki uvezeni prilagođeni paket ima oblik:

uvoz(paket CRUD_API/paket-ime-direktorija)

Zatim instalirajte pakete potrebne za stvaranje CRUD API-ja. U ovom slučaju, koristite Gin Gonic za usmjeravanje API krajnjih točaka:

instagram viewer

ići dobiti github.com/gin-gonic/gin

Sada instalirajte MongoDB Driver za pohranu podataka:

ići dobiti go.mongodb.org/mongo-driver/mongo

Kako se povezati Idite na MongoDB

Sve što trebate je vaš MongoDB URI za povezivanje Golanga s bazom podataka. Obično izgleda ovako ako se povezujete na MongoDB Atlas lokalno:

Mongo_URL = "mongodb://127.0.0.1:27017"

Sada stvorite novu mapu u korijenskom direktoriju vašeg projekta i pozovite je baze podataka. Stvorite Go datoteku unutar ove mape i dajte joj naziv baza podataka.go.

Ovo je vaš paket baze podataka i počinje uvozom potrebnih biblioteka:

paket baza podatakauvoz (
"kontekst"
"fmt"
"log"
"vrijeme"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
funk ConnectDB() *mongo. Klijent {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klijent, greška := mongo. NewClient (opcije. Klijent().PrimijeniURI(Mongo_URL))
if err != nula {
log.Kobno(pogriješiti)
	}
ctx, odustani := kontekst. WithTimeout (kontekst. Pozadina(), 10 * vrijeme. Drugi)
	pogreška = klijent. Poveži (ctx)
	odgoditi odustani()
if err != nula {
log.Kobno(pogriješiti)
	}fmt. Println("Povezan na mongoDB")
povratak klijent
}

Najbolja je praksa sakriti varijable okruženja poput niza povezivanja baze podataka u a .env datoteka pomoću paketa dotenv. To čini vaš kod prenosivijim i korisnim kada koristite a Instanca MongoDB klastera u oblaku, na primjer.

The ConnectDB funkcija uspostavlja vezu i vraća novi objekt MongoDB klijenta.

Stvorite zbirku baze podataka

MongoDB pohranjuje podatke u zbirkama, koje pružaju sučelje za temeljne podatke baze podataka.

Za rukovanje funkcijom dohvaćanja zbirke, počnite stvaranjem nove mape, Kolekcija, u korijenu vašeg projekta. Sada izradite novu Go datoteku, getCollection.go, koji dobiva kolekciju iz baze podataka:

paket getcollectionuvoz (
"go.mongodb.org/mongo-driver/mongo"
)funkGetCollection(klijent *mongo.Klijent, naziv zbirkeniz) *mongo.Kolekcija {
	zbirka := klijent. Baza podataka("myGoappDB").Kolekcija("Postovi")
povratak kolekcija
}

Ova funkcija dobiva kolekciju iz MongoDB baze podataka. Naziv baze podataka, u ovom slučaju, je myGoappDB, sa Postovi kao svoju zbirku.

Stvorite model baze podataka

Napravite novu mapu unutar svog korijenskog direktorija i pozovite je model. Ova mapa upravlja vašim modelom baze podataka.

Stvorite novu Go datoteku unutar te mape i pozovite je model.ići. Vaš je model, u ovom slučaju, post na blogu s naslovom:

paket modeluvoz (
"go.mongodb.org/mongo-driver/bson/primitive"
)tip Post struct {
iskaznicaprimitivna.ID objekta
	Niz naslova
	Niz članka
}

Stvaranje CRUD API-ja uz Go

Sljedeće je stvaranje CRUD API-ja. Da biste započeli s ovim odjeljkom, napravite novu mapu unutar korijenskog direktorija vašeg projekta za rukovanje krajnjim točkama. Nazovi to rute.

Stvorite zasebnu Go datoteku u ovoj mapi za svaku radnju. Na primjer, možete ih imenovati stvoriti.krenuti, čitati.ići, ažuriraj.kreni, i izbrisati.krenuti. Ove rukovatelje ćete izvesti kao rute paket.

Kako stvoriti krajnju točku POST-a u Go

Započnite definiranjem POST krajnje točke za upisivanje podataka u bazu podataka.

Unutra rute/create.go, dodajte sljedeće:

paket ruteuvoz (
	getcollection "CRUD_API/Zbirka"
	baza podataka "CRUD_API/baze podataka"
	model "CRUD_API/model"
"kontekst"
"log"
"net/http"
"vrijeme"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funk CreatePost(c *gin. Kontekst){
var DB = baza podataka. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postovi")
	ctx, odustani := kontekst. WithTimeout (kontekst. Pozadina(), 10*vrijeme. Drugi)
	post := novi(model. Postovi)
	odgoditi odustani()
ako pogriješi := c. BindJSON(&post); pogreška != nula {
 c. JSON(http. StatusBadRequest, gin. H{"poruka": pogreška})
log.Kobno(pogriješiti)
povratak
	}
postPayload := model. Postovi{
Iskaznica: primitivna.NewObjectID(),
Titula: objaviti.Titula,
Članak: objaviti.Članak,
	}
rezultat, pogreška := postCollection. InsertOne (ctx, postPayload)
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": pogreška})
povratak
	}c. JSON(http. StatusCreated, gin. H{"poruka": "Uspješno objavljeno", "Podaci": map[string]sučelje{}{"podaci": rezultat}})
}

Ovaj kôd počinje uvozom prilagođenih modula projekta. Zatim uvozi pakete trećih strana uključujući Džin i MongoDB upravljački program.

Unaprijediti, postCollection čuva zbirku baze podataka. Posebno, c. BindJSON("post") je JSONificirana instanca modela koja poziva svako polje modela kao postPayload; ovo ide u bazu podataka.

Kako stvoriti GET krajnju točku

GET krajnja točka, u rute/read.go, čita jedan dokument iz baze podataka preko njegovog jedinstvenog ID-a. Također počinje uvozom prilagođenih paketa i paketa trećih strana:

paket ruteuvoz (
	getcollection "CRUD_API/Zbirka"
	baza podataka "CRUD_API/baze podataka"
	model "CRUD_API/model"
"kontekst"
"net/http"
"vrijeme"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funk ReadOnePost(c *gin. Kontekst){
	ctx, odustani := kontekst. WithTimeout (kontekst. Pozadina(), 10*vrijeme. Drugi)
var DB = baza podataka. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postovi")
postId := c. Param("postId")
var model rezultata. Postovi
odgoditi odustani()
objId, _ := primitivan. ObjectIDFromHex (postId)
pogreška := postCollection. FindOne (ctx, bson. M{"iskaznica": objId}).Dekodiraj(&proizlaziti)
res := karta[string]sučelje{}{"podaci": rezultat}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": pogreška})
povratak
	}c. JSON(http. StatusCreated, gin. H{"poruka": "uspjeh!", "Podaci": res})
}

The postId varijabla je deklaracija parametra. Dobiva ID objekta dokumenta kao objId.

Međutim, proizlaziti je instanca modela baze podataka, koja kasnije čuva vraćeni dokument kao res.

Kako stvoriti krajnju točku PUT

Rukovatelj PUT, u rute/ažuriranje.go, sličan je POST rukovatelju. Ovaj put ažurira postojeću objavu svojim jedinstvenim ID-om objekta:

paket ruteuvoz (
	getcollection "CRUD_API/Zbirka"
	baza podataka "CRUD_API/baze podataka"
	model "CRUD_API/model"
"kontekst"
"net/http"
"vrijeme"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funk UpdatePost(c *gin. Kontekst){
	ctx, odustani := kontekst. WithTimeout (kontekst. Pozadina(), 10 * vrijeme. Drugi)
var DB = baza podataka. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postovi")
postId := c. Param("postId")
var post model. Postovi
odgoditi odustani()
objId, _ := primitivan. ObjectIDFromHex (postId)
ako pogriješi := c. BindJSON(&post); pogreška != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": pogreška})
povratak
	}
uređeno := bson. M{"titula": post. Titula, "članak": post. Članak}
rezultat, pogreška := postCollection. UpdateOne (ctx, bson. M{"iskaznica": objId}, bson. M{"$set": uređeno})
res := karta[string]sučelje{}{"podaci": rezultat}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": pogreška})
povratak
	}
ako rezultat. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": "Podaci ne't postoji"})
povratak
	}c. JSON(http. StatusCreated, gin. H{"poruka": "podaci uspješno ažurirani!", "Podaci": res})
}

JSON format instance modela (objaviti) poziva svako polje modela iz baze podataka. Varijabla rezultata koristi MongoDB $set operator za ažuriranje traženog dokumenta koji se poziva njegovim ID-om objekta.

The proizlaziti. MatchedCount uvjet sprječava izvođenje koda ako u bazi podataka nema zapisa ili je proslijeđeni ID nevažeći.

Stvaranje krajnje točke DELETE

Krajnja točka DELETE, u izbrisati.krenuti, uklanja dokument na temelju ID-a objekta proslijeđenog kao URL parametar:

paket ruteuvoz (
	getcollection "CRUD_API/Zbirka"
	baza podataka "CRUD_API/baze podataka"
"kontekst"
"net/http"
"vrijeme"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funk Izbriši objavu(c *gin. Kontekst){
	ctx, odustani := kontekst. WithTimeout (kontekst. Pozadina(), 10*vrijeme. Drugi)
var DB = baza podataka. ConnectDB()
	postId := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Postovi") 
	odgoditi odustani()
	objId, _ := primitivan. ObjectIDFromHex (postId) 
	rezultat, pogreška := postCollection. DeleteOne (ctx, bson. M{"iskaznica": objId}) 
	res := karta[string]sučelje{}{"podaci": rezultat}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": pogreška})
povratak
	}
ako rezultat. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"poruka": "Nema podataka za brisanje"})
povratak
	}c. JSON(http. StatusCreated, gin. H{"poruka": "Članak je uspješno izbrisan", "Podaci": res})
}

Ovaj kod briše zapis pomoću DeleteOne funkcija. Također koristi proizlaziti. DeletedCount svojstvo za sprječavanje izvođenja koda ako je baza podataka prazna ili je ID objekta nevažeći.

Stvorite datoteku API Runner

Na kraju, stvorite a glavni.krenuti unutar korijenskog direktorija vašeg projekta. Vaša konačna struktura projekta trebala bi izgledati ovako:

Ova datoteka upravlja izvršavanjem usmjerivača za svaku krajnju točku:

paket glavniuvoz (
 rute "CRUD_API/rute"
"github.com/gin-gonic/gin"
)
funk glavni(){
 usmjerivač := gin.Zadano()
ruter. OBJAVI("/", rute. CreatePost)
// poziva se kao lokalni host: 3000/getOne/{id}
 ruter. DOBITI("getOne/:postId", rute. ReadOnePost)
// poziva se kao lokalni host: 3000/Ažuriraj/{iskaznica}
 ruter. STAVITI("/update/:postId", rute. UpdatePost)
// poziva se kao lokalni host: 3000/izbrisati/{iskaznica}
 ruter. IZBRISATI("/izbrisati/:postId", rute. Izbriši objavu)ruter. Trčanje("lokalni host: 3000")
}

Ova datoteka je glavni paket koji pokreće druge datoteke. Započinje uvozom rukovatelja rutama. Sljedeće je ruter varijabla, a džin instanca koja evocira HTTP radnje i poziva svaku krajnju točku prema nazivu funkcije iz rute paket.

Vaš CRUD projekt radi dalje lokalni host: 3000. Za pokretanje poslužitelja i testirajte CRUD API, pokrenite sljedeću naredbu u svom osnovnom direktoriju:

ićitrčanjeglavni.ići

Pretvorite svoj Golang CRUD projekt u upotrebljiv proizvod

Uspješno ste izradili CRUD API s Goom; Čestitamo! Iako je ovo manji projekt, vidjeli ste što je potrebno za izvršavanje regularnih HTTP zahtjeva u Gou.

Možete postati kreativniji ako ovo proširite na praktičniju aplikaciju koja donosi vrijednost korisnicima. Go je prikladan programski jezik za niz slučajeva upotrebe.

About Technology - denizatm.com