golang操作MongoDB总结

下载安装MongoDB

本文视频教程：https://www.bilibili.com/video/BV1zR4y1t7Wj?p=107

关注公众号，领取课程资料和源码

下载地址：

https://www.mongodb.com/download-center/community

打开客户端

mongo.exe

创建数据库

use go_db;

创建集合

 db.createCollection("student");

下载安装驱动并连接数据库

下载地址：

https://www.mongodb.com/download-center/community

打开客户端

mongo.exe

创建数据库

use go_db;

创建集合

 db.createCollection("student");

下载驱动

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

连接mongoDB

package main

import (
    "context"
    "fmt"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "log"
)


var client *mongo.Client

func initDB()  {
    // 设置客户端连接配置
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
    // 连接到MongoDB
    var err error
    client, err = mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    // 检查连接
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")
}

func main() {
    initDB()
}

运行结果

Connected to MongoDB!

BSON简介

MongoDB中的JSON文档存储在名为BSON(二进制编码的JSON)的二进制表示中。与其他将JSON数据存储为简单字符串和数字的数据库不同，BSON编码扩展了JSON表示，使其包含额外的类型，如int、long、date、浮点数和decimal128。这使得应用程序更容易可靠地处理、排序和比较数据。

连接MongoDB的Go驱动程序中有两大类型表示BSON数据：D和Raw。

类型D家族被用来简洁地构建使用本地Go类型的BSON对象。这对于构造传递给MongoDB的命令特别有用。D家族包括四类:

• D：一个BSON文档。这种类型应该在顺序重要的情况下使用，比如MongoDB命令。
• M：一张无序的map。它和D是一样的，只是它不保持顺序。
• A：一个BSON数组。
• E：D里面的一个元素。

要使用BSON，需要先导入下面的包：

import "go.mongodb.org/mongo-driver/bson"

下面是一个使用D类型构建的过滤器文档的例子，它可以用来查找name字段与’张三’或’李四’匹配的文档:

bson.D{{
    "name",
    bson.D{{
        "$in",
        bson.A{"张三", "李四"},
    }},
}}

Raw类型家族用于验证字节切片。你还可以使用Lookup()从原始类型检索单个元素。如果你不想要将BSON反序列化成另一种类型的开销，那么这是非常有用的。这个教程我们将只使用D类型。

添加文档

创建一个结构体

type Student struct {
    Name string
    Age int
}

添加单个文档

使用collection.InsertOne()方法插入一条文档记录：

func insertOne(s Student) {
    initDB()
    collection := client.Database("go_db").Collection("student")
    insertResult, err := collection.InsertOne(context.TODO(), s)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Inserted a single document: ", insertResult.InsertedID)
}

测试

func main() {
    s := Student{Name: "tom", Age: 20}
    insertOne(s)
}

运行结果

Connected to MongoDB!
Inserted a single document:  ObjectID("61124558682f5c9583330222")

客户端查看

mongodb 打开客户端
use go_db
db.student.find()
db.student.remove({}) // 删除所有

插入多个文档

使用collection.InsertMany()方法插入多条文档记录：

func insertMore(students []interface{}) {
    //students := []interface{}{s2, s3}
    initDB()
    collection := client.Database("go_db").Collection("student")
    insertManyResult, err := collection.InsertMany(context.TODO(), students)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)
}

测试

func main() {
    s := Student{Name: "tom", Age: 20}
    s1 := Student{Name: "kite", Age: 21}
    s2 := Student{Name: "rose", Age: 22}
    students := []interface{}{s, s1, s2}
    insertMore(students)
}

运行结果

Connected to MongoDB!
Inserted multiple documents:  [ObjectID("611246c56637c3554426bc92") ObjectID("611246c56637c3554426bc93") ObjectID("611246c56637c3554426bc94")]

更多方法请查阅官方文档。

查找文档

package main

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

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

var client *mongo.Client
func initDB() {
    // 设置客户端连接配置
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    co := options.Client().ApplyURI("mongodb://localhost:27017")
    mongo.Connect(context.TODO(), co)
    // 连接到MongoDB
    var err error
    client, err = mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    client.Ping(context.TODO(), nil)
    // 检查连接
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")
}

func find() {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    collection := client.Database("go_db").Collection("student")
    cur, err := collection.Find(ctx, bson.D{})
    if err != nil {
        log.Fatal(err)
    }
    defer cur.Close(ctx)
    for cur.Next(ctx) {
        var result bson.D
        err := cur.Decode(&result)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("result: %v\n", result)
        fmt.Printf("result.Map(): %v\n", result.Map()["name"])
    }
    if err := cur.Err(); err != nil {
        log.Fatal(err)
    }
}



func main() {
    initDB()
    find()
}

更新文档

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

type Student struct {
    Name string
    Age  int
}

var client *mongo.Client

func initDb() {
    co := options.Client().ApplyURI("mongodb://localhost:27017")
    c, err := mongo.Connect(context.TODO(), co)
    if err != nil {
        log.Fatal(err)
    }

    err2 := c.Ping(context.TODO(), nil)
    if err2 != nil {
        log.Fatal(err2)
    } else {
        fmt.Println("连接成功！")
    }
    client = c
}

func update() {
    ctx := context.TODO()
    defer client.Disconnect(ctx)
    c := client.Database("go_db").Collection("Student")

    update := bson.D{{"$set", bson.D{{"Name", "big tom"}, {"Age", 22}}}}

    ur, err := c.UpdateMany(ctx, bson.D{{"name", "tom"}}, update)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("ur.ModifiedCount: %v\n", ur.ModifiedCount)
}

func main() {
    initDb()
    update()
}

删除文档

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

type Student struct {
    Name string
    Age  int
}

var client *mongo.Client

func initDb() {
    co := options.Client().ApplyURI("mongodb://localhost:27017")
    c, err := mongo.Connect(context.TODO(), co)
    if err != nil {
        log.Fatal(err)
    }

    err2 := c.Ping(context.TODO(), nil)
    if err2 != nil {
        log.Fatal(err2)
    } else {
        fmt.Println("连接成功！")
    }
    client = c
}

func del() {

    initDb()
    c := client.Database("go_db").Collection("Student")
    ctx := context.TODO()

    dr, err := c.DeleteMany(ctx, bson.D{{"Name", "big kite"}})

    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("ur.ModifiedCount: %v\n", dr.DeletedCount)

}

func main() {
    del()
}