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

Ako vytvoriť CRUD API pomocou 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.



VYUŽITIE VIDEA DŇA

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:



go 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:

import(package CRUD_API/package-directory-name)

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



go get github.com/gin-gonic/gin

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

go get 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:



Windows 7 vs. Windows 10 
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:

package database 
  
import ( 
	"context" 
	"fmt" 
	"log" 
	"time" 
	"go.mongodb.org/mongo-driver/mongo" 
	"go.mongodb.org/mongo-driver/mongo/options" 
) 
  
func ConnectDB() *mongo.Client { 
	Mongo_URL := "mongodb://127.0.0.1:27017" 
	client, err := mongo.NewClient(options.Client().ApplyURI(Mongo_URL)) 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	err = client.Connect(ctx) 
	defer cancel() 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	fmt.Println("Connected to mongoDB") 
	return client 
}

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:

package getcollection 
  
import ( 
	"go.mongodb.org/mongo-driver/mongo" 
) 
  
func GetCollection(client *mongo.Client, collectionName string) *mongo.Collection { 
	collection := client.Database("myGoappDB").Collection("Posts") 
	return collection 
}

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:

package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

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é:

ako urobiť obrázky do jedného 
package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"log" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func CreatePost(c *gin.Context) { 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	post := new(model.Posts) 
	defer cancel() 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusBadRequest, gin.H{"message": err}) 
		log.Fatal(err) 
		return 
	} 
  
	postPayload := model.Posts{ 
		Id:      primitive.NewObjectID(), 
		Title:   post.Title, 
		Article: post.Article, 
	} 
  
	result, err := postCollection.InsertOne(ctx, postPayload) 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Posted successfully", "Data": map[string]interface{}{"data": result}}) 
}

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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func ReadOnePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var result model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	err := postCollection.FindOne(ctx, bson.M{"id": objId}).Decode(&result) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "success!", "Data": res}) 
}

The príspevky 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func UpdatePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var post model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	edited := bson.M{"title": post.Title, "article": post.Article} 
  
	result, err := postCollection.UpdateOne(ctx, bson.M{"id": objId}, bson.M{"$set": edited}) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.MatchedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "Data doesn't exist"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "data updated successfully!", "Data": 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func DeletePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	postId := c.Param("postId") 
  
	var postCollection = getcollection.GetCollection(DB, "Posts")  
	defer cancel() 
	objId, _ := primitive.ObjectIDFromHex(postId)  
	result, err := postCollection.DeleteOne(ctx, bson.M{"id": objId})  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.DeletedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "No data to delete"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Article deleted successfully", "Data": 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:

Štruktúra projektu Golang CRUD

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

ako sledovať youtube s priateľmi 
package main 
  
import ( 
    routes "CRUD_API/routes" 
    "github.com/gin-gonic/gin" 
) 
  
func main() { 
    router := gin.Default() 
  
    router.POST("/", routes.CreatePost) 
  
    // called as localhost:3000/getOne/{id} 
    router.GET("getOne/:postId", routes.ReadOnePost) 
  
    // called as localhost:3000/update/{id} 
    router.PUT("/update/:postId", routes.UpdatePost) 
  
    // called as localhost:3000/delete/{id} 
    router.DELETE("/delete/:postId", routes.DeletePost) 
  
    router.Run("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:

go run main.go

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.