Comment créer une API CRUD avec Gin et MongoDB de Golang

Golang est l'un des langages de programmation les plus rémunérateurs et les plus demandés avec de nombreuses applications. Lorsqu'il est associé à des frameworks tels que Gin, Revel et gorilla/mux, vous pouvez facilement créer une API avec Go.

Apprenez à créer une API CRUD dans Golang à l'aide du framework HTTP Gin.

---

---

UTILISEZ LA VIDÉO DU JOUR

Configuration et installation initiales

Démarrer avec Golang en l'installant sur votre ordinateur si vous ne l'avez pas déjà fait.

Une fois installé, l'étape suivante consiste à créer un dossier racine de projet sur votre machine et à initialiser un module Go dans ce répertoire racine.

Pour ce faire, ouvrez une CLI , accédez au dossier racine de votre projet et exécutez :

go mod init module_name 

Vous verrez le nom de votre module (par ex. CRUD_API ) et sa version lorsque vous ouvrez le aller.mod dossier. Tous les packages personnalisés proviendront de ce module parent. Ainsi, tout package personnalisé importé prend la forme :

comment ajouter quelqu'un à whatsapp

import(package CRUD_API/package-directory-name)

Ensuite, installez les packages nécessaires à la création de l'API CRUD. Dans ce cas, utilisez Gin Gonic pour router les points de terminaison de l'API :

---

---

go get github.com/gin-gonic/gin 

Installez maintenant le pilote MongoDB pour stocker les données :

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

Comment se connecter Aller à MongoDB

Tout ce dont vous avez besoin est votre URI MongoDB pour connecter Golang à la base de données. Cela ressemble généralement à ceci si vous vous connectez localement à MongoDB Atlas :

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

Créez maintenant un nouveau dossier dans le répertoire racine de votre projet et appelez-le bases de données . Créez un fichier Go dans ce dossier et nommez-le base de données.go .

Il s'agit de votre package de base de données, et il commence par importer les bibliothèques requises :

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 
} 

Il est recommandé de masquer les variables d'environnement telles que la chaîne de connexion à la base de données dans un .env dossier en utilisant le paquet dotenv . Cela rend votre code plus portable et est pratique lorsque vous utilisez un Instance de cluster cloud MongoDB , par exemple.

La ConnectDB La fonction établit une connexion et renvoie un nouvel objet client MongoDB.

Créer une collection de base de données

MongoDB stocke les données dans des collections, qui fournissent une interface avec les données de base de données sous-jacentes.

Pour gérer la fonctionnalité de récupération de collection, commencez par créer un nouveau dossier, Le recueil , à la racine de votre projet. Créez maintenant un nouveau fichier Go, getCollection.go , qui récupère la collection de la base de données :

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 
} 

Cette fonction obtient la collection de la base de données MongoDB. Le nom de la base de données, dans ce cas, est myGoappDB , avec Des postes comme sa collection.

Créer le modèle de base de données

Créez un nouveau dossier dans votre répertoire racine et appelez-le maquette . Ce dossier gère votre modèle de base de données.

Créez un nouveau fichier Go dans ce dossier et appelez-le modèle.go . Votre modèle, dans ce cas, est un article de blog avec son titre :

comment coupler une télécommande apple tv

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

Créer une API CRUD avec Go

La prochaine étape est la création de l'API CRUD. Pour commencer avec cette section, créez un nouveau dossier dans le répertoire racine de votre projet pour gérer vos points de terminaison. Appeler itinéraires .

Créez un fichier Go distinct dans ce dossier pour chaque action. Par exemple, vous pouvez les nommer créer.go , lire.aller , mise à jour.go , et supprimer.go . Vous exporterez ces gestionnaires en tant que itinéraires forfait.

Comment créer le point de terminaison POST dans Go

Commencez par définir le point de terminaison POST pour écrire des données dans la base de données.

À l'intérieur routes/create.go , ajoutez ce qui suit :

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

Ce code commence par importer les modules personnalisés du projet. Il importe ensuite des packages tiers, y compris Gin et Pilote MongoDB .

Plus loin, postCollection contient la collection de la base de données. Notamment, c.BindJSON('post') est une instance de modèle JSONifiée qui appelle chaque champ de modèle en tant que postPayload ; cela va dans la base de données.

Comment créer le point de terminaison GET

Le point de terminaison GET, dans itinéraires/lire.aller , lit un seul document de la base de données via son ID unique. Il commence également par importer des packages personnalisés et tiers :

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

La des postes variable est une déclaration de paramètre. Il obtient l'ID d'objet d'un document comme objId .

Cependant, résultat est une instance du modèle de base de données, qui contient ultérieurement le document renvoyé en tant que res .

Comment créer le point de terminaison PUT

Le gestionnaire PUT, dans routes/update.go , est similaire au gestionnaire POST. Cette fois, il met à jour une publication existante par son ID d'objet unique :

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 l'instance de modèle ( Publier ) appelle chaque champ de modèle à partir de la base de données. La variable de résultat utilise MongoDB $ ensemble opérateur pour mettre à jour un document requis appelé par son ID d'objet.

La result.MatchedCount La condition empêche l'exécution du code s'il n'y a pas d'enregistrement dans la base de données ou si l'ID transmis n'est pas valide.

Création d'un point de terminaison SUPPRIMER

Le point de terminaison DELETE, dans supprimer.go , supprime un document en fonction de l'ID d'objet passé en paramètre 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}) 
} 

Ce code supprime un enregistrement à l'aide de la SupprimerUn fonction. Il utilise également le result.DeletedCount propriété pour empêcher l'exécution du code si la base de données est vide ou si l'ID d'objet n'est pas valide.

Créer le fichier d'exécution d'API

Enfin, créez un main.go dans le répertoire racine de votre projet. La structure de votre projet final devrait ressembler à ceci :

Ce fichier gère l'exécution du routeur pour chaque point de terminaison :

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

Ce fichier est le package principal qui exécute d'autres fichiers. Il commence par importer les gestionnaires de route. Vient ensuite le routeur variable, une Gin instance qui évoque les actions HTTP et appelle chaque point de terminaison par son nom de fonction à partir du itinéraires forfait.

Votre projet CRUD s'exécute sur hôte local : 3000 . Pour exécuter le serveur et tester l'API CRUD , exécutez la commande suivante dans votre répertoire de base :

Windows n'a pas pu détecter les paramètres proxy de ce réseau

go run main.go

Transformez votre projet Golang CRUD en un produit utilisable

Vous avez créé avec succès une API CRUD avec Go ; toutes nos félicitations! Bien qu'il s'agisse d'un projet mineur, vous avez vu ce qu'il faut pour exécuter des requêtes HTTP régulières dans Go.

Vous pouvez faire preuve de plus de créativité en développant cette application dans une application plus pratique qui offre de la valeur aux utilisateurs. Go est un langage de programmation adapté à une gamme de cas d'utilisation.