Cómo crear una API CRUD con Gin y MongoDB de Golang

Golang es uno de los lenguajes de programación más demandados y mejor pagados con muchas aplicaciones. Cuando se combina con marcos como Gin, Revel y gorilla/mux, puede crear fácilmente una API con Go.

Aprenda a crear una API CRUD en Golang utilizando el marco Gin HTTP.

---

---

MAKEUSEOF VÍDEO DEL DÍA

Configuración e instalación inicial

Comience con Golang instalándolo en su computadora si aún no lo ha hecho.

Una vez instalado, el siguiente paso es crear una carpeta raíz del proyecto en su máquina e inicializar un módulo Go en ese directorio raíz.

Para ello, abra una CLI , navegue a la carpeta raíz de su proyecto y ejecute:

go mod init module_name 

Verá el nombre de su módulo (p. ej. CRUD_API ) y su versión al abrir el ir.mod expediente. Todos los paquetes personalizados provendrán de este módulo principal. Entonces, cualquier paquete personalizado importado toma la forma:

import(package CRUD_API/package-directory-name)

A continuación, instale los paquetes necesarios para crear la API CRUD. En este caso, utilice Ginebra Gónica para enrutar los puntos finales de la API:

---

---

go get github.com/gin-gonic/gin 

Ahora instale el controlador MongoDB para almacenar datos:

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

Cómo conectarse Ir a MongoDB

Todo lo que necesita es su URI de MongoDB para conectar Golang con la base de datos. Por lo general, se ve así si se está conectando a MongoDB Atlas localmente:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

Ahora crea una nueva carpeta en el directorio raíz de tu proyecto y llámala bases de datos . Cree un archivo Go dentro de esta carpeta y asígnele un nombre base de datos.ir .

Este es su paquete de base de datos y comienza importando las bibliotecas requeridas:

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 
} 

Es una buena práctica ocultar variables de entorno como la cadena de conexión de la base de datos en un .env expediente usando el paquete dotenv . Esto hace que su código sea más portátil y resulta útil cuando se utiliza un Instancia de clúster en la nube de MongoDB , por ejemplo.

cómo desmontar el controlador de xbox one

los Conectar DB La función establece una conexión y devuelve un nuevo objeto MongoDB Client.

Crear colección de base de datos

MongoDB almacena datos en colecciones, que proporcionan una interfaz para los datos de la base de datos subyacente.

Para manejar la funcionalidad de obtención de colecciones, comience creando una nueva carpeta, Recopilación , en la raíz de su proyecto. Ahora cree un nuevo archivo Go, getCollection.go , que obtiene la colección de la base de datos:

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 
} 

Esta función obtiene la Colección de la base de datos MongoDB. El nombre de la base de datos, en este caso, es miGoappDB , con Publicaciones como su colección.

computadora portátil conectada a wifi pero sin internet

Crear el modelo de base de datos

Cree una nueva carpeta dentro de su directorio raíz y llámela modelo . Esta carpeta maneja su modelo de base de datos.

Cree un nuevo archivo Go dentro de esa carpeta y llámelo modelo.ir . Su modelo, en este caso, es una publicación de blog con su título:

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

Creación de una API CRUD con Go

El siguiente paso es la creación de la API CRUD. Para comenzar con esta sección, cree una nueva carpeta dentro del directorio raíz de su proyecto para manejar sus puntos finales. Llámalo rutas .

Cree un archivo Go separado en esta carpeta para cada acción. Por ejemplo, puedes nombrarlos crear.ir , leer.ir , actualizar.ir , y eliminar.ir . Exportará estos controladores como el rutas paquete.

Cómo crear el punto final POST en Go

Comience definiendo el punto final POST para escribir datos en la base de datos.

En el interior rutas/create.go , agrega lo siguiente:

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

Este código comienza importando los módulos personalizados del proyecto. A continuación, importa paquetes de terceros, incluidos Ginebra y Controlador MongoDB .

Más lejos, postColección contiene la colección de la base de datos. Notablemente, c.BindJSON('publicación') es una instancia de modelo JSONified que llama a cada campo de modelo como postcarga útil ; esto va a la base de datos.

Cómo crear el punto final GET

El punto final GET, en rutas/read.go , lee un solo documento de la base de datos a través de su ID único. También comienza importando paquetes personalizados y de terceros:

¿Puedes enviarle un mensaje a alguien en youtube?

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

los publicaciones variable es una declaración de parámetro. Obtiene el ID de objeto de un documento como objId .

Sin embargo, resultado es una instancia del modelo de base de datos, que luego contiene el documento devuelto como resolución .

Cómo crear el punto final PUT

El controlador PUT, en rutas/update.go , es similar al controlador POST. Esta vez, actualiza una publicación existente por su ID de objeto único:

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 formato JSON de la instancia del modelo ( correo ) llama a cada campo del modelo desde la base de datos. La variable de resultado utiliza MongoDB. $establecer operador para actualizar un documento requerido llamado por su ID de objeto.

los resultado.MatchedCount condición evita que el código se ejecute si no hay ningún registro en la base de datos o si el ID pasado no es válido.

Creación de un punto final DELETE

El extremo DELETE, en eliminar.ir , elimina un documento en función del ID de objeto pasado como parámetro de 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}) 
} 

Este código elimina un registro usando el Eliminar uno función. También utiliza el resultado.DeletedCount propiedad para evitar que el código se ejecute si la base de datos está vacía o el ID del objeto no es válido.

Crear el archivo del ejecutor de la API

Finalmente, crea un principal.ir dentro del directorio raíz de su proyecto. La estructura final de su proyecto debería verse así:

Este archivo maneja la ejecución del enrutador para cada punto 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") 
} 

Este archivo es el paquete principal que ejecuta otros archivos. Comienza importando los controladores de ruta. El siguiente es el enrutador variables, un Ginebra instancia que evoca las acciones HTTP y llama a cada punto final por su nombre de función desde el rutas paquete.

Su proyecto CRUD se ejecuta en anfitrión local: 3000 . Para ejecutar el servidor y probar la API CRUD , ejecute el siguiente comando en su directorio base:

go run main.go

Convierta su proyecto Golang CRUD en un producto utilizable

Ha creado con éxito una API CRUD con Go; ¡Felicidades! Si bien este es un proyecto menor, ha visto lo que se necesita para ejecutar solicitudes HTTP regulares en Go.

Puede ser más creativo expandiendo esto a una aplicación más práctica que brinde valor a los usuarios. Go es un lenguaje de programación adecuado para una variedad de casos de uso.