Gestion de différents paramètres de requête dans le framework Go Fiber

Exemple simple

Tous les paramètres de requête dans le framework Fiber sont obtenus via l'objet de contexte Ctx.

app.Get("/user/:name?", func(c *fiber.Ctx) error {
    // Obtenir les paramètres via le paramètre Ctx de la fonction de route et appeler la méthode appropriée
    // Ici, le paramètre name est obtenu via Params
    return c.SendString(c.Params("name"))
})

Obtention des paramètres de route

Obtention des paramètres depuis le chemin de l'URL

// GET http://example.com/user/fenny
app.Get("/user/:name", func(c *fiber.Ctx) error {
  c.Params("name") // "fenny"

  // ...
})

// GET http://example.com/user/fenny/123
app.Get("/user/*", func(c *fiber.Ctx) error {
  c.Params("*")  // "fenny/123"
  c.Params("*1") // "fenny/123"
  
  c.Params("*", "valeur par défaut")  // La valeur par défaut peut être définie avec le deuxième paramètre
})

Obtention des paramètres de route de type Int

// GET http://example.com/user/123
app.Get("/user/:id", func(c *fiber.Ctx) error {
  id, err := c.ParamsInt("id") // int 123 et pas d'erreur

  // ...
})

Obtention des paramètres de requête GET

// GET http://example.com/?order=desc&brand=nike
app.Get("/", func(c *fiber.Ctx) error {
  c.Query("order")         // "desc"
  c.Query("marque")         // "nike"
  // Le deuxième paramètre peut être utilisé pour définir une valeur par défaut, qui sera renvoyée si le paramètre n'existe pas
  c.Query("vide", "nike") // "nike"

  // ...
})

Renvoyer tous les paramètres de requête

// GET http://example.com/?name=alex&want_pizza=false&id=
app.Get("/", func(c *fiber.Ctx) error {
    m := c.Queries()
    m["name"]        // "alex"
    m["want_pizza"]  // "false"
    m["id"]          // ""
    // ...
})

Associer les paramètres de requête à un objet de type struct

// Définir une struct pour recevoir les paramètres
// Utiliser la balise query pour spécifier les noms des paramètres à lier
type Person struct {
    Nom     string     `query:"name"`
    Passe     string     `query:"pass"`
    Produits []string   `query:"products"`
}

app.Get("/", func(c *fiber.Ctx) error {
        // Définir une variable de type struct pour recevoir les paramètres
        p := new(Person)

        // Utiliser QueryParser pour lier les paramètres de requête à la variable p
        if err := c.QueryParser(p); err != nil {
            return err
        }

        log.Println(p.Nom)     // john
        log.Println(p.Passe)     // doe
        log.Println(p.Produits) // [shoe, hat]

        // ...
})
// Exécuter la commande curl suivante pour tester
// curl "http://localhost:3000/?name=john&pass=doe&products=shoe,hat"

Obtention des paramètres de formulaire de requête POST

app.Post("/", func(c *fiber.Ctx) error {
  // Obtenir la première valeur du champ de formulaire "name" :
  c.FormValue("name")
  // => "john" ou "" s'il n'existe pas

  // ...
})
## Traitement des paramètres de corps

Il est principalement utilisé pour traiter les requêtes POST/PUT et prend en charge les paramètres JSON, XML et de formulaire.

```go
// Définit la structure pour recevoir les paramètres et définir les noms de champ de paramètre que vous souhaitez recevoir via les balises json, xml et form
// json, xml, form peuvent être sélectionnés selon les besoins ; il n'est pas nécessaire d'inclure tous.
type Person struct {
    Name string `json:"name" xml:"name" form:"name"`
    Pass string `json:"pass" xml:"pass" form:"pass"`
}

app.Post("/", func(c *fiber.Ctx) error {
    // Définit la variable de structure pour recevoir les paramètres
    p := new(Person)

    // Utilise BodyParser pour lier les paramètres de corps à la variable p
    if err := c.BodyParser(p); err != nil {
        return err
    }

    log.Println(p.Name) // john
    log.Println(p.Pass) // doe

    // ...
})

// Exemples de divers types de requêtes ; pour les requêtes de paramètres au format JSON, n'oubliez pas de définir Content-Type: application/json

// curl -X POST -H "Content-Type: application/json" --data "{\"name\":\"john\",\"pass\":\"doe\"}" localhost:3000

// curl -X POST -H "Content-Type: application/xml" --data "<login><name>john</name><pass>doe</pass></login>" localhost:3000

// curl -X POST -H "Content-Type: application/x-www-form-urlencoded" --data "name=john&pass=doe" localhost:3000

// curl -X POST -F name=john -F pass=doe http://localhost:3000

// curl -X POST "http://localhost:3000/?name=john&pass=doe"

Comment récupérer les données de corps d'origine, comme suit :

// curl -X POST http://localhost:8080 -d user=john

app.Post("/", func(c *fiber.Ctx) error {
  // Utilise BodyRaw pour renvoyer les données de corps brutes
  return c.Send(c.BodyRaw()) // []byte("user=john")
})

Récupération des en-têtes de requête

app.Get("/", func(c *fiber.Ctx) error {
  c.Get("Content-Type")       // "text/plain"
  c.Get("CoNtEnT-TypE")       // "text/plain"
  c.Get("something", "john")  // "john"
  // ...
})

Récupération de l'adresse IP du client

app.Get("/", func(c *fiber.Ctx) error {
  c.IP() // "127.0.0.1"

  // ...
})

Si vous êtes déployé sur un serveur utilisant un proxy ou un équilibreur de charge, vous devez récupérer l'adresse IP du client via l'en-tête x-forwarded-for en définissant comme suit :

app := fiber.New(fiber.Config{
  ProxyHeader: fiber.HeaderXForwardedFor,
})

Lecture des cookies

app.Get("/", func(c *fiber.Ctx) error {
  // Obtient le cookie par clé :
  c.Cookies("name")         // "john"
  c.Cookies("empty", "doe") // "doe"
  // ...
})

Traitement des paramètres Go Fiber