Ako vytvoriť CRUD API s Golang's Gin a MongoDB

Golang je jedným z najlepšie platených programovacích jazykov s množstvom aplikácií. Pri spárovaní s rámcami ako Gin, Revel a gorilla/mux môžete ľahko vytvoriť API s Go.

Zistite, ako vytvoriť CRUD API v Golang pomocou rámca Gin HTTP.

Počiatočné nastavenie a inštalácia

Začnite s Golangom inštaláciou do počítača, ak ste tak ešte neurobili.

Po inštalácii je ďalším krokom vytvorenie koreňového priečinka projektu na vašom počítači a inicializácia modulu Go v tomto koreňovom adresári.

Ak to chcete urobiť, otvorte CLI, prejdite do koreňového priečinka projektu a spustite:

prejdite na mod init module_name

Uvidíte názov modulu (napr. CRUD_API) a jeho verziu, keď otvoríte súbor go.mod súbor. Všetky vlastné balíčky budú pochádzať z tohto nadradeného modulu. Akýkoľvek importovaný vlastný balík má teda podobu:

importovať(balík CRUD_API/balík-názov-adresára)

Ďalej nainštalujte balíky potrebné na vytvorenie CRUD API. V tomto prípade použite Gin Gonic na smerovanie koncových bodov API:

ísť dostať github.com/gin-gonic/gin

Teraz nainštalujte ovládač MongoDB na ukladanie údajov:

ísť dostať go.mongodb.org/mongo-driver/mongo

Ako sa pripojiť Prejdite na MongoDB

Všetko, čo potrebujete, je vaše MongoDB URI na pripojenie Golangu k databáze. Zvyčajne to vyzerá takto, ak sa pripájate k MongoDB Atlas lokálne:

Mongo_URL = "mongodb://127.0.0.1:27017"

Teraz vytvorte nový priečinok v koreňovom adresári projektu a zavolajte ho databázy. V tomto priečinku vytvorte súbor Go a pomenujte ho database.go.

Toto je váš databázový balík a začína importovaním požadovaných knižníc:

balík databázy
importovať (
"kontext"
"fmt"
"log"
"čas"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func ConnectDB() *mongo. Zákazník {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klient, chyba := mongo. Nový klient (možnosti. Client().ApplyURI(Mongo_URL))
if err != nula {
log.Osudné(chybovať)
	}
ctx, zrušiť := kontext. WithTimeout (kontext. Background(), 10 * čas. druhý)
	chyba = klient. Pripojiť (ctx)
	odložiť zrušenie()
if err != nula {
log.Osudné(chybovať)
	}
fmt. Println("Pripojené k mongoDB")
vrátiť zákazník
}

Najlepšou praxou je skryť premenné prostredia, ako je reťazec pripojenia k databáze v a .env súbor pomocou balíka dotenv. Vďaka tomu je váš kód prenosnejší a hodí sa pri použití a Inštancia cloudového klastra MongoDB, napríklad.

The ConnectDB funkcia vytvorí spojenie a vráti nový objekt MongoDB Client.

Vytvorte kolekciu databázy

MongoDB ukladá údaje do kolekcií, ktoré poskytujú rozhranie pre základné databázové údaje.

Ak chcete zvládnuť funkciu načítania kolekcie, začnite vytvorením nového priečinka, Zbierka, v koreňovom adresári vášho projektu. Teraz vytvorte nový súbor Go, getCollection.go, ktorý získa kolekciu z databázy:

balík getcollection
importovať (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(zákazník *mongo.Zákazník, názov zbierkyreťazec) *mongo.Kolekcia {
	inkaso := klient. Databáza("myGoappDB").Kolekcia("Príspevky")
vrátiť zber
}

Táto funkcia získava kolekciu z databázy MongoDB. Názov databázy je v tomto prípade myGoappDB, s Príspevky ako jeho zbierka.

Vytvorte databázový model

Vytvorte nový priečinok v koreňovom adresári a zavolajte ho Model. Tento priečinok spracováva váš databázový model.

V tomto priečinku vytvorte nový súbor Go a zavolajte ho model.go. Váš model je v tomto prípade blogový príspevok s názvom:

balík Model
importovať (
"go.mongodb.org/mongo-driver/bson/primitive"
)
typu Štruktúra príspevku {
IDprimitívny.ObjectID
	Reťazec názvu
	Reťazec článku
}

Vytvorenie CRUD API s Go

Ďalej je to vytvorenie CRUD API. Ak chcete začať s touto sekciou, vytvorte nový priečinok v koreňovom adresári projektu, ktorý bude spracovávať vaše koncové body. Volaj to trasy.

V tomto priečinku vytvorte samostatný súbor Go pre každú akciu. Môžete ich napríklad pomenovať create.go, read.go, update.go, a delete.go. Tieto obslužné nástroje exportujete ako trasy balík.

Ako vytvoriť koncový bod POST v Go

Začnite definovaním koncového bodu POST na zapisovanie údajov do databázy.

Vnútri routes/create.go, pridajte nasledovné:

balík trasy
importovať (
	getcollection "CRUD_API/Kolekcia"
	databázy "CRUD_API/databázy"
	Model "CRUD_API/model"
"kontext"
"log"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func CreatePost(c *gin. Kontext){
var DB = databáza. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Príspevky")
	ctx, zrušiť := kontext. WithTimeout (kontext. Background(), 10*krát. druhý)
	príspevok := Nový(Model. príspevky)
	odložiť zrušenie()
ak sa mýlim := c. BindJSON(&príspevok); chyba != nula {
 c. JSON(http. StatusBadRequest, gin. H{"správu": err})
log.Osudné(chybovať)
vrátiť
	}
postPayload := model. príspevky{
Id: primitívny.NewObjectID(),
Názov: príspevok.Názov,
Článok: príspevok.Článok,
	}
výsledok, chyba := postCollection. InsertOne (ctx, postPayload)
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": err})
vrátiť
	}
c. JSON(http. StatusCreated, gin. H{"správu": "Odoslané úspešne", "Údaje": map[string]rozhranie{}{"údajov": výsledok}})
}

Tento kód začína importovaním vlastných modulov projektu. Potom importuje balíky tretích strán vrátane Gin a Ovládač MongoDB.

ďalej postCollection uchováva kolekciu databázy. Najmä c. BindJSON("príspevok") je inštancia modelu JSONified, ktorá volá každé pole modelu ako postPayload; toto ide do databázy.

Ako vytvoriť koncový bod GET

Koncový bod GET, in routes/read.go, načíta jeden dokument z databázy prostredníctvom svojho jedinečného ID. Začína to tiež importovaním vlastných balíkov a balíkov tretích strán:

balík trasy
importovať (
	getcollection "CRUD_API/Kolekcia"
	databázy "CRUD_API/databázy"
	Model "CRUD_API/model"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func ReadOnePost(c *gin. Kontext){
	ctx, zrušiť := kontext. WithTimeout (kontext. Background(), 10*krát. druhý)
var DB = databáza. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Príspevky")
postId := c. Param("postId")
var výsledkový model. Príspevky
odložiť zrušenie()
objId, _ := primitívne. ObjectIDFromHex (postId)
err := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&výsledok)
res := mapa[reťazec]rozhranie{}{"údaje": výsledok}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": err})
vrátiť
	}
c. JSON(http. StatusCreated, gin. H{"správu": "úspech!", "Údaje": res})
}

The postId premenná je deklarácia parametra. Získa ID objektu dokumentu ako objId.

však výsledok je inštanciou databázového modelu, ktorý neskôr obsahuje vrátený dokument ako res.

Ako vytvoriť koncový bod PUT

Obslužný program PUT, in routes/update.go, je podobný obslužnému programu POST. Tentoraz aktualizuje existujúci príspevok jeho jedinečným ID objektu:

balík trasy
importovať (
	getcollection "CRUD_API/Kolekcia"
	databázy "CRUD_API/databázy"
	Model "CRUD_API/model"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func UpdatePost(c *gin. Kontext){
	ctx, zrušiť := kontext. WithTimeout (kontext. Background(), 10 * čas. druhý)
var DB = databáza. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Príspevky")
postId := c. Param("postId")
var post model. Príspevky
odložiť zrušenie()
objId, _ := primitívne. ObjectIDFromHex (postId)
ak sa mýlim := c. BindJSON(&príspevok); chyba != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": err})
vrátiť
	}
upravené := bson. M{"titul": príspevok. názov, "článok": príspevok. článok}
výsledok, chyba := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": upravené})
res := mapa[reťazec]rozhranie{}{"údaje": výsledok}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": err})
vrátiť
	}
ak výsledok. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": "Údaje nie'neexistuje"})
vrátiť
	}
c. JSON(http. StatusCreated, gin. H{"správu": "údaje úspešne aktualizované!", "Údaje": res})
}

Formát JSON inštancie modelu (príspevok) volá každé pole modelu z databázy. Premenná result používa MongoDB $set operátora na aktualizáciu požadovaného dokumentu volaného jeho ID objektu.

The výsledok. MatchedCount podmienka bráni spusteniu kódu, ak v databáze nie je žiadny záznam alebo je odovzdané ID neplatné.

Vytvorenie DELETE Endpoint

Koncový bod DELETE, in delete.go, odstráni dokument na základe ID objektu odovzdaného ako parameter adresy URL:

balík trasy
importovať (
	getcollection "CRUD_API/Kolekcia"
	databázy "CRUD_API/databázy"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func Odstrániť príspevok(c *gin. Kontext){
	ctx, zrušiť := kontext. WithTimeout (kontext. Background(), 10*krát. druhý)
var DB = databáza. ConnectDB()
	postId := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Príspevky") 
	odložiť zrušenie()
	objId, _ := primitívne. ObjectIDFromHex (postId) 
	výsledok, chyba := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := mapa[reťazec]rozhranie{}{"údaje": výsledok}
if err != nula {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": err})
vrátiť
	}
ak výsledok. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"správu": "Žiadne údaje na odstránenie"})
vrátiť
	}
c. JSON(http. StatusCreated, gin. H{"správu": "Článok bol úspešne odstránený", "Údaje": res})
}

Tento kód vymaže záznam pomocou DeleteOne funkciu. Používa tiež výsledok. DeletedCount vlastnosť, ktorá zabráni spusteniu kódu, ak je databáza prázdna alebo ID objektu je neplatné.

Vytvorte súbor API Runner

Nakoniec vytvorte a main.go v koreňovom adresári vášho projektu. Konečná štruktúra vášho projektu by mala vyzerať takto:

Tento súbor spracováva spustenie smerovača pre každý koncový bod:

balík hlavné
importovať (
 trasy "CRUD_API/trasy"
"github.com/gin-gonic/gin"
)
func hlavné(){
 router := gin.Predvolené()
router. POST("/", trasy. CreatePost)
// volané ako localhost: 3000/getOne/{id}
 router. GET("getOne/:postId", trasy. ReadOnePost)
// volané ako localhost: 3000/aktualizovať/{id}
 router. PUT("/update/:postId", trasy. UpdatePost)
// volané ako localhost: 3000/vymazať/{id}
 router. DELETE("/vymazať/:postId", trasy. Odstrániť príspevok)
router. Spustiť("localhost: 3000")
}

Tento súbor je hlavným balíkom, ktorý spúšťa ďalšie súbory. Začína sa importovaním obslužných programov trasy. Ďalej je router premenlivý, a gin inštancia, ktorá evokuje akcie HTTP a volá každý koncový bod podľa názvu funkcie z trasy balík.

Váš projekt CRUD beží ďalej localhost: 3000. Ak chcete spustiť server a otestujte CRUD API, spustite nasledujúci príkaz vo svojom základnom adresári:

ísťbehaťhlavné.choď

Premeňte svoj projekt Golang CRUD na použiteľný produkt

Úspešne ste vytvorili CRUD API s Go; gratulujem! Aj keď ide o menší projekt, videli ste, čo je potrebné na vykonávanie bežných požiadaviek HTTP v Go.

Môžete byť kreatívnejší, ak to rozšírite do praktickejšej aplikácie, ktorá používateľom prináša hodnotu. Go je vhodný programovací jazyk pre celý rad prípadov použitia.