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

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 应用程序时,请使用本指南中的函数。

赞(0)
未经允许不得转载:主机百科 » 在 Ubuntu 20.04 上使用 Golang 和 MongoDB 创建 CRUD 应用程序