Pemetaan Go Fiber

Routing

Peran rute dalam kerangka kerja Go Fiber adalah mengikat berbagai URL ke fungsi penanganan, untuk mendukung pemrosesan permintaan HTTP. Ini berfungsi sebagai titik masuk untuk semua permintaan kerangka web.

Penangan Rute (Fungsi)

Mendaftarkan rute yang terikat dengan metode HTTP spesifik.

Catatan: Dalam beberapa kerangka kerja, penangan rute disebut pengontrol, yang umumnya memiliki makna yang sama—menentukan fungsi (metode) mana yang akan menangani permintaan HTTP masuk.

Tanda Tangan Fungsi:

// Metode HTTP
func (app *App) Get(path string, handlers ...Handler) Router
func (app *App) Head(path string, handlers ...Handler) Router
func (app *App) Post(path string, handlers ...Handler) Router
func (app *App) Put(path string, handlers ...Handler) Router
func (app *App) Delete(path string, handlers ...Handler) Router
func (app *App) Connect(path string, handlers ...Handler) Router
func (app *App) Options(path string, handlers ...Handler) Router
func (app *App) Trace(path string, handlers ...Handler) Router
func (app *App) Patch(path string, handlers ...Handler) Router

// Add memungkinkan Anda untuk menentukan metode sebagai nilai
func (app *App) Add(method, path string, handlers ...Handler) Router

// All mendaftarkan rute pada semua metode HTTP
// Serupa dengan app.Use tetapi tidak mengikat awalan
func (app *App) All(path string, handlers ...Handler) Router

Contoh:

// Penangan GET sederhana
app.Get("/api/list", func(c *fiber.Ctx) error {
  return c.SendString("Ini adalah permintaan GET!")
})

// Penangan POST sederhana
app.Post("/api/register", func(c *fiber.Ctx) error {
  return c.SendString("Ini adalah permintaan POST!")
})

Use digunakan untuk memuat middleware dan penyisipan URL awalan. Rute-rute ini hanya cocok dengan awalan setiap jalur, misalnya, /john akan cocok dengan /john/doe, /johnnnnn, dan sebagainya.

Tanda Tangan Fungsi middleware kustom:

func (app *App) Use(args ...interface{}) Router

Contoh:

// Cocok dengan permintaan apa pun
app.Use(func(c *fiber.Ctx) error {
    return c.Next()
})

// Cocok dengan permintaan yang dimulai dengan /api
app.Use("/api", func(c *fiber.Ctx) error {
    return c.Next()
})

// Cocok dengan permintaan yang dimulai dengan /api atau /home (mendukung awalan ganda)
app.Use([]string{"/api", "/home"}, func(c *fiber.Ctx) error {
    return c.Next()
})

// Tambahkan beberapa penangan
app.Use("/api", func(c *fiber.Ctx) error {
  c.Set("X-Custom-Header", random.String(32))
  return c.Next()
}, func(c *fiber.Ctx) error {
  return c.Next()
})

Path

Jalur rute, bersama dengan metode permintaan, menentukan ujung yang dapat diakses. Jalur rute dapat berupa string atau pola string.

Contoh jalur rute berbasis string

// Jalur rute ini akan cocok dengan permintaan ke jalur root, "/":
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Jalur akar")
})

// Jalur rute ini akan cocok dengan permintaan ke "/about":
app.Get("/about", func(c *fiber.Ctx) error {
  return c.SendString("Tentang")
})

// Jalur rute ini akan cocok dengan permintaan ke "/random.txt":
app.Get("/random.txt", func(c *fiber.Ctx) error {
  return c.SendString("Acak.txt")

Seperti kerangka kerja expressJs, urutan di mana rute dideklarasikan penting. Ketika permintaan diterima, rute-rute diperiksa sesuai dengan urutan yang dideklarasikan.

Harap dicatat: Pastikan rute dengan parameter variabel ditulis setelah rute yang berisi bagian tetap untuk mencegah bagian variabel ini cocok secara keliru, yang dapat menyebabkan perilaku yang tidak terduga.

Parameter Rute

Parameter rute adalah elemen dinamis dalam sebuah rute dan dapat berupa nama atau segment tak bernama. Segmen-segmen ini digunakan untuk menangkap nilai pada posisi yang ditentukan dalam URL. Anda dapat menggunakan fungsi Params untuk mengambil nilai-nilai ini, di mana parameter fungsi adalah nama parameter rute dalam path, atau untuk parameter tak bernama, itu adalah karakter (*, +) dan jumlahnya.

Tanda wildcard (*) atau tanda tambah (+) mewakili parameter yang rakus.

Rute juga menyediakan kemungkinan untuk menggunakan parameter opsional. Untuk parameter-parameter bernama, parameter-parameter ini diikuti oleh tanda tanya (?), sedangkan tanda tambah bukan bersifat opsional, dan Anda dapat menggunakan karakter wildcard untuk mewakili rentang parameter opsional dan rakus.

Contoh mendefinisikan rute dengan parameter rute

// Parameters
app.Get("/user/:name/books/:title", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s\n", c.Params("name"))
    fmt.Fprintf(c, "%s\n", c.Params("title"))
    return nil
})
// Plus - rakus - tidak opsional
app.Get("/user/+", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("+"))
})

// Parameter opsional
app.Get("/user/:name?", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("name"))
})

// Wildcard - rakus - opsional
app.Get("/user/*", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("*"))
})

// Jalur rute ini akan cocok dengan permintaan "/v1/some/resource/name:customVerb" karena karakter parameter telah di-escape
app.Get(`/v1/some/resource/name\:customVerb`, func(c *fiber.Ctx) error {
    return c.SendString("Hello, Community")
})

Karena tanda hubung (-) dan titik (.) diinterpretasikan secara harfiah, mereka dapat digunakan bersama dengan parameter rute untuk mencapai tujuan yang berguna.

Semua karakter parameter khusus juga dapat di-escape menggunakan \ dan nilainya akan diabaikan, jadi jika Anda ingin menggunakannya dalam rute. Disarankan untuk menggunakan backticks ``, seperti dalam dokumentasi regulasi Go, mereka selalu digunakan untuk memastikan tidak ada ambiguitas, dan karakter escape tidak secara tidak sengaja memengaruhi pola regulasi.

// http://localhost:3000/plantae/prunus.persica
app.Get("/plantae/:genus.:species", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s.%s\n", c.Params("genus"), c.Params("species"))
    return nil // prunus.persica
})

// http://localhost:3000/flights/LAX-SFO
app.Get("/flights/:from-:to", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s-%s\n", c.Params("from"), c.Params("to"))
    return nil // LAX-SFO
})

Rute cerdas kami mengenali bahwa karakter parameter yang diperkenalkan dalam kasus ini seharusnya menjadi bagian dari rute permintaan dan dapat menanganinya sebagai itu.

// http://localhost:3000/shop/product/color:blue/size:xs
app.Get("/shop/product/color::color/size::size", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s:%s\n", c.Params("color"), c.Params("size"))
    return nil // blue:xs
})

Selain itu, rute dapat menggunakan beberapa parameter dan beberapa karakter parameter tak bernama secara berurutan, seperti karakter wildcard atau tambah, yang sangat memperluas kemungkinan untuk pengguna dalam rute.

// GET /@v1
// Params: "sign" -> "@", "param" -> "v1"
app.Get("/:sign:param", handler)

// GET /api-v1
// Params: "name" -> "v1" 
app.Get("/api-:name", handler)

// GET /customer/v1/cart/proxy
// Params: "*1" -> "customer/", "*2" -> "/cart"
app.Get("/*v1*/proxy", handler)

// GET /v1/brand/4/shop/blue/xs
// Params: "*1" -> "brand/4", "*2" -> "blue/xs"
app.Get("/v1/*/shop/*", handler)

Kami telah mengadaptasi rute ke rute Express, tetapi belum mendukung ekspresi reguler karena relatif lambat.

Kendala

Ketika terdapat pencocokan dengan URL yang masuk dan jalur URL dibagi menjadi nilai rute melalui parameter, maka kendala akan dieksekusi. Fitur ini diperkenalkan di v2.37.0 dan terinspirasi dari .NET Core.

Kendala tidak digunakan untuk validasi parameter. Jika kendala tidak valid untuk nilai parameter, Fiber akan mengembalikan pemegang 404.

Contoh

• Kendala Tunggal
• Kendala Jamak
• Kendala Ekspresi Reguler

app.Get("/:test", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("test"))
})

// curl -X GET http://localhost:3000/12 // 12

// curl -X GET http://localhost:3000/1 // Tidak bisa menemukan GET /1

Anda dapat menggunakan `;` untuk menambahkan beberapa kendala.

app.Get("/:test", func(c *fiber.Ctx) error { return c.SendString(c.Params("test")) })

// curl -X GET http://localhost:3000/120000 // Tidak bisa menemukan GET /120000

// curl -X GET http://localhost:3000/1 // Tidak bisa menemukan GET /1

// curl -X GET http://localhost:3000/250 // 250

Fiber memprekompilasi kueri ekspresi reguler saat mendaftarkan rute, sehingga tidak ada overhead kinerja untuk kendala ekspresi reguler.

```go
app.Get(`/:date`, func(c *fiber.Ctx) error {
  return c.SendString(c.Params("date"))
})

// curl -X GET http://localhost:3000/125 // Tidak bisa menemukan GET /125

// curl -X GET http://localhost:3000/test // Tidak bisa menemukan GET /test

// curl -X GET http://localhost:3000/2022-08-27 // 2022-08-27

> Saat menggunakan kendala tanggal dan waktu (`*`,`+`,`?`,`:`,`/`,``,``,`>`,';`,`(`,`)`), gunakan `\\` sebelum menggunakan karakter khusus dalam rute untuk menghindari penafsiran yang keliru.

**Contoh Parameter Opsional**

Anda juga dapat menambahkan kendala ke parameter opsional.
```go
app.Get("/:test?", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("test"))
})
// curl -X GET http://localhost:3000/42
// 42
// curl -X GET http://localhost:3000/
//
// curl -X GET http://localhost:3000/7.0
// Tidak bisa menemukan GET /7.0

Middleware

Fungsi yang dirancang untuk memanipulasi permintaan atau tanggapan disebut fungsi middleware. Next adalah fungsi routing Fiber yang, ketika dipanggil, mengeksekusi fungsi next yang cocok dengan rute saat ini.

Contoh Fungsi Middleware

app.Use(func(c *fiber.Ctx) error {
  // Atur header kustom dalam semua tanggapan:
  c.Set("X-Custom-Header", "Halo, dunia")

  // Lanjut ke middleware selanjutnya:
  return c.Next()
})

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Halo, dunia!")
})

Jalur untuk metode Use dapat berupa jalur pemasangan atau jalur awalan, dan membatasi middleware yang diterapkan hanya pada permintaan dengan jalur yang dimulai dari jalur tersebut.

Menambahkan Batasan Rute secara Dinamis

Karena pertimbangan desain dan kinerja, menambahkan rute secara dinamis setelah aplikasi dijalankan tidak didukung. Pastikan bahwa semua rute didefinisikan sebelum aplikasi mulai.

Pengelompokan

Jika Anda memiliki banyak titik akhir, Anda dapat menggunakan Group untuk mengatur rute.

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

  api := app.Group("/api", middleware) // /api

  v1 := api.Group("/v1", middleware)   // /api/v1
  v1.Get("/list", handler)             // /api/v1/list
  v1.Get("/user", handler)             // /api/v1/user

  v2 := api.Group("/v2", middleware)   // /api/v2
  v2.Get("/list", handler)             // /api/v2/list
  v2.Get("/user", handler)             // /api/v2/user

  log.Fatal(app.Listen(":3000"))
}