在Golangð建造CRUD操作
#postgres #go #fiber #gorm

介绍 :

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

我们正在建造什么?

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

Image description

先决条件ð:

要继续进行教程,首先,您需要安装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后,

Image description

路线:

现在,让我们创建一个新的文件夹/软件包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呼叫如果尚未存在,则有助于创建表。数据库迁移通常是随着时间的推移改变数据库结构的原因,这有助于确保数据库结构正确迁移到最新版本。

函数InitDBmain.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发送到邮政请求的工具。

Image description

得到 :

现在,添加一个函数,用于从记录中获取任务。为此,让我们更新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。

Image description

得到一个任务:

现在,对于通过“ 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”。

Image description

删除 :

用于从列表中删除任务,让我们在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”,则将错误发送给使用光纤函数的用户。

Image description

更新 :

为此,在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
}

Image description

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

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

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

结论ð:

Image description

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

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

在此之前