标签： Golang

1.介绍

MongoDB是最好的基于文档的开源数据库管理系统之一。由于其灵活的设计模式，您可以在各种业务系统中使用该应用程序，这是传统 SQL 数据库无法满足的。

凭借其强大的数据库模式，MongoDB平台适用于设置用于管理产品数据，创建内容管理系统（CMS）的系统，以及在大多数情况下存储和查询大数据的系统。

另一方面，Golang 是一种快速、可扩展且易于学习的现代编程语言，用于编码高级软件应用程序。由于MongoDB为Golang语言提供了全面的API，因此您可以将这两个应用程序一起使用，为金融，电子商务，研究等提供解决方案。

在本指南中，您将使用 MongoDB 设置一个数据库，并从自定义 Golang 应用程序与其通信，以在 Ubuntu 20.04 服务器上执行基本的创建、读取、更新和删除 （CRUD） 操作。

2.准备工作

要继续执行本指南，请确保您已获得以下各项：

• Ubuntu 20.04 服务器。
• 具有 sudo 权限的非 root 用户。
• 使用用户帐户和密码配置的 MongoDB 数据库。
• 一个戈朗包。

3. 创建 MongoDB 数据库

数据驱动应用程序必须能够存储、检索、更新和删除记录。只有在为软件设置数据库后，才能执行所有这些操作。通过 SSH 连接到您的服务器，然后按照以下步骤初始化 MongoDB 数据库。

1. 登录到您的MongoDB数据库。替换为数据库的管理员帐户。mongo_db_admin

   $ mongosh -u mongo_db_admin -p --authenticationDatabase admin

2. 出现提示时，输入MongoDB帐户的密码，然后按继续。接下来，运行下面的语句以创建数据库。ENTERshop_db

   test> use shop_db

3. 确认已切换到新数据库。shop_db

   switched to db shop_db

4. 接下来，使用 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
   
               }  
   
              ]);

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

   {
   
     acknowledged: true,
   
     insertedIds: {
   
       '0': ObjectId("62188b2358979df39bbcf178"),
   
       '1': ObjectId("62188b2358979df39bbcf179"),
   
       '2': ObjectId("62188b2358979df39bbcf17a")
   
     }
   
   }

6. 接下来，使用以下语句查询集合以确保数据已到位。products

   shop_db> db.products.find()

7. 您应该获得所有产品的列表以及相关的产品，如下所示。_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
   
     }
   
   ]

8. 从 MongoDB 服务器注销。

   shop_db> quit

9. 现在，您已经设置了数据库、集合和示例文档。在接下来的步骤中，您将使用 Golang 语言创建一些脚本来操作您的 MongoDB 集合。shop_dbproducts

4. 创建文件main.go

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

1. 在创建文件的源代码之前，请创建一个目录以将源代码与其余 Linux 文件分开。main.goproject

   $ mkdir project

2. 然后，切换到新目录。project

   $ cd project

3. 接下来，使用文本编辑器打开一个新文件以进行编辑。nanomain.go

   $ nano main.go

4. 打开文件后，在文件中输入以下信息。将 替换为 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())
   
       }   
   
   }

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

5. 设置新文件create_record.go

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

1. 运行以下命令以设置文件。create_record.go

   $ nano create_record.go

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

   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
   
   }

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

6. 创建文件delete_record.go

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

1. 使用 打开一个新文件 。delete_record.gonano

   $ nano delete_record.go

2. 接下来，在文件中输入以下信息。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
   
   }

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

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

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

1. 用于打开新文件。nanoupdate_record.go

   $ nano update_record.go

2. 接下来，在文件中输入以下信息。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
   
   }

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

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

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

1. 用于创建新文件。nanoget_records.go

   $ nano get_records.go

2. 然后，在文件中输入以下信息。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
   
   }

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

9. 测试 Golang 应用程序

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

1. 导入 Golang 应用程序的 MongoDB 驱动程序。

   $ go get go.mongodb.org/mongo-driver/mongo

2. 接下来，执行以下命令以运行应用程序。以下命令允许应用程序启动 Web 服务器并侦听端口上的传入 HTTP 连接，并具有阻止功能。不要在此 SSH 终端窗口上运行任何其他命令。8080

   $ go run ./

3. 接下来，在单独的终端窗口中建立与服务器的新 SSH 会话。
4. 尝试通过运行以下命令创建新文档。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}'

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

   {
   
     "data": {
   
       "insertedId": "621c9acf3f4e8882c3eeabef"
   
     }
   
   }

6. 接下来，使用以下命令从集合中检索所有文档。products

   $ curl -X GET localhost:8080/api/v1/products

7. 现在，您应该会看到四个文档的列表。前三个是首次初始化数据库时设置的文档，最后一个 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
   
       }
   
     ]
   
   }

8. 接下来，运行以下命令以使用 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}'

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

   {
   
     "data": "Document updated successfully."
   
   }

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

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

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

    {
    
      "data": "Document deleted successfully."
    
    }

12. 接下来，再次检索记录，以确保已在集合中执行 和 操作。UPDATEDELETEproducts

    $ curl -X GET localhost:8080/api/v1/products

13. 从下面的输出中可以看到，您已经删除了带有 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
    
        }
    
      ]        
    
    }

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

10.结论

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