在 Ubuntu 20.04 上使用 Golang 和 MongoDB 创建 CRUD 应用程序

登录到您的MongoDB数据库。替换为数据库的管理员帐户。mongo_db_admin
```
$ mongosh -u mongo_db_admin -p --authenticationDatabase admin
```
出现提示时，输入MongoDB帐户的密码，然后按继续。接下来，运行下面的语句以创建数据库。ENTERshop_db
```
test> use shop_db
```
确认已切换到新数据库。shop_db
```
switched to db shop_db
```

接下来，使用 MongoDB 函数在新集合中插入三个文档。productsinsertMany()

shop_db> db.products.insertMany([

            {"product_id" : 1,

             "product_name" : "LEATHER BELT",

             "retail_price" : 24.35   

            },

            {"product_id" : 2,

             "product_name" : "WINTER JACKET",

             "retail_price" : 99.95    

            },

            {"product_id" : 3,

             "product_name" : "WOOLEN SWEATER",

             "retail_price" : 43.20

            }  

           ]);

通过确认下面的输出来确保命令已成功。

{

  acknowledged: true,

  insertedIds: {

    '0': ObjectId("62188b2358979df39bbcf178"),

    '1': ObjectId("62188b2358979df39bbcf179"),

    '2': ObjectId("62188b2358979df39bbcf17a")

  }

}

接下来，使用以下语句查询集合以确保数据已到位。products
```
shop_db> db.products.find()
```

您应该获得所有产品的列表以及相关的产品，如下所示。_ids

[

  {

    _id: ObjectId("62188b2358979df39bbcf178"),

    product_id: 1,

    product_name: 'LEATHER BELT',

    retail_price: 24.35

  },

  {

    _id: ObjectId("62188b2358979df39bbcf179"),

    product_id: 2,

    product_name: 'WINTER JACKET',

    retail_price: 99.95

  },

  {

    _id: ObjectId("62188b2358979df39bbcf17a"),

    product_id: 3,

    product_name: 'WOOLEN SWEATER',

    retail_price: 43.2

  }

]

从 MongoDB 服务器注销。
```
shop_db> quit
```
现在，您已经设置了数据库、集合和示例文档。在接下来的步骤中，您将使用 Golang 语言创建一些脚本来操作您的 MongoDB 集合。shop_dbproducts

4. 创建文件`main.go`

该文件将保存应用程序的函数。这是执行应用程序时触发的主要方法。main.gomain()

在创建文件的源代码之前，请创建一个目录以将源代码与其余 Linux 文件分开。main.goproject
```
$ mkdir project
```
然后，切换到新目录。project
```
$ cd project
```
接下来，使用文本编辑器打开一个新文件以进行编辑。nanomain.go
```
$ nano main.go
```

打开文件后，在文件中输入以下信息。将替换为 MongoDB 用户帐户的正确值。main.gomongo_db_adminEXAMPLE_PASSWORD

package main



import (

    "context"

    "net/http"

    "encoding/json" 

    _"log" 

    "fmt" 

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

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

)



const (  

    dbUser = "mongo_db_admin"

    dbPass = "EXAMPLE_PASSWORD"

    dbName = "shop_db"

)



func main() {

     http.HandleFunc("/api/v1/products", requestHandler)

     http.ListenAndServe(":8080", nil)

}



func requestHandler(w http.ResponseWriter, req *http.Request) {



    w.Header().Set("Content-Type", "application/json")



    response := map[string]interface{}{}



    ctx := context.Background()



    client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://" + dbUser + ":" + dbPass + "@localhost:27017"))



    if err != nil { 

        fmt.Println(err.Error())

    } 



    collection := client.Database(dbName).Collection("products")  



    data := map[string]interface{}{} 



    err = json.NewDecoder(req.Body).Decode(&data)



    if err != nil { 

        fmt.Println(err.Error())

    }



    switch req.Method {

        case "POST":

            response, err = createRecord(collection, ctx, data)

        case "GET":

            response, err = getRecords(collection, ctx)

        case "PUT":

            response, err = updateRecord(collection, ctx, data)

        case "DELETE":

            response, err = deleteRecord(collection, ctx, data)

    }



    if err != nil { 

        response = map[string]interface{}{"error": err.Error(),}  

    } 



    enc := json.NewEncoder(w)

    enc.SetIndent("", "  ")



    if err := enc.Encode(response); err != nil {

        fmt.Println(err.Error())

    }   

}

完成编辑后保存并关闭文件。
在上面的文件中，您将创建一个 Web 服务器，该服务器使用语句和 .8080http.HandleFunc("/api/v1/products", requestHandler)http.ListenAndServe(":8080", nil)
在该函数下，您将连接到之前创建的 MongoDB 实例。接下来，使用 Golang 语句通过传递集合引用将 HTTP 请求路由到相应的 CRUD 函数。最后，您将使用 JSON 函数以人类可读的格式格式化和输出数据。requestHandler()switchproducts
创建文件后，现在将在不同的文件上设置单独的函数，以处理应用程序的所有 CRUD 操作。main.go

5. 设置新文件`create_record.go`

要为 CRUD 操作设置的第一个文件是该文件。此文件包含用于将文档插入集合的功能。create_record.goproducts

运行以下命令以设置文件。create_record.go
```
$ nano create_record.go
```

接下来，在文件中输入以下信息。

package main



import (

    "context"      

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

)



func createRecord(collection *mongo.Collection, ctx context.Context, data map[string]interface{})(map[string]interface{}, error){     



    req, err := collection.InsertOne(ctx, data)



    if err != nil { 

        return nil, err                    

    }



    insertedId := req.InsertedID



    res := map[string]interface{}{

               "data" : map[string]interface{}{                            

                    "insertedId": insertedId,

                },

           } 



    return res, nil

}

保存并关闭文件。
上面文件中的主要功能是将BSON有效负载从请求HTTP客户端保存到MongoDB数据库。在上述文件下，如果语句执行没有任何错误，则返回新文档的。collection.InsertOne(ctx, data)insertedId
接下来，您将设置一个函数来从 MongoDB 集合中删除文档。

6. 创建文件`delete_record.go`

与任何其他应用程序一样，如果不再需要记录，则必须提供从集合中删除记录的功能。products

使用打开一个新文件。delete_record.gonano
```
$ nano delete_record.go
```

接下来，在文件中输入以下信息。delete_record.go

package main



import (

    "context"          

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

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

)



func deleteRecord(collection *mongo.Collection, ctx context.Context, data map[string]interface{})(map[string]interface{}, error){



    _, err := collection.DeleteOne(ctx, bson.M{"product_id": data["product_id"]})



    if err != nil { 

        return nil, err                    

    }     



    res := map[string]interface{}{

               "data" : "Document deleted successfully.",   

           } 



    return res, nil

}

保存并关闭文件。
在上面的文件中，您正在使用该函数从MongoDB数据库中删除文档。为了确保删除正确的文档，请使用语句检索要删除的项目。换句话说，在向应用程序提交请求时，您应该在 HTTP 有效负载中传递 a。collection.DeleteOne(...)product_idbson.M{"product_id": data["product_id"]}product_idDELETE
接下来，您将设置一个函数来更新文档。

7. 创建一个新文件`update_record.go`

您将使用该文件对文档进行更改。此文件下的 function（）依赖于包含要更新的字段的有效负载以及文档的唯一性。update_record.goupdateRecord()product_id

用于打开新文件。nanoupdate_record.go
```
$ nano update_record.go
```

接下来，在文件中输入以下信息。update_record.go

package main



import (

    "context"

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

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

)



func updateRecord(collection *mongo.Collection, ctx context.Context, data map[string]interface{})(map[string]interface{}, error){            



    filter := bson.M{"product_id": data["product_id"]}

    fields := bson.M{"$set": data}



    _, err := collection.UpdateOne(ctx, filter, fields)



    if err != nil { 

        return nil, err                    

    }



    res := map[string]interface{}{

               "data" : "Document updated successfully.",   

           } 



    return res, nil

}

在上面的文件中，您首先使用语句为要更新的文档提供一个参数。然后，您将使用语句提交新的文档值。此处的值来自请求客户端提交的 HTTP 有效负载。filterfilter := bson.M{"product_id": data["product_id"]}fields := bson.M{"$set": data}data
接下来，使用该函数向集合提交更新请求。在下一步中，您将创建一个函数，用于从 MongoDB 集合中检索记录。collection.UpdateOne(ctx, filter, fields)

8. 创建一个新文件`get_records.go`

MongoDB API for Golang具有非常直观的功能，用于以地图的形式从数据库中检索文档。您将使用这些函数查询数据库集合并将文档返回到之前创建的文件。main.go

用于创建新文件。nanoget_records.go
```
$ nano get_records.go
```

然后，在文件中输入以下信息。get_records.go

package main



import (

    "context"          

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

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

)



func getRecords(collection *mongo.Collection, ctx context.Context)(map[string]interface{}, error){ 



    cur, err := collection.Find(ctx, bson.D{})



    if err != nil { 

        return nil, err

    }



    defer cur.Close(ctx) 



    var products []bson.M           



    for cur.Next(ctx) {



        var product bson.M



        if err = cur.Decode(&product); err != nil {

            return nil, err

        }



        products = append(products, product)



    }



    res := map[string]interface{}{}



    res = map[string]interface{}{

              "data" : products,   

          }             



    return res, nil

}

保存并关闭文件。
在上面的文件中，您将使用该函数返回已保存在集合中的文档的光标。然后，您将使用循环循环访问稍后附加到数组的文档。cur, err := collection.Find(ctx, bson.D{})productsfor cur.Next(ctx) {...}products []bson.M
最后，您将数据作为映射返回到调用函数。现在，你已为应用设置了所有 CRUD 函数。在下一步中，您将测试应用程序以确保一切按预期工作。[string]interface{}

9. 测试 Golang 应用程序

在此步骤中，你将测试应用程序，以确保它可以处理所有 CRUD 操作，而不会出现任何错误。

导入 Golang 应用程序的 MongoDB 驱动程序。
```
$ go get go.mongodb.org/mongo-driver/mongo
```
接下来，执行以下命令以运行应用程序。以下命令允许应用程序启动 Web 服务器并侦听端口上的传入 HTTP 连接，并具有阻止功能。不要在此 SSH 终端窗口上运行任何其他命令。8080
```
$ go run ./
```
接下来，在单独的终端窗口中建立与服务器的新 SSH 会话。

尝试通过运行以下命令创建新文档。curl

$ curl -X POST localhost:8080/api/v1/products -H "Content-Type: application/json" -d '{"product_id": 4, "product_name": "WIRELESS KEYBOARD",  "retail_price": 45.30}'

您应该获得新记录，如下所示。insertedId

{

  "data": {

    "insertedId": "621c9acf3f4e8882c3eeabef"

  }

}

接下来，使用以下命令从集合中检索所有文档。products
```
$ curl -X GET localhost:8080/api/v1/products
```

现在，您应该会看到四个文档的列表。前三个是首次初始化数据库时设置的文档，最后一个 record（）是您刚刚使用该命令插入的文档。WIRELESS KEYBOARDcurl

{

  "data": [

    {

      "_id": "621c9aaf35ece941bcc5b80d",

      "product_id": 1,

      "product_name": "LEATHER BELT",

      "retail_price": 24.35

    },

    {

      "_id": "621c9aaf35ece941bcc5b80e",

      "product_id": 2,

      "product_name": "WINTER JACKET",

      "retail_price": 99.95

    },

    {

      "_id": "621c9aaf35ece941bcc5b80f",

      "product_id": 3,

      "product_name": "WOOLEN SWEATER",

      "retail_price": 43.2

    },

    {

      "_id": "621c9acf3f4e8882c3eeabef",

      "product_id": 4,

      "product_name": "WIRELESS KEYBOARD",

      "retail_price": 45.3

    }

  ]

}

接下来，运行以下命令以使用 of 更新文档并将其 from 更改为。product_id1product_nameLEATHER BELTMETAL BUCKLE LEATHER BELT

$ curl -X PUT localhost:8080/api/v1/products -H "Content-Type: application/json" -d '{"product_id": 1, "product_name": "METAL BUCKLE LEATHER BELT",  "retail_price": 45.30}'

以下输出确认你已成功更新产品详细信息。
```
{

  "data": "Document updated successfully."

}
```

通过运行以下命令删除带有 of （）的文档。product_id4WIRELESS KEYBOARD

$ curl -X DELETE localhost:8080/api/v1/products -H "Content-Type: application/json" -d '{"product_id": 4}'

您应该会收到以下确认消息。

{

  "data": "Document deleted successfully."

}

接下来，再次检索记录，以确保已在集合中执行和操作。UPDATEDELETEproducts
```
$ curl -X GET localhost:8080/api/v1/products
```

从下面的输出中可以看到，您已经删除了带有 of 的文档，并且您还成功地将文档的值更新为 of 到。product_id4product_id1METAL BUCKLE LEATHER BELT

{

  "data": [

    {

      "_id": "621c9aaf35ece941bcc5b80d",

      "product_id": 1,

      "product_name": "METAL BUCKLE LEATHER BELT",

      "retail_price": 45.3

    },

    {

      "_id": "621c9aaf35ece941bcc5b80e",

      "product_id": 2,

      "product_name": "WINTER JACKET",

      "retail_price": 99.95

    },

    {

      "_id": "621c9aaf35ece941bcc5b80f",

      "product_id": 3,

      "product_name": "WOOLEN SWEATER",

      "retail_price": 43.2

    }

  ]        

}

您的代码现在按预期工作，并且能够处理所有 CRUD 操作。

10.结论

在本指南中，您使用Golang编程语言在Ubuntu 20.04服务器上连接和操作MongoDB集合中的数据。使用 Golang 设计下一个数据驱动的 MongoDB 应用程序时，请使用本指南中的函数。

在 Ubuntu 20.04 上使用 Golang 和 MongoDB 创建 CRUD 应用程序

1.介绍

2.准备工作

3. 创建 MongoDB 数据库

4. 创建文件`main.go`

5. 设置新文件`create_record.go`

6. 创建文件`delete_record.go`

7. 创建一个新文件`update_record.go`

8. 创建一个新文件`get_records.go`

9. 测试 Golang 应用程序

10.结论

相关推荐

联系本站

最新文章

热门文章

热门标签

网站统计

其他操作