pelaksanaan penghalaan daun golang

Dengan populariti bahasa Go dalam pembangunan web, semakin ramai pembangun cuba menggunakan bahasa Go untuk membangunkan aplikasi web. Dalam pembangunan aplikasi web, pelaksanaan penghalaan adalah bahagian yang sangat penting. Hari ini, kami akan memperkenalkan rangka kerja penghalaan berdasarkan bahasa Go – daun.

1. Apakah itu Daun?

Leaf ialah perpustakaan penghalaan bahasa Go yang ringan yang fleksibel, mudah digunakan dan cekap. Leaf bukan sahaja boleh digunakan untuk perkhidmatan HTTP, tetapi juga untuk pelaksanaan penghalaan pelbagai protokol rangkaian seperti WebSocket dan FTP.

Leaf boleh menyokong pelaksanaan API gaya RESTful, dan menyediakan fungsi middleware untuk menyokong pembangunan dan penggunaan middleware tersuai. Di samping itu, Leaf juga menyokong pemprosesan tersuai permintaan HTTP dan data tindak balas, yang boleh menampung pelbagai keperluan perniagaan khas.

Kod sumber Leaf dihoskan pada GitHub dan sumber terbuka di bawah lesen MIT, percuma untuk digunakan, diubah suai dan diedarkan.

2. Pelaksanaan penghalaan dalam Leaf

Pelaksanaan penghalaan dalam Leaf adalah sangat mudah, cuma buat objek penghalaan dan kemudian tambah peraturan penghalaan. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "github.com/vardius/leaf"
)

func main() {
    r := leaf.NewRouter()
    r.GET("/", func(c *leaf.Context) {
        fmt.Fprintln(c.Writer, "Hello, Leaf!")
    })
    
    r.Run(":8080")
}

Dalam kod di atas, kami mencipta objek penghalaan melalui fungsi NewRouter dan menambahkan peraturan penghalaan permintaan GET ke objek penghalaan Peraturan menentukan Laluan yang diminta ialah laluan akar /. Apabila permintaan GET mengakses pelayan, fungsi tanpa nama yang sepadan dengan peraturan penghalaan akan dilaksanakan. Kaedah pemadanan peraturan penghalaan menggunakan algoritma pemadanan awalan, jadi kami boleh meliputi laluan permintaan yang berbeza dengan mentakrifkan berbilang peraturan.

Dalam Leaf, peraturan penghalaan menyokong lulus parameter. Anda boleh menggunakan :param untuk mentakrifkan parameter, seperti yang ditunjukkan di bawah:

r.GET("/user/:id", func(c *leaf.Context) {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "User ID: %s", id)
})

Dalam contoh ini, kami mentakrifkan peraturan penghalaan untuk permintaan GET, yang menggunakan parameter :id. Apabila terdapat permintaan GET untuk mengakses /user/123, Leaf secara automatik akan memadankan peraturan penghalaan dan menghantar parameter 123 kepada pembolehubah id dalam fungsi tanpa nama. Kita boleh menggunakan c.Params untuk mendapatkan nilai parameter yang dihantar kepada peraturan penghalaan.

Leaf juga menyokong pengendalian kumpulan penghalaan. Kumpulan penghalaan ialah satu set peraturan penghalaan dengan awalan yang sama, yang boleh dilaksanakan melalui fungsi Group. Berikut ialah contoh:

r.Group("/api/v1", func() {
    r.GET("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "User ID: %s", id)
    })
    r.POST("/user", func(c *leaf.Context) {
        fmt.Fprintln(c.Writer, "Create User")
    })
    r.PUT("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "Update User: %s", id)
    })
    r.DELETE("/user/:id", func(c *leaf.Context) {
        id := c.Params["id"]
        fmt.Fprintf(c.Writer, "Delete User: %s", id)
    })
})

Dalam contoh di atas, kami menggunakan fungsi Group untuk mencipta kumpulan penghalaan yang mengandungi semua laluan permintaan bermula dengan /api/v1. Dalam kumpulan penghalaan, kami mentakrifkan beberapa peraturan penghalaan untuk permintaan HTTP, termasuk permintaan lulus parameter, GET, POST, PUT dan DELETE.

3. Sokongan middleware Leaf

Leaf juga menyokong pembangunan dan penggunaan middleware. Dalam Leaf, middleware ialah sekeping kod program yang mengendalikan antara permintaan dan respons. Middleware boleh melakukan pelbagai pemprosesan pada permintaan dan respons, seperti menambah pengepala permintaan, mengesahkan maklumat pengesahan, memproses parameter permintaan dan hasil tindak balas, dsb. Leaf menambah middleware melalui kaedah Use, contohnya:

r.Use(func(c *leaf.Context) {
    // do something before request
    c.Next() // 执行下一个中间件或匿名函数
    // do something after request
})

Dalam contoh ini, kami mentakrifkan middleware, dan kod dalam badan fungsi akan dilaksanakan sebelum permintaan dipadankan dengan peraturan penghalaan. Dalam middleware, kita boleh melaksanakan middleware atau fungsi tanpa nama seterusnya dalam peraturan penghalaan dengan memanggil c.Next(). Selepas melaksanakan fungsi tanpa nama, ia akan kembali ke middleware semasa untuk melaksanakan kod berikutnya.

Sudah tentu, Leaf juga menyokong panggilan berantai bagi berbilang middleware Anda boleh menambah berbilang middleware melalui kaedah AppendMiddleware, contohnya:

r.AppendMiddleware(A)
r.AppendMiddleware(B)
r.AppendMiddleware(C)

Dalam contoh di atas, kami menggunakan kaedah Tiga perisian tengah A, B, dan C telah ditambah dalam urutan. Apabila permintaan masuk, ia akan dilaksanakan secara berurutan. AppendMiddleware

4. Sokongan corak MVC Leaf

Leaf juga menyediakan sokongan pembangunan berdasarkan corak MVC. Dalam Leaf, kita boleh mentakrifkan pengawal melalui

, dan berbilang kaedah pemprosesan boleh ditakrifkan dalam pengawal. Pengawal boleh melaksanakan sebarang logik perniagaan, dan Leaf secara automatik memadankan kaedah dalam pengawal melalui peraturan penghalaan dan melaksanakannya. Berikut ialah contoh mudah: Controller

type UserController struct {
    leaf.Controller
}

func (c *UserController) GetUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "User ID: %s", id)
}

func (c *UserController) CreateUser() {
    fmt.Fprintln(c.Writer, "Create User")
}

func (c *UserController) UpdateUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "Update User: %s", id)
}

func (c *UserController) DeleteUser() {
    id := c.Params["id"]
    fmt.Fprintf(c.Writer, "Delete User: %s", id)
}

func main() {
    r := leaf.NewRouter()
    userController := &UserController{}
    r.Group("/api/v1", func() {
        r.GET("/user/:id", userController.GetUser)
        r.POST("/user", userController.CreateUser)
        r.PUT("/user/:id", userController.UpdateUser)
        r.DELETE("/user/:id", userController.DeleteUser)
    })
    r.Run(":8080")
}

Dalam contoh ini, kami mentakrifkan pengawal

dan melaksanakan UserController, GetUser, CreateUser dan UpdateUser di dalamnya Kaedah digunakan untuk mengendalikan GET, POST, PUT dan DELETE permintaan masing-masing. Dalam kumpulan penghalaan, kami memetakan kaedah ini kepada permintaan yang sepadan dan menentukan awalan peraturan penghalaan sebagai DeleteUser. /api/v1

5. Permintaan HTTP dan pemprosesan respons Leaf

Dalam Leaf, kami boleh memproses data permintaan dan respons HTTP mengikut keperluan perniagaan. Leaf menyediakan pelbagai kaedah untuk memproses data permintaan dan respons, seperti:

c.SetHeader(key, value) // 设置响应头
c.GetHeader(key) // 获取请求头
c.SetCookie(cookie) // 设置 Cookie
c.GetCookie(name) // 获取 Cookie
c.SetStatusCode(code int) // 设置响应状态码
c.WriteJSON(v interface{}) // 响应 JSON 数据
c.WriteFile(file string) // 响应文件
c.String(code int, s string) // 响应字符串

Melalui kaedah ini, kami boleh memproses data permintaan dan respons dengan mudah.

6

Leaf ialah perpustakaan penghalaan bahasa Go yang sangat baik. Ia bukan sahaja ringan, cekap dan mudah digunakan, tetapi juga menyediakan pelbagai fungsi seperti perisian tengah, mod MVC dan pemprosesan permintaan dan respons HTTP pelbagai keperluan kami untuk membangunkan aplikasi web. Jika anda mencari pelaksanaan penghalaan yang sangat baik dalam Go, Leaf pastinya berbaloi untuk dicuba.

Atas ialah kandungan terperinci pelaksanaan penghalaan daun golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!