Enrutamiento de Go Fiber

Enrutamiento

El papel de la ruta en el marco de trabajo Go Fiber es vincular diferentes URL a funciones de manejo, con el fin de admitir el procesamiento de solicitudes HTTP. Sirve como punto de entrada para todas las solicitudes del marco web.

Manejadores de Rutas (Funciones)

Registre rutas que están vinculadas a métodos HTTP específicos.

Nota: En algunos marcos de trabajo, los manejadores de rutas se llaman controladores, lo cual generalmente tiene el mismo significado: determinar qué función (método) manejará la solicitud HTTP entrante.

Firma de la función:

// Métodos 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 te permite especificar métodos como valores
func (app *App) Add(method, path string, handlers ...Handler) Router

// All registra la ruta en todos los métodos HTTP
// Similar a app.Use pero no vincula un prefijo
func (app *App) All(path string, handlers ...Handler) Router

Ejemplo:

// Manejador GET simple
app.Get("/api/list", func(c *fiber.Ctx) error {
  return c.SendString("¡Esta es una solicitud GET!")
})

// Manejador POST simple
app.Post("/api/register", func(c *fiber.Ctx) error {
  return c.SendString("¡Esta es una solicitud POST!")
})

Use se utiliza para cargar middleware y los interceptores del prefijo de URL. Estas rutas solo coinciden con el comienzo de cada ruta, por ejemplo, /john coincidirá con /john/doe, /johnnnnn, y así sucesivamente.

Firma de la función de middleware personalizado:

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

Ejemplo:

// Coincide con cualquier solicitud
app.Use(func(c *fiber.Ctx) error {
    return c.Next()
})

// Coincide con solicitudes que comienzan con /api
app.Use("/api", func(c *fiber.Ctx) error {
    return c.Next()
})

// Coincide con solicitudes que comienzan con /api o /home (admite múltiples prefijos)
app.Use([]string{"/api", "/home"}, func(c *fiber.Ctx) error {
    return c.Next()
})

// Agregar múltiples manejadores
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()
})

Ruta

La ruta de la ruta, junto con el método de solicitud, define los puntos finales a los que se puede acceder. La ruta de la ruta puede ser una cadena o un patrón de cadena.

Ejemplos de rutas basadas en cadenas

// Esta ruta coincidirá con solicitudes a la ruta raíz, "/":
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("Ruta raíz")
})

// Esta ruta coincidirá con solicitudes a "/acerca-de":
app.Get("/acerca-de", func(c *fiber.Ctx) error {
  return c.SendString("Acerca de")
})

// Esta ruta coincidirá con solicitudes a "/random.txt":
app.Get("/random.txt", func(c *fiber.Ctx) error {
  return c.SendString("Random.txt")

Similar al marco de trabajo expressJs, el orden en el que se declaran las rutas es importante. Cuando se recibe una solicitud, las rutas se verifican en el orden en que se declaran.

Por favor, tenga en cuenta: Asegúrese de que las rutas con parámetros variables se escriban después de las rutas que contienen partes fijas para evitar que estas partes variables coincidan erróneamente, lo que podría llevar a un comportamiento inesperado.

Parámetros de ruta

Los parámetros de ruta son elementos dinámicos en una ruta y pueden ser segmentos nombrados o sin nombre. Estos segmentos se utilizan para capturar valores en posiciones específicas de la URL. Puedes usar la función Params para recuperar estos valores, donde el parámetro de la función es el nombre del parámetro de la ruta en el camino, o para los parámetros sin nombre, son los caracteres (*, +) y su recuento.

El asterisco (*) o el signo más (+) representan parámetros codiciosos.

Las rutas también ofrecen la posibilidad de utilizar parámetros opcionales. Para los parámetros nombrados, estos parámetros van seguidos de un signo de interrogación (?), mientras que el signo más no es opcional, y puedes usar caracteres comodín para representar un rango de parámetros opcional y codicioso.

Ejemplo de definición de una ruta con parámetros de ruta

// Parámetros
app.Get("/usuario/:nombre/libros/:titulo", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s\n", c.Params("nombre"))
    fmt.Fprintf(c, "%s\n", c.Params("titulo"))
    return nil
})
// Plus - codicioso - no opcional
app.Get("/usuario/+", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("+"))
})

// Parámetro opcional
app.Get("/usuario/:nombre?", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("nombre"))
})

// Comodín - codicioso - opcional
app.Get("/usuario/*", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("*"))
})

// Esta ruta se corresponderá con la solicitud "/v1/algun/recurso/nombre:verboPersonalizado" porque los caracteres de parámetro han sido escapados
app.Get(`/v1/algun/recurso/nombre\:verboPersonalizado`, func(c *fiber.Ctx) error {
    return c.SendString("Hola, Comunidad")
})

Dado que los guiones (-) y los puntos (.) se interpretan literalmente, se pueden utilizar junto con los parámetros de ruta para lograr propósitos útiles.

Todos los caracteres de parámetro especial también pueden escaparse utilizando \ y sus valores se ignorarán, por lo que si deseas usarlos en la ruta. Se recomienda utilizar comillas inversas ``, ya que en la documentación de expresiones regulares de Go siempre se utilizan para asegurarse de que no haya ambigüedad, y los caracteres de escape no afecten involuntariamente el patrón de expresión regular.

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

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

Nuestro enrutamiento inteligente reconoce que los caracteres de parámetro introducidos en este caso deberían ser parte de la ruta de solicitud y puede manejarlos como tal.

// http://localhost:3000/tienda/producto/color:azul/talla:xs
app.Get("/tienda/producto/color::color/talla::talla", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s:%s\n", c.Params("color"), c.Params("talla"))
    return nil // azul:xs
})

Además, las rutas pueden usar múltiples parámetros y múltiples caracteres de parámetro sin nombre consecutivamente, como caracteres comodín o signos más, lo que amplía enormemente las posibilidades para los usuarios en las rutas.

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

// GET /api-v1
// Params: "nombre" -> "v1" 
app.Get("/api-:nombre", manejador)

// GET /cliente/v1/carrito/proxy
// Params: "*1" -> "cliente/", "*2" -> "/carrito"
app.Get("/*v1*/proxy", manejador)

// GET /v1/marca/4/tienda/azul/xs
// Params: "*1" -> "marca/4", "*2" -> "azul/xs"
app.Get("/v1/*/tienda/*", manejador)

Ya hemos adaptado el enrutamiento a enrutamiento de Express, pero aún no admite expresiones regulares porque son relativamente lentas.

Restricciones

Cuando hay coincidencia con la URL de entrada y la ruta de la URL se divide en valores de ruta a través de parámetros, se ejecutarán las restricciones. Esta característica fue introducida en v2.37.0 e fue inspirada por .NET Core.

Las restricciones no son para la validación de parámetros. Si la restricción no es válida para el valor del parámetro, Fiber devolverá un manejador 404.

Ejemplos

• Restricción simple
• Múltiples restricciones
• Restricción de expresión regular

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 // No se encuentra GET /1

Puede usar `;` para agregar múltiples restricciones.

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

// curl -X GET http://localhost:3000/120000 // No se encuentra GET /120000

// curl -X GET http://localhost:3000/1 // No se encuentra GET /1

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

Fiber precompila las consultas de expresiones regulares al registrar rutas, por lo que no hay sobrecarga de rendimiento para las restricciones de expresiones regulares.

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

// curl -X GET http://localhost:3000/125 // No se encuentra GET /125

// curl -X GET http://localhost:3000/test // No se encuentra GET /test

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

> Al utilizar restricciones de fecha y hora (`*`,`+`,`?`,`:`,`/`,``,``,`>`,';`,`(`,`)`), utilice `\\` antes de utilizar caracteres especiales en la ruta para evitar su interpretación errónea.

**Ejemplo de Parámetro Opcional**

También puede agregar restricciones a parámetros opcionales.
```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
// No se encuentra GET /7.0

Middleware

Las funciones diseñadas para manipular solicitudes o respuestas se llaman funciones de middleware. Next es una función de enrutamiento de Fiber que, al ser llamada, ejecuta la función next que coincide con la ruta actual.

Ejemplo de función de middleware

app.Use(func(c *fiber.Ctx) error {
  // Establecer un encabezado personalizado en todas las respuestas:
  c.Set("X-Custom-Header", "¡Hola, mundo!")

  // Continuar con el próximo middleware:
  return c.Next()
})

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("¡Hola, mundo!")
})

La ruta para el método Use puede ser una ruta de montaje o prefijo, y restringe que el middleware se aplique solo a solicitudes con rutas que comiencen con esa ruta.

Agregar Limitaciones de Ruta en Tiempo de Ejecución

Debido a consideraciones de diseño y rendimiento, no se admite la adición dinámica de rutas después del inicio de la aplicación. Asegúrese de que todas las rutas estén definidas antes de que la aplicación se inicie.

Agrupación

Si tienes muchos endpoints, puedes usar Group para organizar rutas.

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