Routing w Go Fiber

Trasportowanie

Rola trasy w frameworku Go Fiber polega na wiązaniu różnych adresów URL z funkcjami obsługi, aby obsługiwać przetwarzanie żądań HTTP. Stanowi ona punkt wejścia dla wszystkich żądań frameworka internetowego.

Obsługa Trasportowania (Funkcje)

Rejestruje trasy, które są przypisane do określonych metod HTTP.

Uwaga: W niektórych frameworkach obsługa tras może być nazywana kontrolerami, co zazwyczaj ma tę samą definicję — wskazuje, która funkcja (metoda) ma obsłużyć przychodzące żądanie HTTP.

Sygnatura funkcji:

// Metody 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

// Metoda Add pozwala określić metody jako wartości
func (app *App) Add(method, path string, handlers ...Handler) Router

// All rejestruje trasę na wszystkich metodach HTTP
// Podobne do app.Use, ale nie wiąże prefiksu
func (app *App) All(path string, handlers ...Handler) Router

Przykład:

// Prosta obsługa GET
app.Get("/api/list", func(c *fiber.Ctx) error {
  return c.SendString("To jest żądanie typu GET!")
})

// Prosta obsługa POST
app.Post("/api/register", func(c *fiber.Ctx) error {
  return c.SendString("To jest żądanie typu POST!")
})

Use służy do ładowania oprogramowania pośredniczącego oraz przechwytywania prefiksów URL. Te trasy pasują tylko do początku każdej ścieżki, na przykład, /john pasuje do /john/doe, /johnnnnn itp.

Sygnatura niestandardowej funkcji pośredniczącej:

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

Przykład:

// Pasuje do każdego żądania
app.Use(func(c *fiber.Ctx) error {
    return c.Next()
})

// Pasuje do żądań zaczynających się od /api
app.Use("/api", func(c *fiber.Ctx) error {
    return c.Next()
})

// Pasuje do żądań zaczynających się od /api lub /home (obsługuje wiele prefiksów)
app.Use([]string{"/api", "/home"}, func(c *fiber.Ctx) error {
    return c.Next()
})

// Dodaje wiele obsługujących
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()
})

Ścieżka

Ścieżka trasy razem z metodą żądania definiuje punkty końcowe, do których można uzyskać dostęp. Ścieżka trasy może być łańcuchem znaków lub wzorcem łańcucha znaków.

Przykłady ścieżek opartych na łańcuchach znaków

// Ta ścieżka trasy będzie pasować do żądań ścieżki głównej, "/":
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Ścieżka główna")
})

// Ta ścieżka trasy będzie pasować do żądań "/about":
app.Get("/about", func(c *fiber.Ctx) error {
  return c.SendString("Informacje")
})

// Ta ścieżka trasy będzie pasować do żądań "/random.txt":
app.Get("/random.txt", func(c *fiber.Ctx) error {
  return c.SendString("Losowy.txt")

Podobnie jak w frameworku expressJs, istotna jest kolejność deklarowania tras. Po otrzymaniu żądania trasy są sprawdzane w kolejności ich deklaracji.

Proszę zauważyć: Upewnij się, że trasy z parametrami zmiennymi są zapisane po trasach zawierających stałe części, aby zapobiec ich błędnemu dopasowaniu, co mogłoby prowadzić do nieoczekiwanego zachowania.

Parametry trasy

Parametry trasy są dynamicznymi elementami trasy i mogą być albo nazwanymi, albo nienazwanymi segmentami. Te segmenty służą do przechwytywania wartości na określonych pozycjach w adresie URL. Można użyć funkcji Params do pobrania tych wartości, gdzie parametrem funkcji jest nazwa parametru trasy w ścieżce, lub dla parametrów nienazwanych, są to znaki (*, +) i ich liczba.

Znak wieloznaczny (*) lub plus (+) reprezentuje parametry zachłanne.

Trasy pozwalają również na używanie parametrów opcjonalnych. Dla nazwanych parametrów, parametry te poprzedza znak zapytania (?), podczas gdy plus nie jest opcjonalny, a można użyć znaków wieloznacznych do reprezentowania opcjonalnego i zachłannego zakresu.

Przykład definiowania trasy z parametrami trasy

// Parametry
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 - zachłanny - nieopcjonalny
app.Get("/user/+", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("+"))
})

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

// Znak wieloznaczny - zachłanny - opcjonalny
app.Get("/user/*", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("*"))
})

// Ta ścieżka trasy będzie pasować do żądania "/v1/some/resource/name:customVerb" ponieważ znaki parametrów zostały zescapowane
app.Get(`/v1/some/resource/name\:customVerb`, func(c *fiber.Ctx) error {
    return c.SendString("Witaj, Społeczność")
})

Ponieważ myślniki (-) i kropki (.) są interpretowane dosłownie, mogą być używane wraz z parametrami trasy w celu osiągnięcia celów użytkowych.

Wszystkie specjalne znaki parametrów mogą być również zescapowane za pomocą \, a ich wartości będą ignorowane, więc jeśli chcesz ich użyć w trasie. Zaleca się używanie odwrotnych apostrofów ``, ponieważ w dokumentacji dotyczącej wyrażeń regularnych w Go zawsze są one stosowane, aby upewnić się, że nie ma niejednoznaczności i znaki escape nie wpłyną przypadkowo na wzorzec wyrażenia regularnego.

// 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
})

Nasza inteligentna trasowanie rozpoznaje, że wprowadzone znaki parametrów w tym przypadku powinny być częścią trasy żądania i może nimi zarządzać jako takimi.

// 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
})

Ponadto, trasy mogą wykorzystywać wiele parametrów i wiele znaków parametrów nienazwanych kolejno, takich jak znaki wieloznaczne lub plus, co znacznie poszerza możliwości użytkowników w trasach.

// 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)

Już dostosowaliśmy trasowanie do trasowania Express, ale nie obsługuje ono jeszcze wyrażeń regularnych, ponieważ są one stosunkowo wolne.

Ograniczenia

W przypadku dopasowania przychodzącego adresu URL oraz podziału ścieżki URL na wartości trasowe za pomocą parametrów, zostaną wykonane ograniczenia. Ta funkcja została wprowadzona w wersji v2.37.0 i została zainspirowana przez .NET Core.

Ograniczenia nie służą do walidacji parametrów. Jeśli ograniczenie jest nieprawidłowe dla wartości parametru, Fiber zwróci obróbkę 404.

Przykłady

• Jedno Ograniczenie
• Wiele Ograniczeń
• Ograniczenie Wyrażenia Regularnego

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 // Nie znaleziono GET /1

Możesz użyć `;` aby dodać wiele ograniczeń.

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

// curl -X GET http://localhost:3000/120000 // Nie znaleziono GET /120000

// curl -X GET http://localhost:3000/1 // Nie znaleziono GET /1

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

Fiber prekompiluje zapytania wyrażeń regularnych podczas rejestracji tras, dlatego nie ma dodatkowego obciążenia wydajnościowego dla ograniczeń wyrażeń regularnych.

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

// curl -X GET http://localhost:3000/125 // Nie znaleziono GET /125

// curl -X GET http://localhost:3000/test // Nie znaleziono GET /test

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

> Podczas korzystania z ograniczeń daty i czasu (`*`,`+`,`?`,`:`,`/`,``,``,`>`,';`,`(`,`)`), użyj `\\` przed użyciem znaków specjalnych w trasie, aby uniknąć błędnego interpretowania.

**Przykład Parametru Opcjonalnego**

Można także dodać ograniczenia do parametrów opcjonalnych.
```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
// Nie znaleziono GET /7.0

Oprogramowanie pośredniczące

Funkcje przeznaczone do manipulacji żądań lub odpowiedzi nazywane są funkcjami pośredniczącymi. Next jest funkcją routingu Fibera, która, gdy zostanie wywołana, wykonuje funkcję next, która pasuje do bieżącej trasy.

Przykład funkcji pośredniczącej

app.Use(func(c *fiber.Ctx) error {
  // Ustaw niestandardowy nagłówek we wszystkich odpowiedziach:
  c.Set("X-Custom-Header", "Witaj, świecie")

  // Przejdź do następnego oprogramowania pośredniczącego:
  return c.Next()
})

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Witaj, świecie!")
})

Ścieżka dla metody Use może być ścieżką montażową lub ścieżką prefixową, i ogranicza oprogramowanie pośredniczące do zastosowania jedynie w żądaniach o ścieżkach rozpoczynających się od tej ścieżki.

Dodawanie Ograniczeń Trasy podczas Wykonywania

Ze względów projektowych i wydajnościowych, dynamiczne dodawanie tras po uruchomieniu aplikacji nie jest obsługiwane. Proszę upewnij się, że wszystkie trasy są zdefiniowane przed uruchomieniem aplikacji.

Grupowanie

Jeśli masz wiele punktów końcowych, możesz użyć Group, aby zorganizować trasy.

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

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

  v1 := api.Group("/v1", oprogramowanie)   // /api/v1
  v1.Get("/lista", obsługa)               // /api/v1/lista
  v1.Get("/użytkownik", obsługa)          // /api/v1/użytkownik

  v2 := api.Group("/v2", oprogramowanie)   // /api/v2
  v2.Get("/lista", obsługa)               // /api/v2/lista
  v2.Get("/użytkownik", obsługa)          // /api/v2/użytkownik

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