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.

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:

gehe 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:

importieren(Paket CRUD_API/Paket-Verzeichnisname)
instagram viewer

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:

gehen erhalten github.com/gin-gonic/gin

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

gehen erhalten 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:

Paket Datenbank
importieren (
"Kontext"
"fmt"
"Protokoll"
"Zeit"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


Funk ConnectDB() *Mongo. Klient {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	Klient, äh := Mongo. Neuer Kunde (Optionen. Client().ApplyURI(Mongo_URL))


wenn err != nil {
Protokoll.Tödlich(irren)
	}


ctx, abbrechen := Kontext. WithTimeout (Kontext. Hintergrund(), 10 * Mal. Zweite)
	Fehler = Kunde. Verbinden (ctx)
	aufschieben abbrechen()


wenn err != nil {
Protokoll.Tödlich(irren)
	}
fmt. Println("Verbunden mit mongoDB")
Rückkehr Klient
}

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.

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:

Paket Sammlung erhalten
importieren (
"go.mongodb.org/mongo-driver/mongo"
)
FunkGetCollection(Klient *Mongo.Klient, SammlungsnameSchnur) *Mongo.Sammlung {
	Sammlung := Kunde. Datenbank("myGoappDB").Sammlung("Beiträge")
Rückkehr Sammlung
}

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:

Paket Modell
importieren (
"go.mongodb.org/mongo-driver/bson/primitive"
)
Typ Post-Struktur {
ICH WÜRDEPrimitive.Objekt Identifikation
	Titel-String
	Artikelzeichenfolge
}

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.

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

Paket Strecken
importieren (
	Sammlung erhalten "CRUD_API/Sammlung"
	Datenbank "CRUD_API/Datenbanken"
	Modell "CRUD_API/Modell"
"Kontext"
"Protokoll"
"net/http"
"Zeit"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


Funk Post erstellen(c*gin. Kontext){
Var DB = Datenbank. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Beiträge")
	ctx, abbrechen := Kontext. WithTimeout (Kontext. Hintergrund(), 10*mal. Zweite)
	Beitrag := Neu(Modell. Beiträge)
	aufschieben abbrechen()


wenn Fehler := c. BindJSON(&Post); ähm != nil {
 c. JSON (http. StatusBadRequest, gin. H{"Botschaft": irren})
Protokoll.Tödlich(irren)
Rückkehr
	}


postPayload := Modell. Beiträge{
Ausweis: Primitive.NeueObjektID(),
Titel: Post.Titel,
Artikel: Post.Artikel,
	}


Ergebnis, err := postCollection. InsertOne (ctx, postPayload)


wenn err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": irren})
Rückkehr
	}
c. JSON (http. StatusErstellt, Gin. H{"Botschaft": "Erfolgreich gepostet", "Daten": map[string]interface{}{"Daten": Ergebnis}})
}

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:

Paket Strecken
importieren (
	Sammlung erhalten "CRUD_API/Sammlung"
	Datenbank "CRUD_API/Datenbanken"
	Modell "CRUD_API/Modell"
"Kontext"
"net/http"
"Zeit"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


Funk ReadOnePost(c*gin. Kontext){
	ctx, abbrechen := Kontext. WithTimeout (Kontext. Hintergrund(), 10*mal. Zweite)
Var DB = Datenbank. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Beiträge")


postId := c. Param("postId")
Var Ergebnismodell. Beiträge


aufschieben abbrechen()


objId, _ := primitiv. ObjectIDFromHex (postId)


err := postSammlung. FindOne (ctx, bson. M{"Ich würde": objId}).Decode(&Ergebnis)


res := map[string]Schnittstelle{}{"Daten": Ergebnis}


wenn err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": irren})
Rückkehr
	}
c. JSON (http. StatusErstellt, Gin. H{"Botschaft": "Erfolg!", "Daten":res})
}

Das postId 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:

Paket Strecken
importieren (
	Sammlung erhalten "CRUD_API/Sammlung"
	Datenbank "CRUD_API/Datenbanken"
	Modell "CRUD_API/Modell"
"Kontext"
"net/http"
"Zeit"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


Funk UpdatePost(c*gin. Kontext){
	ctx, abbrechen := Kontext. WithTimeout (Kontext. Hintergrund(), 10 * Mal. Zweite)
Var DB = Datenbank. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Beiträge")


postId := c. Param("postId")
Var Post-Modell. Beiträge


aufschieben abbrechen()


objId, _ := primitiv. ObjectIDFromHex (postId)


wenn Fehler := c. BindJSON(&Post); ähm != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": irren})
Rückkehr
	}


bearbeitet := bson. M{"Titel": Post. Titel, "Artikel": Post. Artikel}


Ergebnis, err := postCollection. UpdateOne (ctx, bson. M{"Ich würde": objId}, bson. M{"$set": bearbeitet})


res := map[string]Schnittstelle{}{"Daten": Ergebnis}


wenn err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": irren})
Rückkehr
	}


wenn Ergebnis. MatchedCount < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": "Daten nicht'Es gibt sie nicht"})
Rückkehr
	}
c. JSON (http. StatusErstellt, Gin. H{"Botschaft": "Daten erfolgreich aktualisiert!", "Daten":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 Ergebnis. 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:

Paket Strecken
importieren (
	Sammlung erhalten "CRUD_API/Sammlung"
	Datenbank "CRUD_API/Datenbanken"
"Kontext"
"net/http"
"Zeit"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


Funk Beitrag entfernen(c*gin. Kontext){
	ctx, abbrechen := Kontext. WithTimeout (Kontext. Hintergrund(), 10*mal. Zweite)
Var DB = Datenbank. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Beiträge") 
	aufschieben abbrechen()
	objId, _ := primitiv. ObjectIDFromHex (postId) 
	Ergebnis, err := postCollection. DeleteOne (ctx, bson. M{"Ich würde": objId}) 
	res := map[string]Schnittstelle{}{"Daten": Ergebnis}


wenn err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": irren})
Rückkehr
	}


wenn Ergebnis. GelöschteAnzahl < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"Botschaft": "Keine Daten zum Löschen"})
Rückkehr
	}
c. JSON (http. StatusErstellt, Gin. H{"Botschaft": "Artikel erfolgreich gelöscht", "Daten":res})
}

Dieser Code löscht einen Datensatz mit der LöschenEins Funktion. Es verwendet auch die Ergebnis. GelöschteAnzahl -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:

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

Paket hauptsächlich
importieren (
 Strecken "CRUD_API/routen"
"github.com/gin-gonic/gin"
)


Funk hauptsächlich(){
 Router := gin.Standard()


Router. POST("/", Strecken. Post erstellen)


// aufgerufen als localhost: 3000/getOne/{id}
 Router. ERHALTEN("getOne/:postId", Strecken. ReadOnePost)


// aufgerufen als localhost: 3000/aktualisieren/{Ich würde}
 Router. STELLEN("/update/:postId", Strecken. UpdatePost)


// aufgerufen als localhost: 3000/löschen/{Ich würde}
 Router. LÖSCHEN("/löschen/:postId", routen. Beitrag entfernen)
Router. Laufen("lokaler Host: 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:

gehenLaufhauptsächlich.gehen

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.