So erstellen Sie eine CRUD-API mit Golangs Gin und MongoDB

So erstellen Sie eine CRUD-API mit Golangs Gin und MongoDB

Golang ist eine der bestbezahlten und gefragtesten Programmiersprachen mit vielen Anwendungen. In Kombination mit Frameworks wie Gin, Revel und Gorilla/Mux können Sie mit Go ganz einfach eine API erstellen.





Erfahren Sie, wie Sie mit dem Gin-HTTP-Framework eine CRUD-API in Golang erstellen.



MAKEUSEOF VIDEO DES TAGES

Ersteinrichtung und Installation

Beginnen Sie mit Golang indem Sie es auf Ihrem Computer installieren, falls Sie dies noch nicht getan haben.





Nach der Installation besteht der nächste Schritt darin, einen Projektstammordner auf Ihrem Computer zu erstellen und ein Go-Modul in diesem Stammverzeichnis zu initialisieren.

Öffnen Sie dazu eine CLI , navigieren Sie zu Ihrem Projektstammordner und führen Sie Folgendes aus:



go mod init module_name

Sie sehen Ihren Modulnamen (z. CRUD_API ) und seine Version beim Öffnen der gehen.mod Datei. Alle benutzerdefinierten Pakete stammen aus diesem übergeordneten Modul. Jedes importierte benutzerdefinierte Paket hat also die Form:

import(package CRUD_API/package-directory-name)

Installieren Sie als Nächstes die Pakete, die zum Erstellen der CRUD-API erforderlich sind. Verwenden Sie in diesem Fall Gin Gonic um die API-Endpunkte weiterzuleiten:



go get github.com/gin-gonic/gin

Installieren Sie nun den MongoDB-Treiber zum Speichern von Daten:

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

So stellen Sie eine Verbindung zu MongoDB her

Sie benötigen lediglich Ihren MongoDB-URI, um Golang mit der Datenbank zu verbinden. Es sieht normalerweise so aus, wenn Sie sich lokal mit MongoDB Atlas verbinden:



Mongo_URL = "mongodb://127.0.0.1:27017"

Erstellen Sie nun einen neuen Ordner in Ihrem Projektstammverzeichnis und rufen Sie ihn auf Datenbanken . Erstellen Sie eine Go-Datei in diesem Ordner und benennen Sie sie Datenbank.go .

Dies ist Ihr Datenbankpaket und es beginnt mit dem Importieren der erforderlichen Bibliotheken:

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 hat sich bewährt, Umgebungsvariablen wie die Datenbankverbindungszeichenfolge in a auszublenden .env Datei mit dem dotenv-Paket . Dies macht Ihren Code portabler und ist praktisch bei der Verwendung von a MongoDB-Cloud-Cluster-Instanz , zum Beispiel.

beste Seite um kostenlose Filme zu streamen

Das ConnectDB -Funktion stellt eine Verbindung her und gibt ein neues MongoDB-Clientobjekt zurück.

Datenbanksammlung erstellen

MongoDB speichert Daten in Sammlungen, die eine Schnittstelle zu den zugrunde liegenden Datenbankdaten bereitstellen.

Um die Funktionalität zum Abrufen von Sammlungen zu handhaben, erstellen Sie zunächst einen neuen Ordner, Sammlung , in Ihrem Projektstamm. Erstellen Sie nun eine neue Go-Datei, getCollection.go , die die Sammlung aus der Datenbank erhält:

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 
}

Diese Funktion ruft die Sammlung aus der MongoDB-Datenbank ab. Der Datenbankname lautet in diesem Fall myGoappDB , mit Beiträge als seine Sammlung.

Erstellen Sie das Datenbankmodell

Erstellen Sie einen neuen Ordner in Ihrem Stammverzeichnis und rufen Sie ihn auf Modell . Dieser Ordner verwaltet Ihr Datenbankmodell.

Erstellen Sie eine neue Go-Datei in diesem Ordner und rufen Sie sie auf model.go . Ihr Modell ist in diesem Fall ein Blogbeitrag mit seinem Titel:

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

Erstellen einer CRUD-API mit Go

Als nächstes folgt die CRUD-API-Erstellung. Um mit diesem Abschnitt zu beginnen, erstellen Sie einen neuen Ordner in Ihrem Projektstammverzeichnis, um Ihre Endpunkte zu verwalten. Nennen Strecken .

Erstellen Sie in diesem Ordner für jede Aktion eine separate Go-Datei. Sie können sie beispielsweise benennen erstellen.gehen , lesen.gehen , update.go , und löschen.gehen . Sie exportieren diese Handler als Strecken Paket.

So erstellen Sie den POST-Endpunkt in Go

Beginnen Sie mit der Definition des POST-Endpunkts, um Daten in die Datenbank zu schreiben.

Windows Media Player 12 kostenlos herunterladen

Innen routen/create.go , fügen Sie Folgendes hinzu:

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

Dieser Code beginnt mit dem Importieren der benutzerdefinierten Module des Projekts. Es importiert dann Pakete von Drittanbietern einschließlich Gin und MongoDB-Treiber .

Des Weiteren, postSammlung enthält die Datenbanksammlung. Vor allem, c.BindJSON('post') ist eine JSONified-Modellinstanz, die jedes Modellfeld als aufruft postNutzlast ; das geht in die Datenbank.

So erstellen Sie den GET-Endpunkt

Der GET-Endpunkt, in routen/read.go , liest ein einzelnes Dokument anhand seiner eindeutigen ID aus der Datenbank. Es beginnt auch mit dem Importieren von benutzerdefinierten und Drittanbieter-Paketen:

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

Das Beiträge variable ist eine Parameterdeklaration. Es erhält die Objekt-ID eines Dokuments als objId .

Jedoch, Ergebnis ist eine Instanz des Datenbankmodells, das später das zurückgegebene Dokument als enthält res .

So erstellen Sie den PUT-Endpunkt

Der PUT-Handler, in routen/update.go , ähnelt dem POST-Handler. Dieses Mal aktualisiert es einen vorhandenen Beitrag anhand seiner eindeutigen Objekt-ID:

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

Ein JSON-Format der Modellinstanz ( Post ) ruft jedes Modellfeld aus der Datenbank auf. Die Ergebnisvariable verwendet die MongoDB $set Operator zum Aktualisieren eines erforderlichen Dokuments, das von seiner Objekt-ID aufgerufen wird.

Das result.MatchedCount Bedingung verhindert, dass der Code ausgeführt wird, wenn es keinen Datensatz in der Datenbank gibt oder die übergebene ID ungültig ist.

Erstellen eines DELETE-Endpunkts

Der DELETE-Endpunkt, in löschen.gehen , entfernt ein Dokument basierend auf der als URL-Parameter übergebenen Objekt-ID:

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

Dieser Code löscht einen Datensatz mit der LöschenEins Funktion. Es verwendet auch die result.DeletedCount -Eigenschaft, um zu verhindern, dass der Code ausgeführt wird, wenn die Datenbank leer oder die Objekt-ID ungültig ist.

Erstellen Sie die API-Runner-Datei

Erstellen Sie abschließend eine main.go in Ihrem Projektstammverzeichnis. Ihre endgültige Projektstruktur sollte wie folgt aussehen:

Golang CRUD-Projektstruktur

Diese Datei verarbeitet die Router-Ausführung für jeden Endpunkt:

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

Diese Datei ist das Hauptpaket, das andere Dateien ausführt. Es beginnt mit dem Importieren der Routenhandler. Als nächstes ist die Router variabel, a Gin Instanz, die die HTTP-Aktionen hervorruft und jeden Endpunkt mit seinem Funktionsnamen aus der aufruft Strecken Paket.

Ihr CRUD-Projekt läuft weiter lokaler Host: 3000 . Zum Ausführen des Servers und Testen Sie die CRUD-API , führen Sie den folgenden Befehl in Ihrem Basisverzeichnis aus:

windows 10 warum ist meine festplatte bei 100 
go run main.go

Verwandeln Sie Ihr Golang-CRUD-Projekt in ein nutzbares Produkt

Sie haben erfolgreich eine CRUD-API mit Go erstellt; Herzliche Glückwünsche! Obwohl dies ein kleines Projekt ist, haben Sie gesehen, was es braucht, um regelmäßige HTTP-Anforderungen in Go auszuführen.

Sie können kreativer werden, indem Sie dies zu einer praktischeren Anwendung erweitern, die den Benutzern einen Mehrwert bietet. Go ist eine geeignete Programmiersprache für eine Reihe von Anwendungsfällen.