Jak vytvořit CRUD API s Golang's Gin a MongoDB

Jak vytvořit CRUD API s Golang's Gin a MongoDB

Golang je jedním z nejlépe platících programovacích jazyků s mnoha aplikacemi. Při spárování s frameworky jako Gin, Revel a gorilla/mux můžete snadno vytvořit API s Go.





Naučte se, jak vytvořit CRUD API v Golangu pomocí Gin HTTP frameworku.



VYUŽÍVÁNÍ VIDEA DNE

Počáteční nastavení a instalace

Začněte s Golangem instalací do počítače, pokud jste tak ještě neučinili.





Po instalaci je dalším krokem vytvoření kořenové složky projektu na vašem počítači a inicializace modulu Go v tomto kořenovém adresáři.

Chcete-li to provést, otevřete CLI , přejděte do kořenové složky projektu a spusťte:



go mod init module_name

Uvidíte název modulu (např. CRUD_API ) a jeho verzi, když otevřete soubor go.mod soubor. Všechny vlastní balíčky pocházejí z tohoto nadřazeného modulu. Jakýkoli importovaný vlastní balíček má tedy podobu:

import(package CRUD_API/package-directory-name)

Dále nainstalujte balíčky potřebné pro vytvoření CRUD API. V tomto případě použijte Gin Gonic pro směrování koncových bodů API:



go get github.com/gin-gonic/gin

Nyní nainstalujte ovladač MongoDB pro ukládání dat:

můžete upgradovat macbook pro ram 
go get go.mongodb.org/mongo-driver/mongo

Jak se připojit Přejděte na MongoDB

Vše, co potřebujete, je vaše MongoDB URI pro připojení Golangu k databázi. Obvykle to vypadá takto, pokud se připojujete k MongoDB Atlas lokálně:



Mongo_URL = "mongodb://127.0.0.1:27017"

Nyní vytvořte novou složku v kořenovém adresáři projektu a zavolejte ji databází . V této složce vytvořte soubor Go a pojmenujte jej databáze.go .

Toto je váš databázový balíček a začíná importem požadovaných knihoven:

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 
}

Nejlepším postupem je skrýt proměnné prostředí, jako je připojovací řetězec databáze v a .env soubor pomocí balíčku dotenv . Díky tomu je váš kód přenosnější a hodí se při použití a Instance cloudového clusteru MongoDB , například.

The ConnectDB funkce naváže připojení a vrátí nový objekt MongoDB Client.

Vytvořit kolekci databáze

MongoDB ukládá data do kolekcí, které poskytují rozhraní k podkladovým databázovým datům.

Chcete-li zvládnout funkci načítání kolekce, začněte vytvořením nové složky, Sbírka , v kořenovém adresáři vašeho projektu. Nyní vytvořte nový soubor Go, getCollection.go , který získá kolekci z databáze:

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 
}

Tato funkce získá kolekci z databáze MongoDB. Název databáze je v tomto případě myGoappDB , s Příspěvky jako jeho sbírka.

Vytvořte databázový model

Vytvořte novou složku v kořenovém adresáři a zavolejte ji Modelka . Tato složka zpracovává váš databázový model.

Vytvořte v této složce nový soubor Go a zavolejte jej model.go . Váš model je v tomto případě blogový příspěvek s názvem:

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

Vytvoření CRUD API s Go

Další na řadě je vytvoření CRUD API. Chcete-li začít s touto částí, vytvořte v kořenovém adresáři projektu novou složku, která bude spravovat vaše koncové body. Zavolej tomu trasy .

Pro každou akci vytvořte v této složce samostatný soubor Go. Můžete je například pojmenovat create.go , read.go , update.go , a delete.go . Tyto obslužné nástroje exportujete jako trasy balík.

Jak vytvořit koncový bod POST v Go

Začněte definováním koncového bodu POST pro zápis dat do databáze.

Uvnitř routes/create.go , přidejte následující:

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číná importem vlastních modulů projektu. Poté importuje balíčky třetích stran včetně Gin a Ovladač MongoDB .

Dále, postCollection uchovává kolekci databáze. Zejména, c.BindJSON('příspěvek') je instance modelu JSONified, která nazývá každé pole modelu jako postPayload ; to jde do databáze.

Jak vytvořit koncový bod GET

Koncový bod GET, in routes/read.go , čte jeden dokument z databáze prostřednictvím jeho jedinečného ID. Začíná to také importem vlastních balíčků a balíčků třetích stran:

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 příspěvky proměnná je deklarace parametru. Získá ID objektu dokumentu jako objId .

Nicméně, výsledek je instancí databázového modelu, který později obsahuje vrácený dokument jako res .

Jak vytvořit koncový bod PUT

Obslužný program PUT, in routes/update.go , je podobný obslužné rutině POST. Tentokrát aktualizuje existující příspěvek 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 instance modelu ( pošta ) volá každé pole modelu z databáze. Proměnná result používá MongoDB $set k aktualizaci požadovaného dokumentu volaného jeho ID objektu.

The result.MatchedCount podmínka zabrání spuštění kódu, pokud v databázi není žádný záznam nebo je předané ID neplatné.

Vytvoření koncového bodu DELETE

Koncový bod DELETE, in delete.go , odstraní dokument na základě ID objektu předaného jako parametr 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 odstraní záznam pomocí DeleteOne funkce. Používá také result.DeletedCount vlastnost, která zabrání spuštění kódu, pokud je databáze prázdná nebo ID objektu je neplatné.

Vytvořte soubor API Runner

Nakonec vytvořte a main.go v kořenovém adresáři vašeho projektu. Konečná struktura vašeho projektu by měla vypadat takto:

Struktura projektu Golang CRUD

Tento soubor zpracovává spuštění routeru pro každý koncový bod:

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 soubor je hlavním balíčkem, který spouští další soubory. Začíná to importem obslužných programů trasy. Další je router proměnná, a gin instance, která vyvolává akce HTTP a volá každý koncový bod podle názvu funkce z trasy balík.

Váš projekt CRUD běží dál localhost: 3000 . Chcete-li spustit server a otestujte CRUD API , spusťte ve svém základním adresáři následující příkaz:

go run main.go

Proměňte svůj projekt Golang CRUD na použitelný produkt

Úspěšně jste vytvořili CRUD API s Go; Gratulujeme! I když se jedná o menší projekt, viděli jste, co je potřeba k provádění běžných požadavků HTTP v Go.

Můžete být kreativnější, když to rozšíříte do praktičtější aplikace, která uživatelům přináší hodnotu. Go je vhodný programovací jazyk pro řadu případů použití.