MongoDB Alpha版Golang驱动基础CRUD操作完整示例需求

Got it, I totally get where you're coming from—those alpha-stage docs can feel pretty bare when you just need straightforward, working examples for basic CRUD. Let's put together a clean, complete example that covers all the core operations using the mongo-go-driver, with explanations for key bits along the way.

First, make sure you've installed the driver:

go get github.com/mongodb/mongo-go-driver/mongo

We'll start with a full working example, then break down each operation. We'll use a simple User struct to map to MongoDB documents.

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/mongodb/mongo-go-driver/bson"
	"github.com/mongodb/mongo-go-driver/mongo"
	"github.com/mongodb/mongo-go-driver/mongo/options"
)

// User represents a document in our "users" collection
type User struct {
	ID        bson.ObjectID `bson:"_id,omitempty"`
	Username  string        `bson:"username"`
	Email     string        `bson:"email"`
	Age       int           `bson:"age"`
	CreatedAt time.Time     `bson:"created_at"`
}

func main() {
	// 1. Establish a connection to MongoDB
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatalf("Failed to connect to MongoDB: %v", err)
	}
	defer func() {
		if err := client.Disconnect(ctx); err != nil {
			log.Fatalf("Failed to disconnect: %v", err)
		}
	}()

	// Verify connection
	err = client.Ping(ctx, nil)
	if err != nil {
		log.Fatalf("Failed to ping MongoDB: %v", err)
	}
	fmt.Println("Connected to MongoDB successfully!")

	// Get a reference to the "testdb" database and "users" collection
	db := client.Database("testdb")
	usersColl := db.Collection("users")

	// --- CREATE (Insert) Operations ---
	fmt.Println("\n=== CREATE Operations ===")
	// Insert a single user
	newUser := User{
		Username:  "johndoe",
		Email:     "john@example.com",
		Age:       30,
		CreatedAt: time.Now(),
	}

	insertResult, err := usersColl.InsertOne(ctx, newUser)
	if err != nil {
		log.Fatalf("Failed to insert user: %v", err)
	}
	fmt.Printf("Inserted single user with ID: %v\n", insertResult.InsertedID)

	// Insert multiple users
	usersToInsert := []interface{}{
		User{Username: "janedoe", Email: "jane@example.com", Age: 28, CreatedAt: time.Now()},
		User{Username: "bobsmith", Email: "bob@example.com", Age: 35, CreatedAt: time.Now()},
	}
	multiInsertResult, err := usersColl.InsertMany(ctx, usersToInsert)
	if err != nil {
		log.Fatalf("Failed to insert multiple users: %v", err)
	}
	fmt.Printf("Inserted %d users with IDs: %v\n", len(multiInsertResult.InsertedIDs), multiInsertResult.InsertedIDs)

	// --- READ (Query) Operations ---
	fmt.Println("\n=== READ Operations ===")
	// Find a single user by username
	var foundUser User
	filter := bson.D{{"username", "johndoe"}}
	err = usersColl.FindOne(ctx, filter).Decode(&foundUser)
	if err != nil {
		log.Fatalf("Failed to find user: %v", err)
	}
	fmt.Printf("Found user: %+v\n", foundUser)

	// Find all users older than 29
	var olderUsers []User
	cursor, err := usersColl.Find(ctx, bson.D{{"age", bson.D{{"$gt", 29}}}})
	if err != nil {
		log.Fatalf("Failed to query users: %v", err)
	}
	defer cursor.Close(ctx)

	for cursor.Next(ctx) {
		var user User
		if err := cursor.Decode(&user); err != nil {
			log.Fatalf("Failed to decode user: %v", err)
		}
		olderUsers = append(olderUsers, user)
	}
	if err := cursor.Err(); err != nil {
		log.Fatalf("Cursor error: %v", err)
	}
	fmt.Printf("Found %d users older than 29: %+v\n", len(olderUsers), olderUsers)

	// --- UPDATE Operations ---
	fmt.Println("\n=== UPDATE Operations ===")
	// Update a single user's age
	updateFilter := bson.D{{"username", "johndoe"}}
	update := bson.D{{"$set", bson.D{{"age", 31}}}}

	updateResult, err := usersColl.UpdateOne(ctx, updateFilter, update)
	if err != nil {
		log.Fatalf("Failed to update user: %v", err)
	}
	fmt.Printf("Matched %d document(s), modified %d document(s)\n", updateResult.MatchedCount, updateResult.ModifiedCount)

	// Update all users to add a "last_updated" field
	multiUpdateFilter := bson.D{{}} // Empty filter matches all documents
	multiUpdate := bson.D{{"$set", bson.D{{"last_updated", time.Now()}}}}

	multiUpdateResult, err := usersColl.UpdateMany(ctx, multiUpdateFilter, multiUpdate)
	if err != nil {
		log.Fatalf("Failed to update multiple users: %v", err)
	}
	fmt.Printf("Matched %d document(s), modified %d document(s)\n", multiUpdateResult.MatchedCount, multiUpdateResult.ModifiedCount)

	// --- DELETE Operations ---
	fmt.Println("\n=== DELETE Operations ===")
	// Delete a single user
	deleteFilter := bson.D{{"username", "bobsmith"}}
	deleteResult, err := usersColl.DeleteOne(ctx, deleteFilter)
	if err != nil {
		log.Fatalf("Failed to delete user: %v", err)
	}
	fmt.Printf("Deleted %d document(s)\n", deleteResult.DeletedCount)

	// Delete all users older than 30
	multiDeleteFilter := bson.D{{"age", bson.D{{"$gt", 30}}}}
	multiDeleteResult, err := usersColl.DeleteMany(ctx, multiDeleteFilter)
	if err != nil {
		log.Fatalf("Failed to delete multiple users: %v", err)
	}
	fmt.Printf("Deleted %d document(s)\n", multiDeleteResult.DeletedCount)
}

• Context Handling: We use context.WithTimeout to prevent hanging connections, and always defer cancellation/disconnection to clean up resources properly.
• BSON Mapping: The User struct uses bson tags to map Go fields to MongoDB document keys. The omitempty flag on ID lets MongoDB auto-generate the _id value if we don't provide one.
• Filters & Updates: We use bson.D (ordered document) for filters and updates, which is the recommended approach for the alpha driver. You can also use bson.M (unordered map) if field order doesn't matter for your operation.
• Error Handling: We're using log.Fatalf for simplicity in the example, but in production code you'll want to handle errors more gracefully—like returning them to the caller, implementing retry logic, or logging without exiting.

A quick note since this is an alpha driver: some APIs might change before the stable release, so keep an eye on the official repo for updates. But this example covers the core CRUD patterns that should remain consistent.

内容的提问来源于stack exchange，提问作者toc-rox