Behandlung verschiedener Anfragemerkmale im Go Fiber Framework

Einfaches Beispiel

Alle Anfragemerkmale im Fiber-Framework werden über das Kontextobjekt Ctx erhalten.

app.Get("/user/:name?", func(c *fiber.Ctx) error {
    // Merkmale werden über den Ctx-Parameter der Routinenfunktion erhalten und die entsprechende Methode aufgerufen
    // Hier wird das Namensmerkmal über Params erhalten
    return c.SendString(c.Params("name"))
})

Abrufen von Routenparametern

Abrufen von Parametern aus dem URL-Pfad

// 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("*", "Standardwert")  // Standardwert kann mit dem zweiten Parameter festgelegt werden
})

Abrufen von Routenparametern vom Typ Int

// GET http://example.com/user/123
app.Get("/user/:id", func(c *fiber.Ctx) error {
  id, err := c.ParamsInt("id") // int 123 und kein Fehler

  // ...
})

Abrufen von GET-Anfrage-Abfragemerkmalen

// GET http://example.com/?order=desc&brand=nike
app.Get("/", func(c *fiber.Ctx) error {
  c.Query("order")         // "desc"
  c.Query("brand")         // "nike"
  // Der zweite Parameter kann verwendet werden, um einen Standardwert festzulegen, der zurückgegeben wird, wenn das Merkmal nicht vorhanden ist
  c.Query("leer", "nike") // "nike"

  // ...
})

Rückgabe aller Abfragemerkmale

// 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"]          // ""
    // ...
})

Binden von Abfragemerkmalen an ein Struktur-Objekt

// Definition einer Struktur zum Empfangen von Parametern
// Verwenden Sie das Abfrage-Tag, um die zu bindenden Parameternamen zu spezifizieren
type Person struct {
    Name     string     `query:"name"`
    Pass     string     `query:"pass"`
    Produkte []string   `query:"produkte"`
}

app.Get("/", func(c *fiber.Ctx) error {
        // Definieren einer Strukturvariablen zum Empfangen von Parametern
        p := new(Person)

        // Verwenden von QueryParser, um Abfragemerkmale an die Variable p zu binden
        if err := c.QueryParser(p); err != nil {
            return err
        }

        log.Println(p.Name)     // john
        log.Println(p.Pass)     // doe
        log.Println(p.Produkte) // [shoe, hat]

        // ...
})
// Führen Sie den folgenden Curl-Befehl zum Testen aus
// curl "http://localhost:3000/?name=john&pass=doe&produkte=shoe,hat"

Abrufen von POST-Anfrage-Formularparametern

app.Post("/", func(c *fiber.Ctx) error {
  // Den ersten Wert aus dem Formularfeld "name" abrufen:
  c.FormValue("name")
  // => "john" oder "", wenn es nicht vorhanden ist

  // ...
})

Behandlung von Body-Parametern

Es wird hauptsächlich zur Verarbeitung von POST/PUT-Anforderungen verwendet und unterstützt JSON, XML und Formularparameter.

// Definieren Sie die Struktur zur Entgegennahme von Parametern und definieren Sie die Parameterfeldnamen, die Sie über die JSON-, XML- und Form-Tags empfangen möchten
// json, xml, form können je nach Bedarf ausgewählt werden; es ist nicht notwendig, alle davon einzuschließen
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 {
    // Definieren Sie die Strukturvariable zum Empfangen von Parametern
    p := new(Person)

    // Verwenden Sie den BodyParser, um die Body-Parameter an die Variable p zu binden
    if err := c.BodyParser(p); err != nil {
        return err
    }

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

    // ...
})

// Beispiele für verschiedene Arten von Anforderungen; für JSON-Format-Parameteranforderungen müssen Sie Content-Type: application/json setzen

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

Wie Sie die ursprünglichen Body-Daten abrufen, wird wie folgt dargestellt:

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

app.Post("/", func(c *fiber.Ctx) error {
  // Verwenden Sie BodyRaw, um die Rohdaten des Bodys zurückzugeben
  return c.Send(c.BodyRaw()) // []byte("user=john")
})

Abrufen von Anforderungskopfzeilen

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

Abrufen der Client-IP

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

  // ...
})

Wenn Sie auf einem Server bereitgestellt sind, der einen Proxy oder Lastenausgleicher verwendet, müssen Sie die IP des Clients über den Header x-forwarded-for abrufen, indem Sie wie folgt einstellen:

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

Cookies lesen

app.Get("/", func(c *fiber.Ctx) error {
  // Cookie nach Schlüssel abrufen:
  c.Cookies("name")         // "john"
  c.Cookies("leer", "doe")  // "doe"
  // ...
})

Go Fiber Parameterverarbeitung