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.

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 :

importer(forfait CRUD_API/forfait-nom-répertoire)

Ensuite, installez les packages nécessaires à la création de l'API CRUD. Dans ce cas, utilisez

instagram viewer
Gin Gonic pour router les points de terminaison de l'API :

aller obtenir github.com/gin-gonic/gin

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

aller obtenir 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 :

forfait base de données
importer (
"le contexte"
"fmt"
"Journal"
"temps"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


fonction ConnectDB() *mongo. Client {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	client, euh := mongo. NouveauClient (options. Client().ApplyURI(Mongo_URL))


si err != néant {
Journal.Mortel(se tromper)
	}


ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 10 * temps. Deuxième)
	erreur = client. Connecter (ctx)
	reporter l'annulation()


si err != néant {
Journal.Mortel(se tromper)
	}
fmt. Imprimerln("Connecté à mongoDB")
revenir 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 :

forfait obtenircollection
importer (
"go.mongodb.org/mongo-driver/mongo"
)
fonctionObtenirCollection(client *Mongo.Client, collectionNamechaîne de caractères) *Mongo.Le recueil {
	collecte := client. Base de données("myGoappDB").Le recueil("Des postes")
revenir le recueil
}

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 :

forfait maquette
importer (
"go.mongodb.org/mongo-driver/bson/primitive"
)
taper Structure de poste {
IDENTIFIANTprimitif.ObjectID
	Chaîne de titre
	Chaîne d'articles
}

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 :

forfait itinéraires
importer (
	obtenircollection "CRUD_API/Collection"
	base de données "CRUD_API/bases de données"
	maquette "CRUD_API/modèle"
"le contexte"
"Journal"
"réseau/http"
"temps"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


fonction CréerPost(c*gin. Le contexte){
var BD = base de données. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Des postes")
	ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 10*temps. Deuxième)
	poste := Nouveau(maquette. Des postes)
	reporter l'annulation()


si erreur := c. BindJSON(&Publier); erreur != néant {
 c. JSON(http. StatusBadRequest, gin. H{"message": euh})
Journal.Mortel(se tromper)
revenir
	}


postPayload := modèle. Des postes{
Identifiant: primitif.NewObjectID(),
Titre: Publier.Titre,
Article: Publier.Article,
	}


résultat, err := postCollection. InsertOne (ctx, postPayload)


si err != néant {
 c. JSON(http. StatusInternalServerError, gin. H{"message": euh})
revenir
	}
c. JSON(http. StatutCréé, gin. H{"message": "Posté avec succès", "Données": carte[chaîne]interface{}{"Les données": résultat}})
}

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 :

forfait itinéraires
importer (
	obtenircollection "CRUD_API/Collection"
	base de données "CRUD_API/bases de données"
	maquette "CRUD_API/modèle"
"le contexte"
"réseau/http"
"temps"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


fonction LireUnPost(c*gin. Le contexte){
	ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 10*temps. Deuxième)
var BD = base de données. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Des postes")


identifiant de poste := c. Param("identifiant de poste")
var modèle de résultat. Des postes


reporter l'annulation()


objId, _ := primitive. ObjectIDFromHex (postId)


erreur := postCollection. FindOne (ctx, bson. M{"identifiant": objId}).Décoder(&résultat)


res := carte[chaîne]interface{}{"data": résultat}


si err != néant {
 c. JSON(http. StatusInternalServerError, gin. H{"message": euh})
revenir
	}
c. JSON(http. StatutCréé, gin. H{"message": "Succès!", "Données": res})
}

La identifiant de poste 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 :

forfait itinéraires
importer (
	obtenircollection "CRUD_API/Collection"
	base de données "CRUD_API/bases de données"
	maquette "CRUD_API/modèle"
"le contexte"
"réseau/http"
"temps"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


fonction Mettre à jourPost(c*gin. Le contexte){
	ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 10 * temps. Deuxième)
var BD = base de données. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Des postes")


identifiant de poste := c. Param("identifiant de poste")
var modèle de poste. Des postes


reporter l'annulation()


objId, _ := primitive. ObjectIDFromHex (postId)


si erreur := c. BindJSON(&Publier); erreur != néant {
 c. JSON(http. StatusInternalServerError, gin. H{"message": euh})
revenir
	}


édité := bson. M{"Titre": Publier. Titre, "article": Publier. Article}


résultat, err := postCollection. UpdateOne (ctx, bson. M{"identifiant": objId}, bson. M{"$ ensemble": édité})


res := carte[chaîne]interface{}{"data": résultat}


si err != néant {
 c. JSON(http. StatusInternalServerError, gin. H{"message": euh})
revenir
	}


si résultat. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"message": "Les données ne'ça n'existe pas"})
revenir
	}
c. JSON(http. StatutCréé, gin. H{"message": "données mises à jour avec succès !", "Données": 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 résultat. 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 :

forfait itinéraires
importer (
	obtenircollection "CRUD_API/Collection"
	base de données "CRUD_API/bases de données"
"le contexte"
"réseau/http"
"temps"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


fonction Supprimer le message(c*gin. Le contexte){
	ctx, annuler := contexte. AvecTimeout (context. Arrière-plan(), 10*temps. Deuxième)
var BD = base de données. ConnectDB()
	identifiant de poste := c. Param("identifiant de poste")


var postCollection = getcollection. GetCollection (DB, "Des postes") 
	reporter l'annulation()
	objId, _ := primitive. ObjectIDFromHex (postId) 
	résultat, err := postCollection. DeleteOne (ctx, bson. M{"identifiant": objId}) 
	res := carte[chaîne]interface{}{"data": résultat}


si err != néant {
 c. JSON(http. StatusInternalServerError, gin. H{"message": euh})
revenir
	}


si résultat. Nombre supprimé < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"message": "Aucune donnée à supprimer"})
revenir
	}
c. JSON(http. StatutCréé, gin. H{"message": "Article supprimé avec succès", "Données": res})
}

Ce code supprime un enregistrement à l'aide de la SupprimerUn fonction. Il utilise également le résultat. Nombre supprimé 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 :

forfait principale
importer (
 itinéraires "CRUD_API/routes"
"github.com/gin-gonic/gin"
)


fonction principale(){
 routeur := gin.Défaut()


routeur. PUBLIER("/", itinéraires. CréerPost)


// appelé en tant qu'hôte local: 3000/getOne/{id}
 routeur. OBTENIR("getOne/:postId", itinéraires. ReadOnePost)


// appelé en tant qu'hôte local: 3000/mettre à jour/{identifiant}
 routeur. METTRE("/update/:postId", itinéraires. UpdatePost)


// appelé en tant qu'hôte local: 3000/effacer/{identifiant}
 routeur. EFFACER("/effacer/:postId", itinéraires. Supprimer le message)
routeur. Courir("hôte local: 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 :

allerCoursprincipale.aller

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.