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.

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:

mergeți 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(pachet CRUD_API/pachet-nume-director)

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

instagram viewer

merge obține github.com/gin-gonic/gin

Acum instalați driverul MongoDB pentru a stoca date:

merge obține 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:

pachet Bază de dateimport (
"context"
"fmt"
"Buturuga"
"timp"
"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. Client nou (opțiuni. Client().ApplyURI(Mongo_URL))
daca greseste != nil {
Buturuga.Fatal(a greșit)
	}
ctx, anulați := context. WithTimeout (context. Fundal(), 10 * timp. Al doilea)
	err = client. Conectare (ctx)
	amână anularea ()
daca greseste != nil {
Buturuga.Fatal(a greșit)
	}fmt. Println("Conectat la mongoDB")
întoarcere 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:

pachet obține colectareimport (
"go.mongodb.org/mongo-driver/mongo"
)funcGetCollection(client *mongo.Client, collectionNameşir) *mongo.Colectie {
	colectare := client. Bază de date("myGoappDB").Colectie("Postări")
întoarcere Colectie
}

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.

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:

pachet modelimport (
"go.mongodb.org/mongo-driver/bson/primitive"
)tip Post struct {
IDprimitiv.ObjectID
	Șir de titlu
	Șir de articol
}

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:

pachet traseeimport (
	obține colectare "CRUD_API/Colecție"
	Bază de date "CRUD_API/baze de date"
	model "CRUD_API/model"
"context"
"Buturuga"
"net/http"
"timp"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func CreatePost(c *gin. Context){
var DB = baza de date. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postări")
	ctx, anulați := context. WithTimeout (context. Fundal(), 10* timp. Al doilea)
	postare := nou(model. postări)
	amână anularea ()
dacă greșește := c. BindJSON(&post); err != nil {
 c. JSON(http. StatusBadRequest, gin. H{"mesaj": greșit})
Buturuga.Fatal(a greșit)
întoarcere
	}
postPayload := model. Postări{
Id: primitiv.NewObjectID(),
Titlu: post.Titlu,
Articol: post.Articol,
	}
rezultat, err := postCollection. InsertOne (ctx, postPayload)
daca greseste != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": greșit})
întoarcere
	}c. JSON(http. StatusCreated, gin. H{"mesaj": "Postat cu succes", "Date": hartă[șir]interfață{}{"date": rezultat}})
}

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(„postare”) 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:

pachet traseeimport (
	obține colectare "CRUD_API/Colecție"
	Bază de date "CRUD_API/baze de date"
	model "CRUD_API/model"
"context"
"net/http"
"timp"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func ReadOnePost(c *gin. Context){
	ctx, anulați := context. WithTimeout (context. Fundal(), 10* timp. Al doilea)
var DB = baza de date. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postări")
ID post:= c. Param("postId")
var model de rezultat. Postări
amână anularea ()
objId, _ := primitiv. ObjectIDFromHex (postId)
err := postColection. FindOne (ctx, bson. M{"id": objId}).Decode(&rezultat)
res := hartă[șir]interfata{}{"date": rezultat}
daca greseste != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": greșit})
întoarcere
	}c. JSON(http. StatusCreated, gin. H{"mesaj": "succes!", "Date": res})
}

The postId 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:

pachet traseeimport (
	obține colectare "CRUD_API/Colecție"
	Bază de date "CRUD_API/baze de date"
	model "CRUD_API/model"
"context"
"net/http"
"timp"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func UpdatePost(c *gin. Context){
	ctx, anulați := context. WithTimeout (context. Fundal(), 10 * timp. Al doilea)
var DB = baza de date. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postări")
ID post:= c. Param("postId")
var post model. Postări
amână anularea ()
objId, _ := primitiv. ObjectIDFromHex (postId)
dacă greșește := c. BindJSON(&post); err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": greșit})
întoarcere
	}
editat := bson. M{"titlu": post. Titlu, "articol": post. Articol}
rezultat, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": editat})
res := hartă[șir]interfata{}{"date": rezultat}
daca greseste != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": greșit})
întoarcere
	}
dacă rezultat. Număr potrivit < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": "Datele nu't exista"})
întoarcere
	}c. JSON(http. StatusCreated, gin. H{"mesaj": "date actualizate cu succes!", "Date": 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. Număr potrivit 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:

pachet traseeimport (
	obține colectare "CRUD_API/Colecție"
	Bază de date "CRUD_API/baze de date"
"context"
"net/http"
"timp"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func Ștergeți postarea(c *gin. Context){
	ctx, anulați := context. WithTimeout (context. Fundal(), 10* timp. Al doilea)
var DB = baza de date. ConnectDB()
	ID post:= c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Postări") 
	amână anularea ()
	objId, _ := primitiv. ObjectIDFromHex (postId) 
	rezultat, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := hartă[șir]interfata{}{"date": rezultat}
daca greseste != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": greșit})
întoarcere
	}
dacă rezultat. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"mesaj": "Nu există date de șters"})
întoarcere
	}c. JSON(http. StatusCreated, gin. H{"mesaj": "Articolul a fost șters cu succes", "Date": 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:

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

pachet principalimport (
 trasee "CRUD_API/rute"
"github.com/gin-gonic/gin"
)
func principal(){
 router := gin.Mod implicit()
router. POST("/", trasee. CreatePost)
// numit ca localhost: 3000/getOne/{id}
 router. OBȚINE("getOne/:postId", trasee. ReadOnePost)
// numit ca localhost: 3000/Actualizați/{id}
 router. A PUNE("/update/:postId", trasee. UpdatePost)
// numit ca localhost: 3000/șterge/{id}
 router. ȘTERGE("/șterge/:postId", rute. Ștergeți postarea)router. Alerga("gazdă locală: 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ă gazdă locală: 3000. Pentru a rula serverul și testați API-ul CRUD, rulați următoarea comandă în directorul de bază:

mergealergaprincipal.merge

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.

About Technology - denizatm.com