Com crear una API CRUD amb Golang's Gin i MongoDB

Golang és un dels llenguatges de programació més demandats i que paga més amb moltes aplicacions. Quan es combina amb marcs com Gin, Revel i gorilla/mux, podeu crear fàcilment una API amb Go.

Apreneu a crear una API CRUD a Golang mitjançant el marc HTTP Gin.

---

---

MAKEUSEO VÍDEO DEL DIA

Configuració i instal·lació inicial

Comença amb Golang instal·lant-lo al vostre ordinador si encara no ho heu fet.

no es pot veure el disc dur extern

Un cop instal·lat, el següent pas és crear una carpeta arrel del projecte a la vostra màquina i inicialitzar un mòdul Go en aquest directori arrel.

Per fer-ho, obriu una CLI , navegueu a la carpeta arrel del vostre projecte i executeu:

go mod init module_name 

Veureu el nom del vostre mòdul (p. ex. CRUD_API ) i la seva versió quan obriu el fitxer anar.mod dossier. Tots els paquets personalitzats vindran d'aquest mòdul principal. Així, qualsevol paquet personalitzat importat pren la forma:

import(package CRUD_API/package-directory-name)

A continuació, instal·leu els paquets necessaris per crear l'API CRUD. En aquest cas, utilitzeu Gin Gonic per encaminar els punts finals de l'API:

---

---

go get github.com/gin-gonic/gin 

Ara instal·leu el controlador MongoDB per emmagatzemar dades:

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

Com connectar-se Aneu a MongoDB

Tot el que necessiteu és el vostre URI de MongoDB per connectar Golang amb la base de dades. Normalment es veu així si us connecteu a MongoDB Atlas localment:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

Ara creeu una nova carpeta al directori arrel del vostre projecte i crideu-la bases de dades . Creeu un fitxer Go dins d'aquesta carpeta i poseu-li un nom base de dades.go .

Aquest és el vostre paquet de base de dades i comença important les biblioteques necessàries:

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 
} 

La millor pràctica és amagar variables d'entorn com la cadena de connexió de la base de dades en a .env dossier utilitzant el paquet dotenv . Això fa que el vostre codi sigui més portàtil i us sigui útil quan feu servir un Instància del clúster al núvol de MongoDB , per exemple.

El ConnectDB La funció estableix una connexió i retorna un nou objecte MongoDB Client.

Crear una col·lecció de bases de dades

MongoDB emmagatzema dades a Col·leccions, que proporcionen una interfície per a les dades de la base de dades subjacents.

Per gestionar la funcionalitat d'obtenció de col·leccions, comenceu creant una carpeta nova, Col · lecció , a l'arrel del vostre projecte. Ara creeu un nou fitxer Go, getCollection.go , que obté la col·lecció de la base de dades:

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 
} 

Aquesta funció obté la col·lecció de la base de dades MongoDB. El nom de la base de dades, en aquest cas, és myGoappDB , amb Publicacions com la seva col·lecció.

Crear el model de base de dades

Feu una nova carpeta dins del vostre directori arrel i truqueu-la model . Aquesta carpeta gestiona el vostre model de base de dades.

Creeu un fitxer Go nou dins d'aquesta carpeta i crideu-lo model.go . El vostre model, en aquest cas, és una entrada de blog amb el seu títol:

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

Creació d'una API CRUD amb Go

El següent és la creació de l'API CRUD. Per començar amb aquesta secció, creeu una nova carpeta dins del directori arrel del vostre projecte per gestionar els vostres punts finals. Anomena-ho rutes .

com fer captures de pantalla a Snapchat sense que ho sàpiguen

Creeu un fitxer Go separat en aquesta carpeta per a cada acció. Per exemple, podeu anomenar-los crear.go , llegir.va , update.go , i suprimir.go . Exportareu aquests controladors com a rutes paquet.

Com crear el punt final POST a Go

Comenceu definint el punt final POST per escriure dades a la base de dades.

Dins rutes/crear.go , afegiu el següent:

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

Aquest codi comença important els mòduls personalitzats del projecte. A continuació, importa paquets de tercers inclosos Ginebra i Controlador MongoDB .

Més lluny, postCol·lecció conté la col·lecció de la base de dades. En particular, c.BindJSON('publicació') és una instància de model JSONificada que crida a cada camp de model com a postPayload ; això entra a la base de dades.

Com crear el punt final GET

El punt final GET, a rutes/llegir.go , llegeix un sol document de la base de dades mitjançant el seu identificador únic. També comença important paquets personalitzats i de tercers:

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

El publicacions variable és una declaració de paràmetre. Obté l'ID d'objecte d'un document com a objId .

Malgrat això, resultat és una instància del model de base de dades, que posteriorment conté el document retornat com a res .

Com crear el punt final PUT

El gestor PUT, en routes/update.go , és similar al controlador POST. Aquesta vegada, actualitza una publicació existent pel seu ID d'objecte únic:

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 de la instància del model ( publicació ) crida a cada camp del model de la base de dades. La variable de resultat utilitza MongoDB $conjunt operador per actualitzar un document requerit anomenat pel seu ID d'objecte.

El resultat.MatchedCount La condició impedeix que el codi s'executi si no hi ha cap registre a la base de dades o si l'identificador passat no és vàlid.

Creació d'un punt final DELETE

El punt final DELETE, a suprimir.go , elimina un document basat en l'ID d'objecte passat com a paràmetre d'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}) 
} 

Aquest codi suprimeix un registre mitjançant el DeleteOne funció. També utilitza el resultat.Recompte suprimit propietat per evitar que el codi s'executi si la base de dades està buida o l'ID de l'objecte no és vàlid.

Creeu el fitxer API Runner

Finalment, crea un main.go dins del directori arrel del vostre projecte. L'estructura del vostre projecte final hauria de ser així:

com fer un so original a tiktok

Aquest fitxer gestiona l'execució de l'encaminador per a cada punt final:

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

Aquest fitxer és el paquet principal que executa altres fitxers. Comença important els gestors de rutes. El següent és el encaminador variable, a ginebra instància que evoca les accions HTTP i crida a cada punt final pel seu nom de funció des de rutes paquet.

El vostre projecte CRUD continua host local: 3000 . Per executar el servidor i prova l'API CRUD , executeu l'ordre següent al vostre directori base:

go run main.go

Converteix el teu projecte Golang CRUD en un producte utilitzable

Heu creat correctament una API CRUD amb Go; felicitats! Tot i que es tracta d'un projecte menor, heu vist què es necessita per executar sol·licituds HTTP habituals a Go.

Podeu ser més creatius ampliant-ho a una aplicació més pràctica que ofereixi valor als usuaris. Go és un llenguatge de programació adequat per a una varietat de casos d'ús.