在Golangð建造CRUD操作-DEV365 开发者社区

介绍：

嘿，那里ð，在本教程中，我们将使用Go-Fiber创建一个带有CRUD操作的Web API。

我们正在建造什么？

我们将使用CRUD操作构建一个待办事项清单API。

先决条件ð：

要继续进行教程，首先，您需要安装Golang，Fiber和PostgreSQL。如果您尚未在Fiber Web框架系列中完成以前的教程，则可以看到它们here：）

安装：

Golang
Go-Fiber：我们将在教程中看到这一点。
PostgreSQL
Gorm：我们将在本教程中从头开始理解。 ð

入门ð：

让我们通过使用以下命令创建主要项目目录todo-list-api开始。

mkdir todo-list-api
cd todo-list-api

现在初始化一个mod文件。 （如果您发布模块，则必须是通过GO Tools下载模块的路径。这将是您的代码存储库。）

go mod init <repository-name>

在我的情况下，存储库名称为github.com/Siddheshk02/todo-list-api。

安装光纤框架运行以下命令：

go get -u github.com/gofiber/fiber/v2

要安装GORM并安装Gorm Postgres驱动程序，请运行以下命令。：

go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres

初始化ð»：

让我们通过创建一个新的光纤实例来设置服务器。为此，创建一个文件main.go并向其添加以下代码：

package main

import "github.com/gofiber/fiber/v2"

func main() {
    app := fiber.New() // Creating a new instance of Fiber.
    list := app.Group("/list")

    list.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Welcome to the Todo-List-API Tutorial :)")
    }) // "/" - Default route to return the given string.

运行main.go后，

路线：

现在，让我们创建一个新的文件夹/软件包routes，该函数将包含routes.go，用于所有功能，由API端点调用。

routes.go：

package routes

import "github.com/gofiber/fiber/v2"

func GetTask(c *fiber.Ctx) error {
    return c.SendString("A Single Task") // for getting a single task.
}

func GetAllTasks(c *fiber.Ctx) error {
    return c.SendString("ALL Tasks") // for getting all the tasks.
}

func AddTask(c *fiber.Ctx) error {
    return c.SendString("Added a Task") // for adding a new task.
}

func DeleteTask(c *fiber.Ctx) error {
    return c.SendString("Deleted a Task") // for deleting a task.
}

func UpdateTask(c *fiber.Ctx) error {
    return c.SendString("Updated a Task") // for updating a task.
}

现在，让我们根据routes.go中的函数更新main.go，

package main

import (
    "github.com/Siddheshk02/todo-list-api/routes"
    "github.com/gofiber/fiber/v2"
)

func main() {
    app := fiber.New()

    list := app.Group("/list")

    list.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Welcome to the Todo-List-API Tutorial :)")
    }) // "/" - Default route to return the given string.

    list.Get("/tasks", routes.GetAllTasks) //Get endpoint for fetching all the tasks.

    list.Get("/task/:id", routes.GetTask) //Get endpoint for fetching a single task.

    list.Post("/add_task", routes.AddTask) //Post endpoint for add a new task.

    list.Delete("/delete_task/:id", routes.DeleteTask) //Delete endpoint for removing an existing task.

    list.Patch("/update_task/:id", routes.UpdateTask) //Patch endpoint for updating an existing task.

    app.Listen(":8000")
}

这是构建API将所有路由的构建时的约定，这将标记为list-api。为此，我们正在使用app.Group()函数。您可以使用此之后的资源名称为特定资源定义所有其余端点。

现在，类似于routes软件包，我们创建一个文件夹/软件包database并在其中创建dbconn.go文件。

在dbconn.go中，让我们定义任务实体并添加数据库凭据：

type Task struct {
    gorm.Model
    Name   string `json:"name"`
    Status string `json:"status"`
}

const (
    host     = "localhost"
    port     = 5432
    user     = "postgres"
    password = "<your-password>"
    dbname   = "todo-list-api"
)

var dsn string = fmt.Sprintf("host=%s port=%d user=%s "+
    "password=%s dbname=%s sslmode=disable TimeZone=Asia/Shanghai",
    host, port, user, password, dbname)

func InitDB() error {
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return err
    }

    db.AutoMigrate(&Task{})

    return nil
}

InitDB，定义了该函数，该函数将尝试建立与数据库的连接。如果不存在数据库表，它将创建一个带有名称task的新数据库表。

AutoMigrate呼叫如果尚未存在，则有助于创建表。数据库迁移通常是随着时间的推移改变数据库结构的原因，这有助于确保数据库结构正确迁移到最新版本。

函数InitDB在main.go中调用。使用以下代码更新main.go。

func main() {
    app := fiber.New()
    dbErr := database.InitDB()

    if dbErr != nil {
        panic(dbErr)
    }

    list := app.Group("/list")

    list.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Welcome to the Todo-List-API Tutorial :)")
    }) // "/" - Default route to return the given string.

    ...
}

邮政：

现在，让我们在dbconn.go文件中创建函数CreateTask，以添加新任务。

func CreateTask(name string, status string) (Task, error) {
    var newTask = Task{Name: name, Status: status}

    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return newTask, err
    }
    db.Create(&Task{Name: name, Status: status})

    return newTask, nil
}

调用函数CreateTask，在routes.go中创建一个AddTask函数，

func AddTask(c *fiber.Ctx) error {
    newTask := new(database.Task)

    err := c.BodyParser(newTask)
    if err != nil {
        c.Status(400).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
        return err
    }

    result, err := database.CreateTask(newTask.Name, newTask.Status)
    if err != nil {
        c.Status(400).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
        return err
    }

    c.Status(200).JSON(&fiber.Map{
        "data":    result,
        "success": true,
        "message": "Task added!",
    })
    return nil
}

，最好将预定义结构作为对API请求的响应以及状态代码和消息。

我们使用BodyParser函数将POST请求数据转换为我们的模型格式。

我正在使用Postman工具发送请求，您可以使用任何将JSON发送到邮政请求的工具。

得到：

现在，添加一个函数，用于从记录中获取任务。为此，让我们更新dbconn.go文件中添加GetallTasks函数，该函数将获取任务列表。

func GetallTasks() ([]Task, error) {
    var tasks []Task

    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return tasks, err
    }

    db.Find(&tasks)

    return tasks, nil
}

现在更新routes.go文件中的GetAllTasks函数，

func GetAllTasks(c *fiber.Ctx) error {
    result, err := database.GetallTasks()
    if err != nil {
        return c.Status(500).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
    }

    return c.Status(200).JSON(&fiber.Map{
        "data":    result,
        "success": true,
        "message": "All Tasks",
    })
}

在Get请求中，我们不需要发送任何数据。我们只需要添加的所有任务的列表。如果数据库调用有任何错误，请发送状态代码500。

得到一个任务：

现在，对于通过“ ID”获得一个任务，让我们在dbconn.go文件中添加一个新函数Gettask。

func Gettask(id string) (Task, error) {
    var task Task

    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return task, err
    }

    db.Where("ID = ?", id).First(&task)
    return task, nil
}

db.Where()用于检查特定“ ID”的任务。

让我们在routes.go文件中创建一个GetTask()函数。

func GetTask(c *fiber.Ctx) error {

    id := c.Params("id")

    if id == "" {

        return c.Status(500).JSON(&fiber.Map{

            "message": "id cannot be empty",

        })
    }

    result, err := database.Gettask(id)
    if err != nil {
        return c.Status(500).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
    }

    return c.Status(200).JSON(&fiber.Map{
        "data":    result,
        "success": true,
        "message": "",
    })
}

在这里，我们使用称为param的光纤函数获得“ ID”，该功能接受一个参数，该参数是期望参数的名称。如果不存在“ ID”，则将错误发送给使用光纤函数的用户。

当GetTask()函数称为

时，将传递此“ ID”。

删除：

用于从列表中删除任务，让我们在dbconn.go文件中添加Deletetask函数。

func Deletetask(id string) error {
    var task Task

    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})

    if err != nil {
        return err
    }

    db.Where("ID = ?", id).Delete(&task)
    return nil

}

此函数类似于Gettask()函数唯一的区别是，在这里我们使用Delete(&task)删除特定任务。

现在，使用以下代码更新routes.go文件中的DeleteTask()函数，

func DeleteTask(c *fiber.Ctx) error {
    id := c.Params("id")

    if id == "" {

        return c.Status(500).JSON(&fiber.Map{

            "message": "id cannot be empty",
        })
    }

    err := database.Deletetask(id)
    if err != nil {
        return c.Status(500).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
    }

    return c.Status(200).JSON(&fiber.Map{
        "data":    nil,
        "success": true,
        "message": "Task Deleted Successfully",
    })

}

类似于函数GetTask()，我们正在采用需要删除的任务的“ ID”参数。如果不存在“ ID”，则将错误发送给使用光纤函数的用户。

更新：

为此，在dbconn.go文件中创建一个新函数Updatetask并添加以下代码，

func Updatetask(name string, status string, id string) (Task, error) {
    var newTask = Task{Name: name, Status: status}

    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        return newTask, err
    }

    db.Where("ID = ?", id).Updates(&Task{Name: newTask.Name, Status: newTask.Status})
    return newTask, nil
}

在这里，我们已经传递了需要更新的任务的名称，状态以及ID。 Updates()功能用于更新表的多列。

现在，让我们在routes.go文件中更新UpdateTask()函数，我们将通过该函数在dbconn.go file中致电并将参数（名称，状态和ID）传递到Updatetask()函数。

func UpdateTask(c *fiber.Ctx) error {
    id := c.Params("id")

    if id == "" {

        return c.Status(500).JSON(&fiber.Map{

            "message": "id cannot be empty",
        })
    }

    newTask := new(database.Task)

    err := c.BodyParser(newTask)
    if err != nil {
        c.Status(400).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
        return err
    }

    result, err := database.Updatetask(newTask.Name, newTask.Status, id)

    if err != nil {
        c.Status(400).JSON(&fiber.Map{
            "data":    nil,
            "success": false,
            "message": err,
        })
        return err
    }

    c.Status(200).JSON(&fiber.Map{
        "data":    result,
        "success": true,
        "message": "Task Updated!",
    })
    return nil
}

在这里，任务名称为“ ID：1”是Fiber Tutorial Series现在已更新为Todo-list-API，保持status值相同。

因此，现在您已经成功创建了CRUD操作 - 创建，读取，更新，删除。

您可以在此处找到本教程的完整代码存储库ðGithub

结论ð：

我希望您必须了解如何使用Go-Fiber，PostgreSQL DB和GORM创建REST API。现在，尝试使用您的想法来构建一些东西，以使您更快地学习：）

要获取有关Golang概念，项目等的更多信息，并且在教程上保持最新信息确实关注Siddhesh on Twitter和GitHub。

在此之前

介绍 ：

我们正在建造什么？

先决条件ð：

安装：

入门ð：

初始化ð»：

路线：

邮政 ：

得到 ：

得到一个任务：

删除 ：

更新 ：

结论ð：

介绍：

邮政：

得到：

删除：

更新：