negroni

The negroni.Classic() function is a convenient way to start a server with a set of default middleware: Recovery (to handle panics), Logging (to log requests/responses), and Static (to serve files from a "public" directory).

package main

import (
  "fmt"
  "net/http"

  "github.com/urfave/negroni/v3"
)

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Welcome to the home page!")
  })

  n := negroni.Classic() // Includes default middleware
  n.UseHandler(mux)

  http.ListenAndServe(":3000", n)
}

You can start a basic web server by creating a net/http multiplexer and wrapping it with negroni.Classic(). negroni.Classic() provides default middleware including negroni.Recovery, negroni.Logging, and negroni.Static (for serving files from a public directory).

package main

import (
  "github.com/urfave/negroni/v3"
  "net/http"
  "fmt"
)

func main() {
  mux := http.NewServeMux()
  mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "Willkommen auf der Homepage!")
  })

  n := negroni.Classic()
  n.UseHandler(mux)
  n.Run(":3000")
}

To use Negroni in your Go project, install the v3 package using go get. Note that Go 1.1 or higher is required.

go get github.com/urfave/negroni/v3

To apply middleware to specific routes (e.g., using Gorilla Mux), wrap the sub-router or specific handler in a new Negroni instance. This allows you to isolate middleware to specific path prefixes.

router := mux.NewRouter()
apiRoutes := mux.NewRouter()

// Shared middleware base
common := negroni.New(
	Middleware1,
	Middleware2,
)

// Apply common middleware + API-specific middleware to the /api prefix
router.PathPrefix("/api").Handler(common.With(
	APIMiddleware1,
	negroni.Wrap(apiRoutes),
))

Negroni follows a 'Bring Your Own Router' (BYOR) philosophy. It is designed to work with any net/http compatible router, such as Gorilla Mux. You should add your router as the final handler using UseHandler().

router := mux.NewRouter()
router.HandleFunc("/", HomeHandler)

n := negroni.New(Middleware1, Middleware2)
n.Use(Middleware3)
// Add the router last
n.UseHandler(router)

http.ListenAndServe(":3001", n)

To apply a specific set of middleware to a subset of routes, create a new Negroni instance and wrap it using negroni.Wrap(). You can also use With() to extend a base Negroni instance with additional middleware for specific routes.

Using negroni.Wrap() with a sub-router:

router.PathPrefix("/subpath").Handler(negroni.New(
  Middleware1,
  Middleware2,
  negroni.Wrap(subRouter),
))

Using With() to share common middleware:

common := negroni.New(Middleware1, Middleware2)

// API routes with common middleware + API specific middleware
router.PathPrefix("/api").Handler(common.With(
  APIMiddleware1,
  negroni.Wrap(apiRoutes),
))

To speed up the development of Negroni-compatible middleware or full web applications, you can use the following scaffolding tools:

• mooseware: A skeleton for writing Negroni-compatible middleware handlers.
• Go-Skeleton: An efficient skeleton for building web-based Go/Negroni projects.

Negroni follows the 'Bring Your Own Routing' (TSPR) pattern. It is designed to work with any net/http compatible router, such as Gorilla Mux. To integrate, add your router as the final handler in the Negroni chain using UseHandler().

router := mux.NewRouter()
router.HandleFunc("/", HomeHandler)

n := negroni.New(Middleware1, Middleware2)
// Or use a middleware with the Use() function
n.Use(Middleware3)
// router goes last
n.UseHandler(router)

n.Run(":3000")

To apply specific middleware to a subset of routes, create a new Negroni instance for that group and wrap it using negroni.Wrap(). This instance can then be passed as a handler to your main router.

router := mux.NewRouter()
apiRoutes := mux.NewRouter()
// add api routes here

// create common middleware to be shared across routes
common := negroni.New(
	Middleware1,
	Middleware2,
)

// create a new negroni for the api middleware
// using the common middleware as a base
router.PathPrefix("/api").Handler(common.With(
  APIMiddleware1,
  negroni.Wrap(apiRoutes),
))

Negroni is not a router; it is a middleware library. You should use it alongside a router like net/http.ServeMux or gorilla/mux. To integrate, use n.UseHandler(router) to ensure the router is the final handler in the middleware chain.

router := mux.NewRouter()
router.HandleFunc("/", HomeHandler)

n := negroni.New(Middleware1, Middleware2)
// Or use a middleware with the Use() function
n.Use(Middleware3)
// router goes last
n.UseHandler(router)

http.ListenAndServe(":3001", n)

To apply middleware to a specific subset of routes, create a new Negroni instance for that group and wrap it using negroni.Wrap(). This instance can then be used as a handler within your main router.

router := mux.NewRouter()
adminRoutes := mux.NewRouter()
// Add Admin routes here

// Create a new Negroni instance for the Admin middleware
router.Handle("/admin", negroni.New(
  Middleware1,
  Middleware2,
  negroni.Wrap(adminRoutes),
))