router

Router

A minimalist and fast router framework for golang. Inspired by the most popular node.js web framework, express.js. It implements ServeHTTP interface so you can use express style routing. It also wraps and extends the net/http Request and ResponseWriter into an easy to read and use function signature.

The main features are:

• Simple router, handler, and middleware
• The speed is up to 9 times faster than express.js
• Chainable router, request and response.
• Standard net/http compatible. Ready for google serverless

• Get started
• Routing
• Handler
• Middleware
• Header
• Cookie
• Context
• Logging
• Example
• Cloud function
• Benchmarks

Get Started

Init folder and install

mkdir app
cd app
go mod init myapp
go get github.com/fastrodev/router

Create main.go file

package main

import (
	"github.com/fastrodev/router"
	"github.com/fastrodev/router/http"
)

func main() {
	app := router.New()
	app.Get("/", func(req http.Request, res http.Response) {
		res.Send("hello")
	})
	app.Listen(9000)
}

Run webapp

go run main.go

Routing

You can add a new route with all http method and http param with :param.

app.Get("/user/:id", handler)

You can append a regular expression in parentheses (())

app.Get("/user/:id([0-9]+)", handler)

Handler

The signature is similar to express.js handler.

func handler(req http.Request, res http.Response) {
	res.Send("hello")
}

Header

HTTP headers let the client and the server pass additional information with an HTTP request or response.

header := res.Header()
header.Set("sid", "123321")

Cookie

A cookie is information stored on your computer by a website you visit.

Get a cookie

c, err := req.Cookie("name")

Create a cookie

c := http.NewCookie()
expire := time.Now().Add(5 * time.Minute)
c.Name("name").Value("agus").Expires(expire)

Then attach it to response

res.Cookie(c)

Context

You can add a context using the app.Ctx(ctx) function

app.Ctx(context.Background())

You can access the context from Request

ctx := req.Context()

and use it again via req.WithContext(ctx)

req = req.WithContext(ctx)

Logging

You can add a logger using the app.Log(log) function

app.Log(log.Default())

Middleware

It have access to the request, the response, and the next function in the application’s request-response cycle.

Application-level middleware

func rootMiddleware(req http.Request, res http.Response, next http.Next) {
	if req.URL.Path != "/" {
		req = req.ErrorMiddleware(std.ErrAbortHandler, std.StatusForbidden)
		next(req, res)
		return
	}
	next(req, res)
}
app.Use(rootMiddleware)

Router-level middleware

handler := func(req http.Request, res http.Response) {
	res.Send("hello")
}

middleware := func(req http.Request, res http.Response, next http.Next) {
	// put your logic here
	next(req, res)
}

app.Get("/", handler, middleware)

Example

You can find above implementations in the following source code: main.go.

Cloud Function

If you want to use serverless computing, you can deploy your codes to google cloud function. With this approach, you don't call the Listen function again. You must create a new function as the entry point for standard net/http Request and ResponseWriter.

Source code: main.go

package function

import (
	std "net/http"

	"github.com/fastrodev/router"
	"github.com/fastrodev/router/http"
)

func createRouter() router.Router {
	app := router.New()
	app.Get("/", func(req http.Request, res http.Response) {
		res.Send("Hello")
	})
	return app
}

func HelloHTTP(w std.ResponseWriter, r *std.Request) {
	createRouter().ServeHTTP(w, r)
}

How to deploy

Reference: deploying the function

gcloud functions deploy HelloHTTP --runtime go113 --trigger-http --allow-unauthenticated

Live demo: HelloHTTP

Benchmarks

Router framework vs standard net/http

You can view the details here: benchmarks

Contributing

We appreciate your help! The main purpose of this repository is to improve performance and readability, making it faster and easier to use.