Use o driver golang para operar o banco de dados MongoDB

Instale o driver MongoDB

mkdr mongodb 
cd mongodb 
go mod init  
go get go.mongodb.org/mongo-driver/mongo

Conecte-se ao MongoDB

Crie um arquivo main.go e
importe os seguintes pacotes para o arquivo main.go

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

O formato URI para se conectar ao MongoDB é

mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]

visão única

mongodb://localhost:27017

Conjunto de réplicas

mongodb://mongodb0.example.com:27017,mongodb1.example.com：27017，mongodb2.example.com：27017 /?replicaSet = myRepl

Cluster fragmentado

mongodb://mongos0.example.com:27017,mongos1.example.com:27017,mongos2.example.com:27017

mongo.Connect () aceita objetos Context e options.ClientOptions, que são usados para definir a string de conexão e outras configurações do driver.
Ao context.TODO()expressar que você não tem certeza de qual contexto para usar agora, mas irá adicionar um
método Ping no futuro para detectar se MongoDB foi conectado normalmente

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://admin:password@localhost:27017")
    var ctx = context.TODO()
    // Connect to MongoDB
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }
    // Check the connection
    err = client.Ping(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!")
    defer client.Disconnect(ctx)

Listar todos os bancos de dados

databases, err := client.ListDatabaseNames(ctx, bson.M{})
if err != nil {
   log.Fatal(err)
}
fmt.Println(databases)

Use objetos BSON em GO

Os documentos JSON no MongoDB são armazenados em uma representação binária chamada BSON (Binary Encoded JSON). Ao contrário de outros bancos de dados que armazenam dados JSON como strings e números simples, a codificação BSON estende a representação JSON, como int, long, date, float point e decimal128. Isso torna mais fácil para os aplicativos processar, classificar e comparar dados de maneira confiável. Go Driver possui duas séries para representar os dados BSON: tipo e Raw系列tipo de série D.
DA série inclui quatro tipos:

D: Documento BSON. Esse tipo é usado em cenários onde a ordem é importante, como comandos do MongoDB.
M: Mapa não ordenado. DO mesmo que exceto que a ordem não é preservada .
A: Uma matriz BSON.

E: DUm único elemento em.

Insira dados no MongoDB

Insira um único documento


//定义插入数据的结构体
type sunshareboy struct {
Name string
Age  int
City string
}

// Conecte-se à coleção sunshare da biblioteca de teste. Se a coleção não existir, a coleção será criada automaticamente
: = client.Database ("test"). Collection ("sunshare")
wanger: = sunshareboy {"wanger", 24, "Beijing"}
insertOne , err: = coleção.InsertOne (ctx, wanger)
if err! = nil {
log.Fatal (err)
}
fmt.Println ("Inserido um único documento:", insertOne.InsertedID)

执行结果如下  
![](https://s4.51cto.com/images/blog/202011/07/378adacb26314b3532fa8947e3516fc1.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)
#### 同时插入多条文档
```go
collection := client.Database("test").Collection("sunshare")
dongdong:=sunshareboy{"张冬冬",29,"成都"}
huazai:=sunshareboy{"华仔",28,"深圳"}
suxin:=sunshareboy{"素心",24,"甘肃"}
god:=sunshareboy{"刘大仙",24,"杭州"}
qiaoke:=sunshareboy{"乔克",29,"重庆"}
jiang:=sunshareboy{"姜总",24,"上海"}
//插入多条数据要用到切片
boys:=[]interface{}{dongdong,huazai,suxin,god,qiaoke,jiang}
insertMany,err:= collection.InsertMany(ctx,boys)
if err != nil {
    log.Fatal(err)
}
fmt.Println("Inserted multiple documents: ", insertMany.InsertedIDs)

Consultar dados do MongDB

Consultar um único documento

Para consultar um único documento, use a função collection.FindOne (), que requer um documento de filtro e um ponteiro que pode decodificar o resultado para seu valor

var result sunshareboy
filter := bson.D{{"name","wanger"}}
err = collection.FindOne(context.TODO(), filter).Decode(&result)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)

O resultado retornado é o seguinte

Connected to MongoDB!
Found a single document: {Name:wanger Age:24 City:北京}
Connection to MongoDB closed.

Consultar vários documentos

Para consultar vários documentos, use a função collection.Find (). Essa função retorna um cursor, que pode ser usado para iterar e decodificar os documentos. Quando a iteração for concluída, feche o cursor

A função Find executa o comando find e retorna o Cursor nos documentos correspondentes na coleção.
O parâmetro de filtro deve ser o documento que contém o operador de consulta e pode ser usado para selecionar quais documentos são incluídos no resultado. Não pode ser zero. Documentos vazios (como bson.D {}) devem ser usados para incluir todos os documentos.

O parâmetro opts pode ser usado para especificar as opções da operação. Por exemplo, podemos definir o limite de retornar apenas cinco documentos (https://godoc.org/go.mongodb.org/mongo-driver/mongo/options#Find）。

//定义返回文档数量
findOptions := options.Find()
findOptions.SetLimit(5)

//定义一个切片存储结果
var results []*sunshareboy

//将bson.D{{}}作为一个filter来匹配所有文档
cur, err := collection.Find(context.TODO(), bson.D{{}}, findOptions)
if err != nil {
    log.Fatal(err)
}
//查找多个文档返回一个游标
//遍历游标一次解码一个游标
for cur.Next(context.TODO()) {
    //定义一个文档，将单个文档解码为result
    var result sunshareboy
    err := cur.Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    results = append(results, &result)
}
fmt.Println(result)
if err := cur.Err(); err != nil {
    log.Fatal(err)
}
//遍历结束后关闭游标
cur.Close(context.TODO())
fmt.Printf("Found multiple documents (array of pointers): %+v\n", results)

O resultado retornado é o seguinte

Connected to MongoDB!
{wanger 24 北京}
{张冬冬 29 成都}
{华仔 28 深圳}
{素心 24 甘肃}
{刘大仙 24 杭州}
Found multiple documents (array of pointers): &[0xc000266450 0xc000266510 0xc000266570 0xc0002665d0 0xc000266630]
Connection to MongoDB closed.

Atualize a documentação do MongoDB

Atualizar um único documento

Para atualizar um único documento, use a função collection.UpdateOne (), um filtro é necessário para corresponder ao documento no banco de dados e um documento de atualização também é necessário para atualizar a operação

O parâmetro de filtro deve ser o documento que contém o operador de consulta e pode ser usado para selecionar o documento a ser atualizado. Não pode ser zero. Se o filtro não corresponder a nenhum documento, a operação será bem-sucedida e um UpdateResult com MatchCount 0 será retornado. Se o filtro corresponder a vários documentos, um será selecionado do conjunto correspondido e MatchedCount será igual a 1.
O parâmetro de atualização deve ser um documento contendo o operador de atualização (https://docs.mongodb.com/manual/reference/operator/update/ ) e pode ser usado para especificar modificações no documento selecionado. Não pode ser nulo ou vazio.

O parâmetro opts pode ser usado para especificar opções para a operação.

filter := bson.D{{"name","张冬冬"}}
//如果过滤的文档不存在，则插入新的文档
opts := options.Update().SetUpsert(true)
update := bson.D{
{"$set", bson.D{
    {"city", "北京"}},
}}
result, err := collection.UpdateOne(context.TODO(), filter, update,opts)
if err != nil {
log.Fatal(err)
}
if result.MatchedCount != 0 {
fmt.Printf("Matched %v documents and updated %v documents.\n", result.MatchedCount, result.ModifiedCount)
}
if result.UpsertedCount != 0 {
fmt.Printf("inserted a new document with ID %v\n", result.UpsertedID)
}

O resultado retornado é o seguinte

Connected to MongoDB!
Matched 1 documents and updated 1 documents.
Connection to MongoDB closed.

Atualizar vários documentos

Para atualizar vários documentos, use a função collection.UpdateOne () com os mesmos parâmetros da função collection.UpdateOne ()

filter := bson.D{{"city","北京"}}
//如果过滤的文档不存在，则插入新的文档
opts := options.Update().SetUpsert(true)
update := bson.D{
{"$set", bson.D{
    {"city", "铁岭"}},
}}
result, err := collection.UpdateMany(context.TODO(), filter, update,opts)
if err != nil {
log.Fatal(err)
}
if result.MatchedCount != 0 {
fmt.Printf("Matched %v documents and updated %v documents.\n", result.MatchedCount, result.ModifiedCount)
}
if result.UpsertedCount != 0 {
fmt.Printf("inserted a new document with ID %v\n", result.UpsertedID)
}

O resultado retornado é o seguinte

Connected to MongoDB!
Matched 2 documents and updated 2 documents.
Connection to MongoDB closed.

Excluir documentos MongoDB

Você pode usar collection.DeleteOne()ou collection.DeleteMany()excluir o documento. Se você passá-lo bson.D{{}}como um parâmetro de filtro, ele corresponderá a todos os documentos no conjunto de dados. Você também pode usar para collection. drop()excluir todo o conjunto de dados.

filter := bson.D{{"city","铁岭"}}
deleteResult, err := collection.DeleteMany(context.TODO(), filter)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult.DeletedCount)

O resultado retornado é o seguinte

Connected to MongoDB!
Deleted 2 documents in the trainers collection
Connection to MongoDB closed.

Obtenha o status do serviço MongoDB

Acima, apresentamos CRUD para MongoDB. Na verdade, ele também suporta muitas operações no MongoDB, como agregação , transações etc. A seguir, vamos apresentar o uso de golang para obter o status do serviço MongoDB. Após a execução, ele retornará um tipo de dados bson.Raw.

ctx, _ = context.WithTimeout(context.Background(), 30*time.Second)
serverStatus, err := client.Database("admin").RunCommand(
ctx,
bsonx.Doc{{"serverStatus", bsonx.Int32(1)}},
).DecodeBytes()
if err != nil {
fmt.Println(err)
}
fmt.Println(serverStatus)
fmt.Println(reflect.TypeOf(serverStatus))
version, err := serverStatus.LookupErr("version")
fmt.Println(version.StringValue())
if err != nil {
fmt.Println(err)
}

Link de referência
https://www.mongodb.com/blog/post/mongodb-go-driver-tutorial
https://godoc.org/go.mongodb.org/mongo-driver/mongo

Bem-vindo a todos para prestar atenção à minha conta pública pessoal "História de desenvolvimento de operação e manutenção"
Use o driver golang para operar o banco de dados MongoDB