构建 API 接口和用户认证的实践指南 DAY 07｜ 青训营

分解和弦
116 阅读7分钟

构建 API 接口和用户认证的实践指南

当使用Go语言设计和构建API接口时，借助Go标准库中的net/http包来处理HTTP请求和响应，同时会结合RESTful设计原则来创建一个基本的API示例。在本文中，我将详细讲解如何使用Go语言构建一个RESTful API，涵盖路由处理、请求处理、数据编码和错误处理等方面。

设计资源和端点

在构建API之前，首先需要设计API的资源和端点。创建一个简单的待办事项（Todo）API，其中每个待办事项包含ID和描述。设计以下端点：

  1. 获取所有待办事项：GET /todos
  2. 获取特定待办事项：GET /todos/{id}
  3. 创建新待办事项：POST /todos
  4. 更新待办事项：PUT /todos/{id}
  5. 删除待办事项：DELETE /todos/{id}

初始化项目

首先，创建一个新的文件夹，例如todo-api，然后在该文件夹中创建一个名为main.go的文件。

导入必要的包

在main.go中，首先需要导入net/http包以及用于处理JSON编码解码的encoding/json包。

goCopy codepackage main
​
import (
    "encoding/json"
    "fmt"
    "net/http"
)

定义待办事项数据结构

接下来，定义待办事项的数据结构，以便在API中使用。创建一个Todo结构体，其中包含ID和Description字段。

goCopy codetype Todo struct {
    ID          int    `json:"id"`
    Description string `json:"description"`
}

初始化数据存储

为了演示，我们将使用一个简单的切片来模拟数据存储。在实际应用中，你可能会使用数据库等持久性存储。

goCopy codevar todos = []Todo{
    {ID: 1, Description: "Buy groceries"},
    {ID: 2, Description: "Finish work project"},
    {ID: 3, Description: "Go to the gym"},
}

创建获取所有待办事项的处理函数

我们首先创建一个处理函数来获取所有待办事项，并将它映射到相应的API端点。

goCopy codefunc GetTodos(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
​
    // 将待办事项切片编码为JSON并返回
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(todos)
}

在此函数中，首先检查请求方法是否为GET。如果不是GET请求，我们返回“Method not allowed”的错误响应。否则，我们设置响应的Content-Type头为application/json，然后使用json.NewEncoder将待办事项切片编码为JSON并写入响应。

创建获取特定待办事项的处理函数

接下来，创建一个处理函数来获取特定ID的待办事项。

goCopy codefunc GetTodoByID(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
​
    // 解析URL路径参数以获取ID
    id := 0
    _, err := fmt.Sscanf(r.URL.Path, "/todos/%d", &id)
    if err != nil {
        http.Error(w, "Invalid ID", http.StatusBadRequest)
        return
    }
​
    // 查找对应的待办事项
    var foundTodo Todo
    for _, todo := range todos {
        if todo.ID == id {
            foundTodo = todo
            break
        }
    }
​
    // 如果找到了待办事项，将其编码为JSON并返回；否则返回404 Not Found
    if foundTodo.ID != 0 {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(foundTodo)
    } else {
        http.NotFound(w, r)
    }
}

在这个处理函数中，执行类似于获取所有待办事项的检查，以确保请求方法为GET。然后，解析URL路径参数以获取待办事项的ID。如果解析失败，返回“Invalid ID”的错误响应。接着，遍历待办事项切片，查找具有匹配ID的待办事项。如果找到了待办事项，将其编码为JSON并写入响应，否则返回404 Not Found。

创建创建新待办事项的处理函数

我们继续创建一个处理函数，用于创建新的待办事项。

goCopy codefunc CreateTodo(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
​
    // 解码请求体中的JSON数据
    var newTodo Todo
    if err := json.NewDecoder(r.Body).Decode(&newTodo); err != nil {
        http.Error(w, "Invalid JSON data", http.StatusBadRequest)
        return
    }
​
    // 生成新的ID
    newID := len(todos) + 1
    newTodo.ID = newID
​
    // 将新的待办事项添加到切片中
    todos = append(todos, newTodo)
​
    w.WriteHeader(http.StatusCreated)
}

在这个处理函数中，首先检查请求方法是否为POST。如果不是POST请求，返回“Method not allowed”的错误响应。接着，使用json.NewDecoder从请求体中解码JSON数据到newTodo结构体。如果解码失败，返回“Invalid JSON data”的错误响应。

然后，生成一个新的ID，然后将其分配给newTodo结构体的ID字段。最后，将newTodo添加到待办事项切片中，并将响应状态码设置为201 Created。

创建更新待办事项的处理函数

我们继续创建一个处理函数，用于更新现有的待办事项。

goCopy codefunc UpdateTodoByID(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPut {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
​
    // 解析URL路径参数以获取ID
    id := 0
    _, err := fmt.Sscanf(r.URL.Path, "/todos/%d", &id)
    if err != nil {
        http.Error(w, "Invalid ID", http.StatusBadRequest)
        return
    }
​
    // 查找对应的待办事项
    var foundTodo *Todo
    for i := range todos {
        if todos[i].ID == id {
            foundTodo = &todos[i]
            break
        }
    }
​
    // 如果找到了待办事项，更新其描述
    if foundTodo != nil {
        // 解码请求体中的JSON数据
        if err := json.NewDecoder(r.Body).Decode(&foundTodo); err != nil {
            http.Error(w, "Invalid JSON data", http.StatusBadRequest)
            return
        }
​
        w.WriteHeader(http.StatusOK)
    } else {
        http.NotFound(w, r)
    }
}

在这个处理函数中，执行类似于获取特定待办事项的步骤，以确保请求方法为PUT。然后，查找具有匹配ID的待办事项，并将其保存在foundTodo指针中。

如果找到了待办事项，使用json.NewDecoder从请求体中解码JSON数据到foundTodo结构体。如果解码失败，返回“Invalid JSON data”的错误响应。如果一切正常，我们将响应状态码设置为200 OK。

创建删除待办事项的处理函数

最后，创建一个处理函数，用于删除指定ID的待办事项。

goCopy codefunc DeleteTodoByID(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodDelete {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
​
    // 解析URL路径参数以获取ID
    id := 0
    _, err := fmt.Sscanf(r.URL.Path, "/todos/%d", &id)
    if err != nil {
        http.Error(w, "Invalid ID", http.StatusBadRequest)
        return
    }
​
    // 查找对应的待办事项索引
    var foundIndex = -1
    for i := range todos {
        if todos[i].ID == id {
            foundIndex = i
            break
        }
    }
​
    // 如果找到了待办事项，从切片中删除
    if foundIndex != -1 {
        todos = append(todos[:foundIndex], todos[foundIndex+1:]...)
        w.WriteHeader(http.StatusNoContent)
    } else {
        http.NotFound(w, r)
    }
}

在这个处理函数中，执行类似于获取特定待办事项的步骤，以确保请求方法为DELETE。然后，查找具有匹配ID的待办事项，并将其索引保存在foundIndex变量中。

如果找到了待办事项，使用切片操作从切片中删除该待办事项，并将响应状态码设置为204 No Content。

注册路由和启动服务器

在主函数中，我们将注册上述处理函数到相应的API端点，并启动一个HTTP服务器来处理请求。

goCopy codefunc main() {
    http.HandleFunc("/todos", GetTodos)
    http.HandleFunc("/todos/", GetTodoByID)
    http.HandleFunc("/todos", CreateTodo).Methods("POST")
    http.HandleFunc("/todos/", UpdateTodoByID).Methods("PUT")
    http.HandleFunc("/todos/", DeleteTodoByID).Methods("DELETE")
​
    fmt.Println("Server started at :8080")
    http.ListenAndServe(":8080", nil)
}

在这里，我们使用http.HandleFunc将不同的处理函数映射到相应的API端点。注意/todos和/todos/两个端点，其中前者用于获取所有待办事项和创建新待办事项，后者用于获取、更新和删除特定待办事项。

启动服务器并测试

在终端中进入项目文件夹，然后运行以下命令启动服务器：

bashCopy code
go run main.go

服务器将会在localhost:8080上启动。可以使用工具如curl、Postman或浏览器来测试API接口。

  • 获取所有待办事项：发送GET请求到http://localhost:8080/todos
  • 获取特定待办事项：发送GET请求到http://localhost:8080/todos/{id}，将{id}替换为待办事项的实际ID
  • 创建新待办事项：发送POST请求到http://localhost:8080/todos，并在请求体中包含待办事项的JSON数据
  • 更新待办事项：发送PUT请求到http://localhost:8080/todos/{id}，将{id}替换为待办事项的实际ID，并在请求体中包含更新后的JSON数据
  • 删除待办事项：发送DELETE请求到http://localhost:8080/todos/{id}，将{id}替换为待办事项的实际ID

总结

通过使用Go语言的net/http包，可以轻松地构建RESTful API。了解如何定义数据结构、处理HTTP请求和响应、以及处理错误情况

avatar
文章
阅读
粉丝