Use the Static method to serve static files such as images, CSS, and JavaScript.
By default, Static will serve index.html
files in response to a request on a directory.
Signaturefunc (app *App) Static(prefix, root string, config ...Static) Router
Use the following code to serve files in a directory named ./public
Exampleapp.Static("/", "./public")// => http://localhost:3000/hello.html// => http://localhost:3000/js/jquery.js// => http://localhost:3000/css/style.css
Example// Serve files from multiple directoriesapp.Static("/", "./public")// Serve files from "./files" directory:app.Static("/", "./files")
You can use any virtual path prefix (where the path does not actually exist in the file system) for files that are served by the Static method, specify a prefix path for the static directory, as shown below:
Exampleapp.Static("/static", "./public")// => http://localhost:3000/static/hello.html// => http://localhost:3000/static/js/jquery.js// => http://localhost:3000/static/css/style.css
If you want to have a little bit more control regarding the settings for serving static files. You could use the fiber.Static
struct to enable specific settings.
fiber.Static{}// Static defines configuration options when defining static assets.type Static struct {// When set to true, the server tries minimizing CPU usage by caching compressed files.// This works differently than the github.com/gofiber/compression middleware.// Optional. Default value falseCompress bool `json:"compress"`// When set to true, enables byte range requests.// Optional. Default value falseByteRange bool `json:"byte_range"`// When set to true, enables directory browsing.// Optional. Default value false.Browse bool `json:"browse"`// The name of the index file for serving a directory.// Optional. Default value "index.html".Index string `json:"index"`// Expiration duration for inactive file handlers.// Use a negative time.Duration to disable it.//// Optional. Default value 10 * time.Second.CacheDuration time.Duration `json:"cache_duration"`// The value for the Cache-Control HTTP-header// that is set on the file response. MaxAge is defined in seconds.//// Optional. Default value 0.MaxAge int `json:"max_age"`// Next defines a function to skip this middleware when returned true.//// Optional. Default: nilNext func(c *Ctx) bool}
Example// Custom configapp.Static("/", "./public", fiber.Static{Compress: true,ByteRange: true,Browse: true,Index: "john.html"CacheDuration: 10 * time.Second,MaxAge: 3600,})
Registeres a route bound to a specific HTTP method.
Signatures// HTTP methodsfunc (app *App) Get(path string, handlers ...Handler) Routerfunc (app *App) Head(path string, handlers ...Handler) Routerfunc (app *App) Post(path string, handlers ...Handler) Routerfunc (app *App) Put(path string, handlers ...Handler) Routerfunc (app *App) Delete(path string, handlers ...Handler) Routerfunc (app *App) Connect(path string, handlers ...Handler) Routerfunc (app *App) Options(path string, handlers ...Handler) Routerfunc (app *App) Trace(path string, handlers ...Handler) Routerfunc (app *App) Patch(path string, handlers ...Handler) Router// Add allows you to specifiy a method as valuefunc (app *App) Add(method, path string, handlers ...Handler) Router// All will register the route on all HTTP methods// Almost the same as app.Use but not bound to prefixesfunc (app *App) All(path string, handlers ...Handler) Router
Example// Simple GET handlerapp.Get("/api/list", func(c *fiber.Ctx)error{return c.SendString("I'm a GET request!")})// Simple POST handlerapp.Post("/api/register", func(c *fiber.Ctx) error {return c.SendString("I'm a POST request!")})
Use can be used for middleware packages and prefix catchers. These routes will only match the beginning of each path i.e. /john
will match /john/doe
, /johnnnnn
etc
Signaturesfunc (app *App) Use(args ...interface{}) Router
Example// Match any requestapp.Use(func(c *fiber.Ctx) error {return c.Next()})// Match request starting with /apiapp.Use("/api", func(c *fiber.Ctx) error {return c.Next()})// Attach multiple handlersapp.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()})
You can Mount Fiber instance by creating a *Mount
Signature
func (a *App) Mount(prefix string, app *App) Router
Example
func main() {micro := fiber.New()micro.Get("/doe", func(c *fiber.Ctx) error {return c.SendStatus(fiber.StatusOK)})app := fiber.New()app.Mount("/john", micro) // GET /john/doe -> 200 OKlog.Fatal(app.Listen(":3000"))}
You can group routes by creating a *Group
struct.
Signature
func (app *App) Group(prefix string, handlers ...Handler) Router
Example
func main() {app := fiber.New()api := app.Group("/api", handler) // /apiv1 := api.Group("/v1", handler) // /api/v1v1.Get("/list", handler) // /api/v1/listv1.Get("/user", handler) // /api/v1/userv2 := api.Group("/v2", handler) // /api/v2v2.Get("/list", handler) // /api/v2/listv2.Get("/user", handler) // /api/v2/userlog.Fatal(app.Listen(":3000"))}
Server returns the underlying fasthttp server
func (app *App) Server() *fasthttp.Server
func main() {app := fiber.New()app.Server().MaxConnsPerIP = 1// ...}
This method returns the original router stack
Signaturefunc (app *App) Stack() [][]*Route
Examplevar handler = func(c *fiber.Ctx) {}func main() {app := fiber.New()app.Get("/john", handler)app.Post("/register", handler)data, _ := json.MarshalIndent(app.Stack(), "", " ")fmt.Println(string(data))}
Result[[{"method": "GET","path": "/john/:age","params": ["age"]}],[{"method": "HEAD","path": "/john/:age","params": ["age"]}],[{"method": "POST","path": "/register","params": null}]]
Config returns the app config as value ( read-only ).
Signaturefunc (app *App) Config() Config
Handler returns the server handler that can be used to serve custom *fasthttp.RequestCtx requests.
Signaturefunc (app *App) Handler() fasthttp.RequestHandler
Listen serves HTTP requests from the given address.
Signaturefunc (app *App) Listen(addr string) error
Examples// Listen on port :8080app.Listen(":8080")// Custom hostapp.Listen("127.0.0.1:8080")
ListenTLS serves HTTPs requests from the given address using certFile and keyFile paths to as TLS certificate and key file.
Signaturefunc (app *App) ListenTLS(addr, certFile, keyFile string) error
Examplesapp.ListenTLS(":443", "./cert.pem", "./cert.key");
Using ListenTLS
defaults to the following config ( use Listener
to provide your own config )
Default *tls.Config&tls.Config{MinVersion: tls.VersionTLS12,PreferServerCipherSuites: true,Certificates: []tls.Certificate{cert,},}
You can pass your own net.Listener
using the Listener
method. This method can be used to enable TLS/HTTPS with a custom tls.Config.
Signaturefunc (app *App) Listener(ln net.Listener) error
Exampleln, _ := net.Listen("tcp", ":3000")cer, _:= tls.LoadX509KeyPair("server.crt", "server.key")ln = tls.NewListener(ln, &tls.Config{Certificates: []tls.Certificate{cer}})app.Listener(ln)
Testing your application is done with the Test method. Use this method for creating _test.go
files or when you need to debug your routing logic. The default timeout is 200ms
if you want to disable a timeout altogether, pass -1
as a second argument.
Signaturefunc (app *App) Test(req *http.Request, msTimeout ...int) (*http.Response, error)
Example// Create route with GET method for test:app.Get("/", func(c *fiber.Ctx) error {fmt.Println(c.BaseURL()) // => http://google.comfmt.Println(c.Get("X-Custom-Header")) // => hireturn c.SendString("hello, World!")})// http.Requestreq := httptest.NewRequest("GET", "http://google.com", nil)req.Header.Set("X-Custom-Header", "hi")// http.Responseresp, _ := app.Test(req)// Do something with results:if resp.StatusCode == 200 {body, _ := ioutil.ReadAll(resp.Body)fmt.Println(string(body)) // => Hello, World!}