Cum se creează un API CRUD cu Gin Golang și MongoDB

Cum se creează un API CRUD cu Gin Golang și MongoDB

Golang este unul dintre limbajele de programare cele mai bine plătite, la cerere, cu multe aplicații. Când sunt asociate cu cadre precum Gin, Revel și gorilla/mux, puteți crea cu ușurință un API cu Go.





Aflați cum să creați un API CRUD în Golang folosind cadrul Gin HTTP.



REALIZAREA VIDEOCLIPULUI ZILEI

Configurare și instalare inițială

Începeți cu Golang instalându-l pe computer dacă nu ați făcut-o deja.





Odată instalat, următorul pas este să creați un folder rădăcină de proiect pe mașina dvs. și să inițializați un modul Go în acel director rădăcină.

Pentru a face acest lucru, deschideți un CLI , navigați la folderul rădăcină al proiectului și rulați:



go mod init module_name

Veți vedea numele modulului dvs. (de ex. CRUD_API ) și versiunea acesteia când deschideți du-te.mod fişier. Toate pachetele personalizate vor veni din acest modul părinte. Deci, orice pachet personalizat importat ia forma:

import(package CRUD_API/package-directory-name)

Apoi, instalați pachetele necesare pentru crearea API-ului CRUD. În acest caz, utilizați Gin Gonic pentru a ruta punctele finale API:



go get github.com/gin-gonic/gin

Acum instalați driverul MongoDB pentru a stoca date:

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

Cum să vă conectați Accesați MongoDB

Tot ce aveți nevoie este URI-ul dvs. MongoDB pentru a conecta Golang la baza de date. De obicei, arată astfel dacă vă conectați la MongoDB Atlas local:



Mongo_URL = "mongodb://127.0.0.1:27017"

Acum creați un nou folder în directorul rădăcină al proiectului și apelați-l baze de date . Creați un fișier Go în interiorul acestui folder și denumiți-l baza de date.go .

Acesta este pachetul dvs. de baze de date și începe prin a importa bibliotecile necesare:

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 
}

Este cea mai bună practică să ascundeți variabilele de mediu, cum ar fi șirul de conexiune la baza de date în a .env fişier folosind pachetul dotenv . Acest lucru face codul dvs. mai portabil și este util atunci când utilizați un Instanță de cluster în cloud MongoDB , de exemplu.

The ConnectDB funcția stabilește o conexiune și returnează un nou obiect MongoDB Client.

Creați o colecție de baze de date

MongoDB stochează date în Colecții, care oferă o interfață cu datele de bază ale bazei de date.

Pentru a gestiona funcționalitatea de preluare a colecțiilor, începeți prin a crea un folder nou, Colectie , în rădăcina proiectului dvs. Acum creați un nou fișier Go, getCollection.go , care primește colecția din baza de date:

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 
}

Această funcție primește colecția din baza de date MongoDB. Numele bazei de date, în acest caz, este myGoappDB , cu Postări ca colecția sa.

Creați modelul bazei de date

Faceți un folder nou în directorul rădăcină și apelați-l model . Acest folder se ocupă de modelul bazei de date.

pot să joc jocurile mele ps3 pe ps4

Creați un nou fișier Go în acel folder și apelați-l model.go . Modelul dvs., în acest caz, este o postare pe blog cu titlul său:

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

Crearea unui API CRUD cu Go

Următorul este crearea API-ului CRUD. Pentru a începe cu această secțiune, creați un nou folder în directorul rădăcină al proiectului pentru a vă gestiona punctele finale. Sună-l trasee .

Creați un fișier Go separat în acest folder pentru fiecare acțiune. De exemplu, le puteți numi crea.du-te , citește.du-te , update.go , și şterge.du-te . Veți exporta acești handlere ca trasee pachet.

Cum se creează punctul final POST în Go

Începeți prin a defini punctul final POST pentru a scrie date în baza de date.

Interior rute/create.go , adăugați următoarele:

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

Acest cod începe prin importul modulelor personalizate ale proiectului. Apoi importă pachete terță parte, inclusiv Gin și Driver MongoDB .

Mai departe, postColecție deține colecția bazei de date. În special, c.BindJSON ('post') este o instanță de model JSONificată care apelează fiecare câmp de model ca postPayload ; aceasta intră în baza de date.

Cum se creează punctul final GET

Punctul final GET, în trasee/citește.go , citește un singur document din baza de date prin ID-ul său unic. De asemenea, începe prin a importa pachete personalizate și terțe:

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 postări variabila este o declarație de parametru. Primește ID-ul obiectului unui document ca objId .

In orice caz, rezultat este o instanță a modelului bazei de date, care mai târziu deține documentul returnat ca res .

Cum se creează punctul final PUT

Managerul PUT, în rute/update.go , este similar cu handlerul POST. De data aceasta, actualizează o postare existentă după ID-ul său unic al obiectului:

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

Un format JSON al instanței model ( post ) apelează fiecare câmp de model din baza de date. Variabila rezultat folosește MongoDB $set operator pentru a actualiza un document solicitat numit prin ID-ul obiectului său.

The rezultat.MatchedCount condiția împiedică rularea codului dacă nu există nicio înregistrare în baza de date sau ID-ul transmis este invalid.

Crearea unui punct final DELETE

Punctul final DELETE, în şterge.du-te , elimină un document pe baza ID-ului obiectului transmis ca parametru 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}) 
}

Acest cod șterge o înregistrare folosind DeleteOne funcţie. De asemenea, folosește rezultat.DeletedCount proprietate pentru a preveni rularea codului dacă baza de date este goală sau ID-ul obiectului este invalid.

Creați fișierul API Runner

În cele din urmă, creați un principal.go în directorul rădăcină al proiectului. Structura finală a proiectului ar trebui să arate astfel:

Structura proiectului Golang CRUD

Acest fișier se ocupă de execuția routerului pentru fiecare punct final:

cum să mutați paginile în cuvânt 
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") 
}

Acest fișier este pachetul principal care rulează alte fișiere. Începe prin a importa gestionatorii de rute. Următorul este router variabilă, a gin instanță care evocă acțiunile HTTP și apelează fiecare punct final prin numele funcției sale din trasee pachet.

Proiectul dumneavoastră CRUD continuă localhost: 3000 . Pentru a rula serverul și testați API-ul CRUD , rulați următoarea comandă în directorul de bază:

go run main.go

Transformați-vă proiectul Golang CRUD într-un produs utilizabil

Ați creat cu succes un API CRUD cu Go; Felicitări! Deși acesta este un proiect minor, ați văzut ce este nevoie pentru a executa solicitări HTTP obișnuite în Go.

Puteți deveni mai creativ extinzând acest lucru într-o aplicație mai practică, care oferă valoare utilizatorilor. Go este un limbaj de programare potrivit pentru o serie de cazuri de utilizare.