Im März 2019 wurde der offizielle, produktionsbereite GO-Treiber für MongoDB veröffentlicht und seit seiner Einführung kontinuierlich aktualisiert. In diesem Tutorial lernen wir, einfache MongoDB-CRUD-Operationen mit dem Go-Treiber durchzuführen.
Voraussetzungen
Zwei Dinge sind erforderlich, bevor wir mit diesem Tutorial beginnen.
- Go sollte auf Ihrem Rechner installiert sein. Für dieses Tutorial wird die Go-Version 1.15 verwendet. Sie können das Go-Paket über diesen Link herunterladen.
- Installieren Sie die neueste Version von MongoDB auf Ihrem Computer und starten Sie den lokalen Server von MongoDB.
Installation des MongoDB-Treibers
Installieren Sie den MongoDB go-Treiber, indem Sie den folgenden Befehl ausführen:
go get go.mongodb.org/mongo-driverWenn Sie Go-Module verwenden, erstellen Sie eine go.mod-Datei und dann fügt der obige Befehl die erforderliche Abhängigkeit in der Mod-Datei hinzu. Diese Datei sperrt alle Projektanforderungen auf ihre korrekte Version.
Hauptdatei einrichten
Erstellen Sie eine Datei main.go in Ihrem Projektordner und öffnen Sie sie in Ihrer IDE. Bevor wir den Code für MongoDB-Operationen schreiben, importieren wir alle erforderlichen Pakete in die Datei.
package main
import (
"context"
"fmt"
"log"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)Erstellen Sie nun die folgenden globalen Variablen, die wir für alle CRUD-Operationsfunktionen verwenden werden.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Erstellen Sie auch die Struktur für Dokumenttyp.
type Person struct {
Name string
Age int
City string
}Verbinden mit MongoDB
Nun ist das Grundsetup fertig. Lassen Sie uns unsere erste Funktion für die Verbindung mit MongoDB erstellen.
func connect() *mongo.Client {
clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
log.Fatal(err)
}
err = client.Ping(ctx, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Connected to MongoDB!")
return client
}Diese Funktion baut die Verbindung mit unserer lokal laufenden MongoDB auf und gibt das Client-Objekt zurück. Sobald die Connect-Methode das Client-Objekt zurückgibt, können wir mit der Ping()-Methode überprüfen, ob die Verbindung erfolgreich war oder nicht. Wenn die Ping()-Methode einen Fehler zurückgibt, können wir den Fehler auslösen und zurückgeben.
Operation einfügen
Um nur ein Dokument einzufügen, können wir die Methode insertOne verwenden und um mehrere Dokumente zusammen einzufügen, können wir die Methode insertMany verwenden. Es folgt die Funktion zum Einfügen eines Dokuments in die Personensammlung:
func insertOne() {
akash := Person{"Akash", 28, "Bengaluru"}
res, err := collection. InsertOne (ctx, akash)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted document: ", res.InsertedID)
}Hier ist die Funktion zum Hinzufügen mehrerer Dokumente zur Sammlung:
func insertMany() {
akash := Person{"Akash", 28, "Bengaluru"}
bob := Person {"Bob", 30, "New York"}
robin := Person {"Robin", 25, "London"}
persons := []interface{}{akash, bob, robin}
res, err := collection.InsertMany(ctx, persons)
if err != nil {
log.Fatal(err)
}
fmt.Println("Inserted documents: ", res.InsertedIDs)
}Für beide Operationen müssen wir die Person-Struktur verwenden, die wir zuvor erstellt haben, und sie mit unseren Daten initialisieren. Mit der InsertMany-Funktion müssen wir die Typschnittstelle für alle Dokumente übergeben.
Abrufoperation
Um Daten aus der Sammlung zu finden, benötigen wir einen Pass-Filter, stellen Sie also sicher, dass Sie das bson-Paket importiert haben. Wir werden den Typ bson.D verwenden, um Filter mit bson-Objekten zu erstellen.
func retrieveOne() {
var result Person
filter := bson.D{{"name", "Akash"}}
err := collection.FindOne(ctx, filter).Decode(&result)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)
}Auf die gleiche Weise können wir die Find-Methode verwenden, um alle übereinstimmenden Dokumente abzurufen.
func retrieveAll() {
findOptions := options.Find()
findOptions.SetLimit(2)
var results []*Person
cur, err := collection.Find(ctx, bson.D{{}}, findOptions)
if err != nil {
log.Fatal(err)
}
// Loop through the cursor
for cur.Next(context.TODO()) {
var elem Person
err := cur.Decode(&elem)
if err != nil {
log.Fatal(err)
}
results = append(results, &elem)
}
if err := cur.Err(); err != nil {
log.Fatal(err)
}
cur.Close(context.TODO())
}Sie können das Optionspaket verwenden, um Optionen wie Limit oder Orders festzulegen.
Aktualisierungsvorgang
Dasselbe wie die FineOne-Methode, für die Aktualisierung können Sie auch die UpdateOne-Methode mit dem bson-Filterobjekt verwenden. Dieser Code aktualisiert alle Dokumente mit dem Namen Akash und erhöht den Wert von Age um eins.
func update() {
filter := bson.D{{"name", "Akash"}}
update := bson.D{
{"$inc", bson.D{
{"Age", 1},
}},
}
updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Updated documents: %+v\n", updateResult)
}Operation löschen
Zum Löschen von Dokumenten aus einer beliebigen Sammlung können Sie entweder die DeleteOne- oder die DeleteMany-Methode verwenden. Auch hier können wir bson-Filterobjekte übergeben, um die Dokumente abzugleichen und sie zu löschen.
func delete() {
deleteResult, err := collection.DeleteMany(ctx, bson.D{{}})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount)
}Wenn Sie das Objekt bson.D{{}} als Filterparameter übergeben, werden alle Dokumente gelöscht. Sie können die Methode collection.Drop() verwenden, um die gesamte Sammlung zu löschen.
Sobald alle diese Funktionen fertig sind, können Sie sie je nach Bedarf in Ihrer Treiberfunktion verwenden. Hoffentlich reicht dies aus, um mit dem Schreiben von MongoDB-Funktionen in Go zu beginnen. Weitere Informationen finden Sie in der offiziellen Dokumentation für den Go Mongo-Treiber.
