Golang基于Trie树实现的高性能HTTP路由插件库goblin的使用

goblin是一个基于Trie树实现的Golang HTTP路由器，具有高性能和轻量级的特点。

特性

• 支持Go 1.16及以上版本
• 基于Trie树的简单数据结构
• 轻量级
  • 代码行数：2428
  • 包大小：140K
• 除了标准包外没有其他依赖
• 兼容net/http
• 比net/http的ServeMux更高级
  • 基于方法的路由
  • 命名参数路由
  • 基于正则表达式的路由
  • 中间件支持
  • 可定制的错误处理程序
  • 默认OPTIONS处理程序
• 0分配
  • 静态路由实现0分配
  • 命名路由约3分配

安装

go get -u github.com/bmf-san/goblin

使用示例

基于方法的路由

r := goblin.NewRouter()

r.Methods(http.MethodGet).Handler(`/`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "/")
}))

r.Methods(http.MethodGet, http.MethodPost).Handler(`/methods`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodGet {
        fmt.Fprintf(w, "GET")
    }
    if r.Method == http.MethodPost {
        fmt.Fprintf(w, "POST")
    }
}))

http.ListenAndServe(":9999", r)

命名参数路由

r := goblin.NewRouter()

r.Methods(http.MethodGet).Handler(`/foo/:id`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    id := goblin.GetParam(r.Context(), "id")
    fmt.Fprintf(w, "/foo/%v", id)
}))

r.Methods(http.MethodGet).Handler(`/foo/:name`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    name := goblin.GetParam(r.Context(), "name")
    fmt.Fprintf(w, "/foo/%v", name)
}))

http.ListenAndServe(":9999", r)

基于正则表达式的路由

r.Methods(http.MethodGet).Handler(`/foo/:id[^\d+$]`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    id := goblin.GetParam(r.Context(), "id")
    fmt.Fprintf(w, "/foo/%v", id)
}))

中间件

// 实现返回http.Handler的中间件函数
func global(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "global: before\n")
		next.ServeHTTP(w, r)
		fmt.Fprintf(w, "global: after\n")
	})
}

func first(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "first: before\n")
		next.ServeHTTP(w, r)
		fmt.Fprintf(w, "first: after\n")
	})
}

func second(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "second: before\n")
		next.ServeHTTP(w, r)
		fmt.Fprintf(w, "second: after\n")
	})
}

func third(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "third: before\n")
		next.ServeHTTP(w, r)
		fmt.Fprintf(w, "third: after\n")
	})
}

r := goblin.NewRouter()

// 设置全局中间件
r.UseGlobal(global)
r.Methods(http.MethodGet).Handler(`/globalmiddleware`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "/globalmiddleware\n")
}))

// 使用Use方法应用中间件
r.Methods(http.MethodGet).Use(first).Handler(`/middleware`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "middleware\n")
}))

// 可以配置多个中间件
r.Methods(http.MethodGet).Use(second, third).Handler(`/middlewares`, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "middlewares\n")
}))

http.ListenAndServe(":9999", r)

请求/globalmiddleware会得到以下结果：

global: before
/globalmiddleware
global: after

请求/middleware会得到以下结果：

global: before
first: before
middleware
first: after
global: after

请求/middlewares会得到以下结果：

global: before
second: before
third: before
middlewares
third: after
second: after
global: after

自定义错误处理程序

func customMethodNotFound() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "customMethodNotFound")
	})
}

func customMethodAllowed() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "customMethodNotAllowed")
	})
}

r := goblin.NewRouter()
r.NotFoundHandler = customMethodNotFound()
r.MethodNotAllowedHandler = customMethodAllowed()

http.ListenAndServe(":9999", r)

默认OPTIONS处理程序

func DefaultOPTIONSHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusNoContent)
	})
}

r := goblin.NewRouter()
r.DefaultOPTIONSHandler = DefaultOPTIONSHandler()

http.ListenAndServe(":9999", r)

默认的OPTIONS处理程序在处理CORS OPTIONS请求(预检请求)时非常有用。

设计

goblin内部使用Trie树数据结构，相比基数树(Radix Tree)，Trie树虽然性能稍逊，但算法更简单，更易于理解和维护。

路由定义在内部表示为树结构，每个HTTP方法都有自己的树，每个节点包含处理程序和中间件定义等数据。

完整示例

package main

import (
	"fmt"
	"net/http"

	"github.com/bmf-san/goblin"
)

func main() {
	r := goblin.NewRouter()

	// 简单路由
	r.Methods(http.MethodGet).Handler("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Welcome to goblin!")
	}))

	// 命名参数路由
	r.Methods(http.MethodGet).Handler("/user/:name", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		name := goblin.GetParam(r.Context(), "name")
		fmt.Fprintf(w, "Hello, %s!", name)
	}))

	// 正则表达式路由
	r.Methods(http.MethodGet).Handler("/post/:id[^\\d+$]", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		id := goblin.GetParam(r.Context(), "id")
		fmt.Fprintf(w, "Post ID: %s", id)
	}))

	// 中间件示例
	authMiddleware := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			fmt.Println("Auth middleware - before")
			next.ServeHTTP(w, r)
			fmt.Println("Auth middleware - after")
		})
	}

	r.Methods(http.MethodGet).Use(authMiddleware).Handler("/private", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Private area")
	}))

	fmt.Println("Server started at :8080")
	http.ListenAndServe(":8080", r)
}

goblin是一个简单、高效且功能丰富的HTTP路由器，适合需要高性能路由的各种Golang web应用场景。