fiber
v2.52.5
Fiber ist ein aus Express inspiriertes Web -Framework , das auf Fasthttp, der schnellsten HTTP -Engine für GO, basiert. Entwickelt, um die Dinge für die schnelle Entwicklung ohne Vorstellung von Speicher und Leistung zu erleichtern .
Fiber V3 befindet sich derzeit in Beta und in aktiver Entwicklung. Obwohl es aufregende neue Funktionen bietet, beachten Sie bitte, dass es möglicherweise nicht für die Produktionsanwendung stabil ist. Wir empfehlen, sich an die neueste stabile Version (v2.x) für missionskritische Anwendungen zu halten. Wenn Sie V3 verwenden, sollten Sie sich auf potenzielle Fehler und Veränderungen vorbereiten. Überprüfen Sie immer die offiziellen Dokumentation und die Freigabeboten auf Updates und gehen Sie mit Vorsicht vor. Happy Coding!
Faser benötigt GO Version 1.23 oder höher . Wenn Sie die offizielle Go -Download -Seite besuchen oder aktualisieren müssen. Erstellen Sie ein neues Verzeichnis für Ihr Projekt, um Ihr Projekt einzurichten, und navigieren Sie ein neues Verzeichnis für Ihr Projekt. Initialisieren Sie Ihr Projekt dann mit Go -Modulen, indem Sie den folgenden Befehl in Ihrem Terminal ausführen:
go mod init github.com/your/repoUm mehr über Go -Module und ihre Funktionsweise zu erfahren, können Sie sich den Blog -Beitrag mit Go -Modulen ansehen.
Nach dem Einrichten Ihres Projekts können Sie Glasfaser mit dem Befehl go get installieren:
go get -u github.com/gofiber/fiber/v3Dieser Befehl holt das Glasfaserpaket ab und fügt es den Abhängigkeiten Ihres Projekts hinzu, sodass Sie Ihre Webanwendungen mit Glasfasern erstellen können.
Der Einstieg mit Glasfasern ist einfach. Hier ist ein grundlegendes Beispiel, um einen einfachen Webserver zu erstellen, der mit "Hallo, Welt!" Auf dem Wurzelweg. In diesem Beispiel zeigt das Initialisieren einer neuen Glasfaser -App, das Einrichten einer Route und das Starten des Servers.
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
// Initialize a new Fiber app
app := fiber . New ()
// Define a route for the GET method on the root path '/'
app . Get ( "/" , func ( c fiber. Ctx ) error {
// Send a string response to the client
return c . SendString ( "Hello, World !" )
})
// Start the server on port 3000
log . Fatal ( app . Listen ( ":3000" ))
} Dieser einfache Server ist einfach einzurichten und auszuführen. Es führt die Kernkonzepte von Faser vor: App -Initialisierung, Routendefinition und Starten des Servers. Führen Sie einfach dieses GO -Programm aus und besuchen Sie http://localhost:3000 in Ihrem Browser, um die Nachricht zu sehen.
Faser ist für Hochleistungs-Hochleistungsfasern optimiert, was bedeutet, dass die von Fasern zurückgegebenen Werte standardmäßig nicht unveränderlich sind und über Anforderungen hinweg wiederverwendet werden . Als Faustregel dürfen Sie nur Kontextwerte innerhalb des Handlers verwenden und dürfen keine Referenzen aufbewahren. Sobald Sie aus dem Handler zurückkehren, werden alle aus dem Kontext erhaltenen Werte in zukünftigen Anfragen wiederverwendet. Besuchen Sie unsere Dokumentation, um mehr zu erfahren.
Diese Tests werden von TechEmpower und Go Web durchgeführt. Wenn Sie alle Ergebnisse sehen möchten, besuchen Sie bitte unser Wiki.
Neue Gophers, die den Wechsel von Node.js to Going mit einer Lernkurve machen, bevor sie mit dem Erstellen ihrer Webanwendungen oder Microservices beginnen können. Faser als Web -Framework wurde mit der Idee des Minimalismus erstellt und folgt dem Unix -Weg , damit neue Gophers schnell in die Welt von Go mit einem warmen und vertrauenswürdigen Begrüßung eintreten können.
Fiber ist von Express inspiriert , dem beliebtesten Web -Framework im Internet. Wir haben die Leichtigkeit der Express und der rohen Leistung von GO kombiniert. Wenn Sie jemals eine Webanwendung in node.js ( mit Express oder ähnlichem ) implementiert haben, erscheinen Ihnen viele Methoden und Prinzipien sehr häufig .
Wir hören unseren Benutzern in Themen, Discord Channel und im ganzen Internet zu, um ein schnelles , flexibles und freundliches GO -Web -Framework für jede Aufgabe, Deadline und Entwicklerfähigkeiten zu erstellen! Genau wie Express in der JavaScript -Welt.
Nachfolgend sind einige der gängigen Beispiele aufgeführt. Wenn Sie weitere Code -Beispiele sehen möchten, besuchen Sie bitte unser Rezepte -Repository oder besuchen Sie unsere gehostete API -Dokumentation.
package main
import (
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
// GET /api/register
app . Get ( "/api/*" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( " %s" , c . Params ( "*" ))
return c . SendString ( msg ) // => register
})
// GET /flights/LAX-SFO
app . Get ( "/flights/:from-:to" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( "? From: %s, To: %s" , c . Params ( "from" ), c . Params ( "to" ))
return c . SendString ( msg ) // => ? From: LAX, To: SFO
})
// GET /dictionary.txt
app . Get ( "/:file.:ext" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( "? %s.%s" , c . Params ( "file" ), c . Params ( "ext" ))
return c . SendString ( msg ) // => ? dictionary.txt
})
// GET /john/75
app . Get ( "/:name/:age/:gender?" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( "? %s is %s years old" , c . Params ( "name" ), c . Params ( "age" ))
return c . SendString ( msg ) // => ? john is 75 years old
})
// GET /john
app . Get ( "/:name" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( "Hello, %s !" , c . Params ( "name" ))
return c . SendString ( msg ) // => Hello john !
})
log . Fatal ( app . Listen ( ":3000" ))
} package main
import (
"encoding/json"
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
app . Get ( "/api/*" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( " %s" , c . Params ( "*" ))
return c . SendString ( msg ) // => register
}). Name ( "api" )
route := app . GetRoute ( "api" )
data , _ := json . MarshalIndent ( route , "" , " " )
fmt . Println ( string ( data ))
// Prints:
// {
// "method": "GET",
// "name": "api",
// "path": "/api/*",
// "params": [
// "*1"
// ]
// }
log . Fatal ( app . Listen ( ":3000" ))
} package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/static"
)
func main () {
app := fiber . New ()
// Serve static files from the "./public" directory
app . Get ( "/*" , static . New ( "./public" ))
// => http://localhost:3000/js/script.js
// => http://localhost:3000/css/style.css
app . Get ( "/prefix*" , static . New ( "./public" ))
// => http://localhost:3000/prefix/js/script.js
// => http://localhost:3000/prefix/css/style.css
// Serve a single file for any unmatched routes
app . Get ( "*" , static . New ( "./public/index.html" ))
// => http://localhost:3000/any/path/shows/index.html
log . Fatal ( app . Listen ( ":3000" ))
} package main
import (
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
// Middleware that matches any route
app . Use ( func ( c fiber. Ctx ) error {
fmt . Println ( "? First handler" )
return c . Next ()
})
// Middleware that matches all routes starting with /api
app . Use ( "/api" , func ( c fiber. Ctx ) error {
fmt . Println ( "? Second handler" )
return c . Next ()
})
// GET /api/list
app . Get ( "/api/list" , func ( c fiber. Ctx ) error {
fmt . Println ( "? Last handler" )
return c . SendString ( "Hello, World !" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Konfigurationsmotoren rendern
Faser standardmäßig zur HTML/Vorlage, wenn keine Ansichtsmotor festgelegt ist.
Wenn Sie Teilungen ausführen oder eine andere Engine wie Bernstein, Lenker, Schnurrbart oder Mops usw. verwenden möchten, lesen Sie unser Vorlagenpaket, das mehrere Ansichtsmotoren unterstützt.
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/template/pug"
)
func main () {
// Initialize a new Fiber app with Pug template engine
app := fiber . New (fiber. Config {
Views : pug . New ( "./views" , ".pug" ),
})
// Define a route that renders the "home.pug" template
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . Render ( "home" , fiber. Map {
"title" : "Homepage" ,
"year" : 1999 ,
})
})
log . Fatal ( app . Listen ( ":3000" ))
}Gruppe
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func middleware ( c fiber. Ctx ) error {
log . Println ( "Middleware executed" )
return c . Next ()
}
func handler ( c fiber. Ctx ) error {
return c . SendString ( "Handler response" )
}
func main () {
app := fiber . New ()
// Root API group with middleware
api := app . Group ( "/api" , middleware ) // /api
// API v1 routes
v1 := api . Group ( "/v1" , middleware ) // /api/v1
v1 . Get ( "/list" , handler ) // /api/v1/list
v1 . Get ( "/user" , handler ) // /api/v1/user
// API v2 routes
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" ))
}Logger
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/logger"
)
func main () {
app := fiber . New ()
// Use Logger middleware
app . Use ( logger . New ())
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "Hello, Logger!" )
})
log . Fatal ( app . Listen ( ":3000" ))
}CORS
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/cors"
)
func main () {
app := fiber . New ()
// Use CORS middleware with default settings
app . Use ( cors . New ())
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "CORS enabled!" )
})
log . Fatal ( app . Listen ( ":3000" ))
} Überprüfen Sie die Kors, indem Sie einen Domain in Origin -Header übergeben:
curl -H " Origin: http://example.com " --verbose http://localhost:3000HTTP -Methoden
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
// Define routes
app . Get ( "/" , static . New ( "./public" ))
app . Get ( "/demo" , func ( c fiber. Ctx ) error {
return c . SendString ( "This is a demo page!" )
})
app . Post ( "/register" , func ( c fiber. Ctx ) error {
return c . SendString ( "Registration successful!" )
})
// Middleware to handle 404 Not Found
app . Use ( func ( c fiber. Ctx ) error {
return c . SendStatus ( fiber . StatusNotFound ) // => 404 "Not Found"
})
log . Fatal ( app . Listen ( ":3000" ))
}JSON
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main () {
app := fiber . New ()
// Route that returns a JSON object
app . Get ( "/user" , func ( c fiber. Ctx ) error {
return c . JSON ( & User { "John" , 20 })
// => {"name":"John", "age":20}
})
// Route that returns a JSON map
app . Get ( "/json" , func ( c fiber. Ctx ) error {
return c . JSON (fiber. Map {
"success" : true ,
"message" : "Hi John!" ,
})
// => {"success":true, "message":"Hi John!"}
})
log . Fatal ( app . Listen ( ":3000" ))
}Websocket
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/websocket"
)
func main () {
app := fiber . New ()
// WebSocket route
app . Get ( "/ws" , websocket . New ( func ( c * websocket. Conn ) {
defer c . Close ()
for {
// Read message from client
mt , msg , err := c . ReadMessage ()
if err != nil {
log . Println ( "read:" , err )
break
}
log . Printf ( "recv: %s" , msg )
// Write message back to client
err = c . WriteMessage ( mt , msg )
if err != nil {
log . Println ( "write:" , err )
break
}
}
}))
log . Fatal ( app . Listen ( ":3000" ))
// Connect via WebSocket at ws://localhost:3000/ws
}Weitere Informationen
package main
import (
"bufio"
"fmt"
"log"
"time"
"github.com/gofiber/fiber/v3"
"github.com/valyala/fasthttp"
)
func main () {
app := fiber . New ()
// Server-Sent Events route
app . Get ( "/sse" , func ( c fiber. Ctx ) error {
c . Set ( "Content-Type" , "text/event-stream" )
c . Set ( "Cache-Control" , "no-cache" )
c . Set ( "Connection" , "keep-alive" )
c . Set ( "Transfer-Encoding" , "chunked" )
c . Context (). SetBodyStreamWriter ( func ( w * bufio. Writer ) {
var i int
for {
i ++
msg := fmt . Sprintf ( "%d - the time is %v" , i , time . Now ())
fmt . Fprintf ( w , "data: Message: %s n n " , msg )
fmt . Println ( msg )
w . Flush ()
time . Sleep ( 5 * time . Second )
}
})
return nil
})
log . Fatal ( app . Listen ( ":3000" ))
}Genesen
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/recover"
)
func main () {
app := fiber . New ()
// Use Recover middleware to handle panics gracefully
app . Use ( recover . New ())
// Route that intentionally panics
app . Get ( "/" , func ( c fiber. Ctx ) error {
panic ( "normally this would crash your app" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Konfiguration
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New (fiber. Config {
// Configure trusted proxies - WARNING: Only trust proxies you control
// Using TrustProxy: true with unrestricted IPs can lead to IP spoofing
TrustProxy : true ,
TrustProxyConfig : fiber. TrustProxyConfig {
Proxies : [] string { "10.0.0.0/8" , "172.16.0.0/12" }, // Example: Internal network ranges only
},
ProxyHeader : fiber . HeaderXForwardedFor ,
})
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "Trusted Proxy Configured!" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Hier ist eine Liste von Middleware, die im Faser -Framework enthalten sind.
| Middleware | Beschreibung |
|---|---|
| Adapter | Konverter für NET/HTTP -Handler zu/von Faseranforderungshandlern. |
| BasicAuth | Bietet eine grundlegende Authentifizierung von HTTP. Es ruft den nächsten Handler für gültige Anmeldeinformationen auf und 401 nicht autorisiert für fehlende oder ungültige Anmeldeinformationen. |
| Cache | Achsenabschnitt und Cache -HTTP -Antworten. |
| Kompresse | Komprimierung Middleware für Glasfaser mit Unterstützung für deflate , gzip , brotli und zstd . |
| CORS | Aktivieren Sie Cross-Origin-Ressourcenfreigabe (CORS) mit verschiedenen Optionen. |
| CSRF | Vor CSRF -Exploits schützen. |
| EarlyData | Fügt Unterstützung für die frühen Daten ("0-RTT") von TLS 1.3 hinzu. |
| Verschlüsselungskookie | Verschlüsseln Sie Middleware, das Cookie -Werte verschlüsselt. |
| Envvar | Stellen Sie Umgebungsvariablen mit einer optionalen Konfiguration aus. |
| ETAG | Ermöglicht, dass Caches effizienter ist und Bandbreite speichert, da ein Webserver keine vollständige Antwort wiedergeben muss, wenn sich der Inhalt nicht geändert hat. |
| Expvar | Dient über seine HTTP -Server -Laufzeit, die im JSON -Format exponierte Variablen ausgesetzt sind. |
| Favicon | Ignorieren Sie Favicon von Protokollen oder dienen Sie aus dem Speicher, wenn ein Dateipfad bereitgestellt wird. |
| HealthCheck | Langlebigkeits- und Bereitschaftssonden für Faser. |
| Helm | Hilft Ihre Apps zu sichern, indem verschiedene HTTP -Header festgelegt werden. |
| idempotenz | Ermöglicht fehlertolerante APIs, bei denen doppelte Anforderungen nicht fälschlicherweise dieselbe Aktion verursachen, die auf der serverseitigen Aktion mehrfach ausgeführt wird. |
| KeyAuth | Fügt Unterstützung für die wichtige Authentifizierung hinzu. |
| Limiter | Fügt die faserbeschränkende Unterstützung zu. Verwenden Sie, um wiederholte Anfragen an öffentliche APIs und/oder Endpunkte wie das Zurücksetzen des Kennworts zu beschränken. |
| Logger | HTTP -Anforderung/Antwortprotokoll. |
| PPROF | Serviert Runtime Profiling -Daten im PPROF -Format. |
| Proxy | Ermöglicht Sie Proxy -Anforderungen an mehrere Server. |
| genesen | Erholt sich von der Panik überall in der Stapelkette und übernimmt die Steuerung mit dem zentralisierten Fehlerhandler. |
| umleiten | Middleware umleiten. |
| anfrage | Fügt jeder Anfrage eine Anforderungs -ID hinzu. |
| umschreiben | Schreiben Sie den URL -Pfad nach bereitgestellten Regeln neu. Es kann hilfreich sein, um die Kompatibilität rückwärts oder nur sauberere und beschreibende Links zu erstellen. |
| Sitzung | Session Middleware. Hinweis: Diese Middleware verwendet unser Speicherpaket. |
| überspringen | Überspringen Sie die Middleware, die einen verpackten Handler überspringt, wenn ein Prädikat wahr ist. |
| statisch | Statische Middleware für Faser, die statische Dateien wie Bilder , CSS und JavaScript bedient. |
| Time-out | Fügt eine maximale Zeit für eine Anfrage hinzu und leitet es an ERRORHandler weiter, wenn sie überschritten wird. |
Liste der extern gehosteten Middleware -Module, die vom Faserteam gepflegt werden.
| Middleware | Beschreibung |
|---|---|
| beitragen | Middlewares von Drittanbietern |
| Lagerung | Vorgefertigte Speichertreiber, die die Speicherschnittstelle implementieren, die für die Verwendung mit verschiedenen Faser -Middlewares ausgelegt ist. |
| Vorlage | Dieses Paket enthält 9 Vorlagenmotoren, die mit Glasfaser v3 verwendet werden können. GO Version 1.23 oder höher ist erforderlich. |
Weitere Artikel, Middlewares, Beispiele oder Tools finden Sie in unserer fantastischen Liste.
Wenn Sie sich bei Ihnen bedanken und/oder die aktive Entwicklung von Fiber unterstützen möchten:
Um sicherzustellen, dass Ihre Beiträge für eine Pull -Anfrage bereit sind, verwenden Sie bitte die folgenden Makefile -Befehle. Diese Tools tragen zur Aufrechterhaltung der Codequalität und -konsistenz.
Führen Sie diese Befehle aus, um sicherzustellen, dass Ihr Code an Projektnormen und Best Practices festhält.
Fiber ist ein Open-Source-Projekt, das Spenden für die Zahlung der Rechnungen, z. B. unserem Domainnamen, Gitbook, Netlify und Serverless-Hosting betreibt. Wenn Sie Faser unterstützen möchten, können Sie hier einen Kaffee kaufen .
| Benutzer | Spende | |
|---|---|---|
| @destari | ☕ x 10 | |
| @DembyGenesis | ☕ x 5 | |
| @Thomasvvugt | ☕ x 5 | |
| @Hendratommy | ☕ x 5 | |
| @Ekaputra07 | ☕ x 5 | |
| @jorgefuertes | ☕ x 5 | |
| @candidosales | ☕ x 5 | |
| @l0nax | ☕ x 3 | |
| @bihe | ☕ x 3 | |
| @justdave | ☕ x 3 | |
| @koddr | ☕ x 1 | |
| @lapolinar | ☕ x 1 | |
| @Diegowifi | ☕ x 1 | |
| @SSIMK0 | ☕ x 1 | |
| @Raymayemir | ☕ x 1 | |
| @Melkorm | ☕ x 1 | |
| @marvinjwendt | ☕ x 1 | |
| @toishy | ☕ x 1 |
Copyright (C) 2019-Präsentation Fenny und Mitwirkende. Fiber ist kostenlos und Open-Source-Software lizenziert im Rahmen der MIT-Lizenz. Das offizielle Logo wurde von Vic Shóstak erstellt und unter Creative Commons Lizenz (CC BY-SA 4.0 International) verteilt.
