Hogyan hozzunk létre CRUD API-t Golang's Gin és MongoDB segítségével

Hogyan hozzunk létre CRUD API-t Golang's Gin és MongoDB segítségével

A Golang az egyik legjobban fizető, igényes programozási nyelv számos alkalmazással. Ha olyan keretrendszerekkel párosítja, mint a Gin, a Revel és a gorilla/mux, könnyen létrehozhat API-t a Go segítségével.





Ismerje meg, hogyan hozhat létre CRUD API-t a Golangban a Gin HTTP keretrendszer használatával.



MAKEUSEOF A NAP VIDEÓJA

Kezdeti beállítás és telepítés

Kezdje el a Golangot telepítse a számítógépére, ha még nem tette meg.





A telepítés után a következő lépés egy projekt gyökérmappája létrehozása a gépen, és a Go modul inicializálása abban a gyökérkönyvtárban.

Ehhez nyissa meg egy CLI , keresse meg a projekt gyökérmappáját, és futtassa:



go mod init module_name

Látni fogja a modul nevét (pl. CRUD_API ) és annak verziója, amikor megnyitja a go.mod fájlt. Minden egyéni csomag ebből a szülőmodulból származik. Tehát minden importált egyedi csomag a következő formában van:

import(package CRUD_API/package-directory-name)

Ezután telepítse a CRUD API létrehozásához szükséges csomagokat. Ebben az esetben használja Gin Gonic az API-végpontok irányításához:



go get github.com/gin-gonic/gin

Most telepítse a MongoDB illesztőprogramot az adatok tárolására:

go get go.mongodb.org/mongo-driver/mongo

Csatlakozás Ugrás a MongoDB-hez

Csak a MongoDB URI-ra van szüksége a Golang és az adatbázis összekapcsolásához. Általában így néz ki, ha helyileg csatlakozik a MongoDB Atlashoz:



miért nem működik az amazon tűzpálcám? 
Mongo_URL = "mongodb://127.0.0.1:27017"

Most hozzon létre egy új mappát a projekt gyökérkönyvtárában, és hívja meg adatbázisok . Hozzon létre egy Go fájlt ebben a mappában, és nevezze el adatbázis.go .

Ez az Ön adatbáziscsomagja, és a szükséges könyvtárak importálásával kezdődik:

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 
}

A legjobb gyakorlat a környezeti változók, például az adatbázis-kapcsolati karakterlánc elrejtése a .env fájlt dotenv csomag használatával . Ez a kódot hordozhatóbbá teszi, és hasznos lehet a MongoDB felhőfürt példány , például.

Az ConnectDB függvény kapcsolatot létesít, és egy új MongoDB Client objektumot ad vissza.

Adatbázis-gyűjtemény létrehozása

A MongoDB gyűjteményekben tárolja az adatokat, amelyek interfészt biztosítanak az alapul szolgáló adatbázisadatokhoz.

A gyűjtemény-lekérési funkció kezeléséhez először hozzon létre egy új mappát, Gyűjtemény , a projekt gyökérben. Most hozzon létre egy új Go fájlt, getCollection.go , amely megkapja a gyűjteményt az adatbázisból:

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 
}

Ez a függvény a gyűjteményt a MongoDB adatbázisból szerzi be. Az adatbázis neve ebben az esetben az myGoappDB , val vel Hozzászólások mint gyűjteménye.

Készítse el az adatbázis-modellt

Hozzon létre egy új mappát a gyökérkönyvtárban, és hívja meg modell . Ez a mappa kezeli az adatbázis-modellt.

Hozzon létre egy új Go fájlt a mappában, és hívja meg model.go . Ebben az esetben az Ön modellje egy blogbejegyzés a következő címmel:

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

CRUD API létrehozása a Go segítségével

A következő lépés a CRUD API létrehozása. Ezzel a szakaszsal kezdésként hozzon létre egy új mappát a projekt gyökérkönyvtárában a végpontok kezelésére. Hívd útvonalak .

Minden egyes művelethez hozzon létre egy külön Go fájlt ebben a mappában. Például elnevezheti őket Create.go , read.go , update.go , és delete.go . Ezeket a kezelőket a következő néven fogja exportálni útvonalak csomag.

A POST végpont létrehozása a Go alkalmazásban

Kezdje a POST végpont meghatározásával az adatok adatbázisba való írásához.

Belül routes/create.go , adja hozzá a következőket:

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}}) 
}

Ez a kód a projekt egyéni moduljainak importálásával kezdődik. Ezután harmadik féltől származó csomagokat importál, beleértve Gin és MongoDB illesztőprogram .

További, postCollection tárolja az adatbázis gyűjteményt. Nevezetesen, c.BindJSON('bejegyzés') egy JSON-modellpéldány, amely minden modellmezőt a következő néven hív meg postPayload ; ez bekerül az adatbázisba.

A GET végpont létrehozása

A GET végpont, in routes/read.go , egyetlen dokumentumot olvas be az adatbázisból annak egyedi azonosítóján keresztül. Egyéni és harmadik féltől származó csomagok importálásával is kezdődik:

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}) 
}

Az hozzászólások változó egy paraméterdeklaráció. A dokumentum objektumazonosítóját mint objId .

Azonban, eredmény az adatbázismodell egy példánya, amely később a visszaadott dokumentumot mint res .

A PUT végpont létrehozása

A PUT kezelő, be routes/update.go , hasonló a POST kezelőhöz. Ezúttal egy meglévő bejegyzést frissít egyedi objektumazonosítójával:

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}) 
}

A modellpéldány JSON formátuma ( hozzászólás ) minden modellmezőt meghív az adatbázisból. Az eredményváltozó a MongoDB-t használja $set operátort, hogy frissítse az objektumazonosítója által megnevezett szükséges dokumentumot.

Az eredmény.MatchedCount feltétel megakadályozza a kód futását, ha nincs rekord az adatbázisban, vagy az átadott azonosító érvénytelen.

DELETE végpont létrehozása

A DELETE végpont, in delete.go , eltávolít egy dokumentumot az URL-paraméterként átadott objektumazonosító alapján:

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}) 
}

Ez a kód törli a rekordot a DeleteOne funkció. Azt is használja a eredmény.DeletedCount tulajdonság, amely megakadályozza a kód lefutását, ha az adatbázis üres vagy az objektumazonosító érvénytelen.

hogyan lehet otthon internetet szerezni

Hozza létre az API Runner fájlt

Végül hozzon létre a fő.go a projekt gyökérkönyvtárában. A végleges projekt felépítése így néz ki:

Golang CRUD projekt felépítése

Ez a fájl kezeli az útválasztó végrehajtását az egyes végpontokhoz:

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") 
}

Ez a fájl a fő csomag, amely más fájlokat futtat. Az útvonalkezelők importálásával kezdődik. Következő a router változó, a gin példány, amely előhívja a HTTP-műveleteket, és minden végpontot a függvénynévvel hív meg a útvonalak csomag.

A CRUD projektje tovább fut localhost:3000 . A szerver futtatásához és tesztelje a CRUD API-t , futtassa a következő parancsot az alapkönyvtárban:

go run main.go

Változtassa Golang CRUD projektjét használható termékké

Sikeresen létrehozott egy CRUD API-t a Go-val; Gratulálunk! Bár ez egy kisebb projekt, már látta, mi kell a szokásos HTTP-kérések végrehajtásához a Go-ban.

Kreatívabbá válhat, ha ezt egy praktikusabb alkalmazássá bővíti, amely értéket biztosít a felhasználók számára. A Go egy megfelelő programozási nyelv számos felhasználási célra.