golang 使用 mongodb

安装mongo-driver

go get go.mongodb.org/mongo-driver

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

// You will be using this Trainer type later in the program
type Trainer struct {
    Name string
    Age  int
    City string
}

func main() {
    // Rest of the code will go here
}

连接服务器

// Set client options
clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

// Connect to MongoDB
client, err := mongo.Connect(context.TODO(), clientOptions)

if err != nil {
    log.Fatal(err)
}

// Check the connection
err = client.Ping(context.TODO(), nil)

if err != nil {
    log.Fatal(err)
}

fmt.Println("Connected to MongoDB!")

**断开连接 **

err = client.Disconnect(context.TODO())

if err != nil {
    log.Fatal(err)
}
fmt.Println("Connection to MongoDB closed.")

目录结构

image.png

drivers/mongo.go

/**
 * @Author : jinchunguang
 * @Date : 19-11-5 下午3:07
 * @Project : go-mongo
 */
package drivers

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

type MongoDrivers struct {
    Client *mongo.Client
    Database string
}

var MgoClient *mongo.Client
var MgoDbName string

// 初始化
func Init() {
    MgoClient=Connect()
    MgoDbName="test"
}

// 连接
func Connect() *mongo.Client {

    // 设置客户端参数
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    // 连接到MongoDB
    client, err := mongo.Connect(context.TODO(), clientOptions)
    //defer client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }

    // 检查链接
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to MongoDB!")
    return client
}

// 关闭
func Close()  {

    err :=MgoClient.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
}%

models/mgo_model.go

/**
 * @Author : jinchunguang
 * @Date : 19-11-5 下午2:59
 * @Project : go-mongo
 */
package models

import (
    "context"
    "fmt"
    _ "fmt"
    "go-mongo/drivers"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
    "log"
    "strconv"
    "time"
)

// 集合名称
const TrainerCollectionName = "trainer"

// TrainerModel
type Mgo struct {
    collection *mongo.Collection
}

// NewTrainer
func NewMgo() *Mgo {
    mgo := new(Mgo)
    mgo.collection = drivers.MgoClient.Database(drivers.MgoDbName).Collection(TrainerCollectionName)
    return mgo
}

// 插入单个
func (m *Mgo) InsertOne(document interface{}) (insertResult *mongo.InsertOneResult) {
    insertResult, err := m.collection.InsertOne(context.TODO(), document)
    if err != nil {
        fmt.Println(err)
    }
    return
}

// 插入多个
func (m *Mgo) InsertMany(documents []interface{}) (insertManyResult *mongo.InsertManyResult) {
    insertManyResult, err := m.collection.InsertMany(context.TODO(), documents)
    if err != nil {
        fmt.Println(err)
    }
    return
}

// 查询单个
func (m *Mgo) FindOne(key string, value interface{}) *mongo.SingleResult {
    filter := bson.D{{key, value}}
    singleResult := m.collection.FindOne(context.TODO(), filter)
    if singleResult != nil {
        fmt.Println(singleResult)
    }
    return singleResult
}

// 查询count总数
func (m *Mgo) Count() (string, int64) {
    name := m.collection.Name()
    size, _ := m.collection.EstimatedDocumentCount(context.TODO())
    return name, size
}

// 按选项查询集合
// Skip 跳过
// Limit 读取数量
// Sort  排序   1 倒叙 ， -1 正序
func (m *Mgo) FindAll(Skip, Limit int64, sort int) *mongo.Cursor {
    SORT := bson.D{{"_id", sort}}
    filter := bson.D{{}}

    // where
    findOptions := options.Find()
    findOptions.SetSort(SORT)
    findOptions.SetLimit(Limit)
    findOptions.SetSkip(Skip)

    cur, err := m.collection.Find(context.TODO(), filter, findOptions)
    if err != nil {
        fmt.Println(err)
    }

    return cur
}

// 获取集合创建时间和编号
func (m *Mgo) ParsingId(result string) (time.Time, uint64) {
    temp1 := result[:8]
    timestamp, _ := strconv.ParseInt(temp1, 16, 64)
    dateTime := time.Unix(timestamp, 0) // 这是截获情报时间 时间格式 2019-04-24 09:23:39 +0800 CST
    temp2 := result[18:]
    count, _ := strconv.ParseUint(temp2, 16, 64) // 截获情报的编号
    return dateTime, count
}

// 删除
func (m *Mgo) Delete(key string, value interface{}) int64 {
    filter := bson.D{{key, value}}
    count, err := m.collection.DeleteOne(context.TODO(), filter, nil)
    if err != nil {
        fmt.Println(err)
    }
    return count.DeletedCount

}

// 删除多个
func (m *Mgo) DeleteMany(key string, value interface{}) int64 {
    filter := bson.D{{key, value}}
    count, err := m.collection.DeleteMany(context.TODO(), filter)
    if err != nil {
        fmt.Println(err)
    }
    return count.DeletedCount
}

// 更新一个
func (m *Mgo) UpdateOne(key string, value interface{}, update interface{}) (updateResult *mongo.UpdateResult) {
    filter := bson.D{{key, value}}
    updateResult, err := m.collection.UpdateOne(context.TODO(), filter, update)
    if err != nil {
        log.Fatal(err)
    }
    return updateResult
}% 

main.go

/**
 * @Author : jinchunguang
 * @Date : 19-11-5 下午2:50
 * @Project : go-mongo
 */
package main

import (
    "context"
    "fmt"
    "go-mongo/drivers"
    "go-mongo/models"
    "go.mongodb.org/mongo-driver/bson"
    "log"
)

type Trainer struct {
    Name string
    Age  int
    City string
}

func main() {

    // 初始化数据库
    drivers.Init()

    // 单个插入
    ash := Trainer{"Ash", 10, "Pallet Town"}
    InsertOneResult := models.NewMgo().InsertOne(ash)
    fmt.Println("Inserted a single document: ", InsertOneResult)

    // 插入多个值
    misty := Trainer{"Misty", 10, "Cerulean City"}
    brock := Trainer{"Brock", 15, "Pewter City"}
    trainers := []interface{}{misty, brock}
    insertManyResult := models.NewMgo().InsertMany(trainers)
    fmt.Println("Inserted multiple documents: ", insertManyResult)

    // 更新
    update := bson.D{
        {"$inc", bson.D{
            {"age", 999},
        }},
    }
    updateResult := models.NewMgo().UpdateOne("name", "Ash", update)
    fmt.Printf("Matched %v documents and updated %v documents.\n", updateResult.MatchedCount, updateResult.ModifiedCount)

    // 查询一个
    var result Trainer
    models.NewMgo().FindOne("name", "Ash").Decode(&result)
    fmt.Printf("Found a single document: %+v\n", result)

    // 查询总数
    name, size := models.NewMgo().Count()
    fmt.Printf(" documents name: %+v documents size %d \n", name, size)

    // 查询多个记录
    var results []*Trainer
    cur := models.NewMgo().FindAll(0, size, 1)
    defer cur.Close(context.TODO())
    if cur != nil {
        fmt.Println("FindAll err:", cur)
    }
    for cur.Next(context.TODO()) {
        var elem Trainer
        err := cur.Decode(&elem)
        if err != nil {
            log.Fatal(err)
        }
        results = append(results, &elem)
    }
    if err := cur.Err(); err != nil {
        log.Fatal(err)
    }
    // 遍历结果
    for k, v := range results {

        fmt.Printf("Found  documents  %d  %v \n", k, v)
    }

    // 删除文件
    deleteResult := models.NewMgo().DeleteMany("name", "Ash")
    fmt.Printf("Deleted %v documents in the trainers collection\n", deleteResult)

    // 关闭连接
    // drivers.Close()

}

output

image.png

https://github.com/jinchunguang/go-mongo