W marcu 2019 r. został wydany oficjalny, gotowy do produkcji sterownik GO dla MongoDB, który od momentu premiery otrzymuje ciągłe aktualizacje. W tym samouczku nauczymy się wykonywać proste operacje CRUD MongoDB za pomocą sterownika Go.
Warunki wstępne
Dwie rzeczy są wymagane przed rozpoczęciem tego samouczka.
- Go powinno być zainstalowane na twoim komputerze. W tym samouczku jest używana wersja Go 1.15. Możesz pobrać pakiet Go z tego linku.
- Zainstaluj najnowszą wersję MongoDB na swoim komputerze i uruchom lokalny serwer MongoDB.
Instalacja sterownika MongoDB
Zainstaluj sterownik MongoDB go, uruchamiając następujące polecenie:
go get go.mongodb.org/mongo-driverJeśli używasz modułów Go, utwórz plik go.mod, a następnie powyższe polecenie doda wymaganą zależność w pliku mod. Ten plik blokuje wszystkie wymagania projektu do jego prawidłowej wersji.
Konfigurowanie głównego pliku
Utwórz plik main.go w folderze projektu i otwórz go w swoim IDE. Zanim napiszemy kod dla operacji MongoDB, zaimportujmy wszystkie niezbędne pakiety do pliku.
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"
)Teraz utwórz następujące zmienne globalne, których będziemy używać we wszystkich funkcjach operacji CRUD.
var client *mongo.Client
var collection *mongo.Collection
var ctx = context.TODO()Utwórz również strukturę dla typu dokumentu.
type Person struct {
Name string
Age int
City string
}Łączenie z MongoDB
Teraz konfiguracja podstawowa jest gotowa. Stwórzmy naszą pierwszą funkcję do łączenia się z MongoDB.
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
}Ta funkcja ustawi połączenie z naszą lokalnie działającą bazą danych MongoDB i zwróci obiekt klienta. Gdy metoda connect zwróci obiekt klienta, możemy użyć metody Ping(), aby sprawdzić, czy połączenie się powiodło, czy nie. Jeśli metoda Ping() zwróci błąd, możemy go zgłosić i zwrócić.
Wstaw operację
Aby wstawić tylko jeden dokument, możemy użyć metody insertOne, a do wstawienia wielu dokumentów razem, możemy użyć metody insertMany. Poniżej znajduje się funkcja wstawiania jednego dokumentu do kolekcji Osoba:
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)
}Oto funkcja dodawania wielu dokumentów do kolekcji:
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)
}Dla obu operacji musimy użyć utworzonej wcześniej struktury Person i zainicjować ją naszymi danymi. Dzięki funkcji InsertMany będziemy musieli przekazać interfejs typu dla wszystkich dokumentów.
Operacja pobierania
W celu znalezienia danych z kolekcji będziemy potrzebować filtru przepustowego, więc upewnij się, że zaimportowałeś pakiet bson. Użyjemy typu bson.D do tworzenia filtrów przy użyciu obiektów bson.
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)
}W ten sam sposób możemy użyć metody Find, aby pobrać wszystkie pasujące dokumenty.
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())
}Możesz użyć pakietu opcji, aby określić opcje, takie jak limit lub zamówienia.
Operacja aktualizacji
Tak samo jak metoda FineOne, do aktualizacji również możesz użyć metody UpdateOne z obiektem filtrującym bson. Ten kod zaktualizuje wszystkie dokumenty o nazwie Akash i zwiększy wartość Age o jeden.
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)
}Usuń operację
Do usuwania dokumentów z dowolnej kolekcji można użyć metody DeleteOne lub DeleteMany. Tutaj również możemy przekazać obiekty filtrujące bson, aby dopasować dokumenty i je usunąć.
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)
}Jeśli przekażesz obiekt bson.D{{}} jako parametr filtru, usunie on wszystkie dokumenty. Możesz użyć metody collection.Drop(), aby usunąć całą kolekcję.
Gdy wszystkie te funkcje są gotowe, możesz ich używać w funkcji kierowcy zgodnie z potrzebami. Mamy nadzieję, że to wystarczy, aby zacząć pisać funkcje MongoDB w Go. Aby uzyskać więcej informacji, zapoznaj się z oficjalną dokumentacją sterownika Go Mongo.
