Go 和 MongoDB：从头开始构建 CRUD API

想要创建一个具有强大后端的动态 Web 应用程序吗？ Go 和 MongoDB 就是最好的选择！这种强大的组合使您能够构建可扩展、高效的 API，轻松处理数据创建、读取、更新和删除 (CRUD)。

在这个适合初学者的指南中，我们将逐步介绍使用 Go 和 MongoDB 构建简单的 CRUD API 的过程。我们将介绍基本步骤，提供代码示例，并在此过程中提供有用的提示。

入门

首先，让我们设置我们的环境：

1. Go 安装： 从 https://go.dev/dl/ 下载并安装最新版本的 Go。
2. MongoDB 设置： 如果您没有运行 MongoDB，可以从 https://www.mongodb.com/try/download/community 下载并安装它。
3. IDE 或文本编辑器： 选择您喜欢的编码环境。一些流行的选项包括 VS Code、GoLand 或 Atom。

项目结构：

创建一个新的项目目录并按如下方式组织文件：

my-crud-api/
├── main.go
├── models/
│   └── user.go
├── handlers/
│   └── user.go
└── config/
    └── config.go

定义我们的模型

让我们从定义数据模型开始。对于此示例，我们将创建一个简单的 User 结构：

// models/user.go
package models

import (
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Name   string             `bson:"name,omitempty"`
    Email  string             `bson:"email,omitempty"`
    Age    int                `bson:"age,omitempty"`
    Active bool               `bson:"active,omitempty"`
}

说明：

• 我们使用 mongo-driver 包中的primitive.ObjectID 来表示唯一的 MongoDB 文档 ID。
• bson 标签对于将 Go 结构字段映射到 MongoDB 文档中的相应字段至关重要。

连接到 MongoDB

我们需要建立与 MongoDB 数据库的连接。在config目录下创建config.go文件：

// config/config.go
package config

import (
    "context"
    "fmt"
    "os"

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

func ConnectToMongoDB() (*mongo.Client, error) {
    uri := os.Getenv("MONGODB_URI")
    if uri == "" {
        return nil, fmt.Errorf("MONGODB_URI is not set")
    }

    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Ping(context.Background(), nil)
    if err != nil {
        return nil, err
    }

    return client, nil
}

说明：

• 我们使用 os.Getenv 从环境变量 MONGODB_URI 中检索 MongoDB 连接 URI。确保在您的环境中设置此变量。
• 我们使用 mongo-driver 包连接到 MongoDB 数据库并执行诸如 ping 数据库之类的基本操作。

建筑处理程序

现在，让我们为 CRUD 操作构建 API 处理程序。在 handlers 目录中，创建 user.go 文件：

// handlers/user.go
package handlers

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/your-username/my-crud-api/config"
    "github.com/your-username/my-crud-api/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// Create a new user
func CreateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.InsertOne(context.Background(), user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Get all users
func GetAllUsers(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    collection := client.Database("your_database_name").Collection("users")
    cursor, err := collection.Find(context.Background(), bson.D{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(context.Background())

    var users []models.User
    for cursor.Next(context.Background()) {
        var user models.User
        if err := cursor.Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        users = append(users, user)
    }

    json.NewEncoder(w).Encode(users)
}

// Get a user by ID
func GetUserByID(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    var user models.User
    if err := collection.FindOne(context.Background(), bson.M{"_id": id}).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

// Update a user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    var updatedUser models.User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    filter := bson.M{"_id": id}
    update := bson.M{"$set": updatedUser}
    result, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Delete a user
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.DeleteOne(context.Background(), bson.M{"_id": id})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

说明：

• 我们实现了 CRUD 操作：CreateUser、GetAllUsers、GetUserByID、UpdateUser 和 DeleteUser。
• 每个函数连接到 MongoDB，检索集合，执行相应的操作，并返回 JSON 响应。
• 我们处理潜在的错误并返回适当的 HTTP 状态代码。

设置主应用程序

最后，让我们将 main.go 文件中的所有内容结合在一起：

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/your-username/my-crud-api/handlers"
)

func main() {
    http.HandleFunc("/users", handlers.CreateUser)
    http.HandleFunc("/users", handlers.GetAllUsers)
    http.HandleFunc("/users/", handlers.GetUserByID)
    http.HandleFunc("/users/", handlers.UpdateUser)
    http.HandleFunc("/users/", handlers.DeleteUser)

    fmt.Println("Server running on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

说明：

• 我们使用相应的 HTTP 端点注册 API 处理程序。
• 我们启动服务器并监听端口 8080。

运行 API

1. 环境变量： 使用 MongoDB 连接字符串设置 MONGODB_URI 环境变量。
2. 构建并运行： 使用 go build 构建 Go 应用程序，然后使用 ./my-crud-api 运行它。

测试 API

您可以使用Postman或curl等工具测试您的API。

• 创建： 使用包含用户详细信息的 JSON 负载向 /users 发送 POST 请求。
• 阅读： 向 /users 发送 GET 请求以检索所有用户，或向 /users/?id={user_id} 发送 GET 请求以获取特定用户。
• 更新： 使用包含更新的用户详细信息的 JSON 负载向 /users/?id={user_id} 发送 PUT 请求。
• 删除： 向 /users/?id={user_id} 发送 DELETE 请求以删除用户。

成功秘诀

• 错误处理：始终处理潜在错误并返回有意义的 HTTP 状态代码。
• 安全性：为您的 API 实施适当的身份验证和授权机制。
• 数据库设计：精心设计数据库架构以优化性能和可扩展性。
• 文档： 记录您的 API 端点、请求/响应格式和错误代码。

恭喜！您已经使用 Go 和 MongoDB 成功构建了基本的 CRUD API。有了这个基础，您可以扩展 API 以处理更复杂的功能并构建令人印象深刻的 Web 应用程序。继续学习和探索 Go 和 MongoDB 的无限可能性！

以上是Go 和 MongoDB：从头开始构建 CRUD API的详细内容。更多信息请关注PHP中文网其他相关文章！