golang轻量级HTTP路由插件库bellt的使用
Golang轻量级HTTP路由插件库bellt的使用
Bellt是一个简单的Golang HTTP路由器库，具有以下功能特性：
- 定义了标准路由"/health"，用于微服务健康检查
- 支持创建参数化路由（简单或分组路由）
- 支持固定模式、查询字符串和参数多种请求方式
- 可在控制器函数中获取请求参数
安装
使用Go CLI安装：
go get -u github.com/GuilhermeCaruso/bellt
基本使用
初始化路由器
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
log.Fatal(http.ListenAndServe(":8080", nil))
}
处理函数(HandleFunc)
/*
[path] - 端点字符串
[handlerFunc] - 请求处理函数
[methods] - 端点方法切片("GET","POST","PUT","DELETE")
*/
router.HandleFunc(path, handlerFunc, methods)
示例：
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
router.HandleFunc("/bellt", belltHandler, "GET")
log.Fatal(http.ListenAndServe(":8080", nil))
}
func belltHandle(w http.ResponseWriter, r *http.Request){
w.WriteHeader(http.StatusOK)
w.Write([]byte("Simple Golang HTTP router"))
}
分组路由(HandleGroup)
/*
[mainPath] - 用于所有子路由的主路由路径
[subHandleFunc] - 初始化普通路由的函数
*/
router.HandleGroup(mainPath, ...SubHandleFunc)
示例：
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
router.HandleGroup("/api",
router.SubHandleFunc("/bellt", belltHandle, "GET"),
router.SubHandleFunc("/check", checkHandle, "GET"),
)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func belltHandle(w http.ResponseWriter, r *http.Request){
w.WriteHeader(http.StatusOK)
w.Write([]byte("Simple Golang HTTP router"))
}
func checkHandle(w http.ResponseWriter, r *http.Request){
w.WriteHeader(http.StatusOK)
w.Write([]byte("Ok!"))
}
中间件
使用Use方法在HandleFunc或SubHandleFunc中声明中间件：
/*
handlerFunc - 请求处理函数
middlewareList - 中间件切片(Middleware)
*/
bellt.Use(handlerFunc, ...middlewareList)
中间件类型定义：
type Middleware func(http.HandlerFunc) http.HandlerFunc
示例：
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
router.HandleFunc("/hello", bellt.Use(
exampleHandler,
middlewareOne,
middlewareTwo,
), "GET")
router.HandleGroup("/api",
router.SubHandleFunc("/hello", bellt.Use(
exampleHandler,
middlewareOne,
middlewareTwo,
), "GET"),
)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func exampleHandler(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write([]byte(`Hello Middleware!`))
}
func middlewareOne(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Step One")
next.ServeHTTP(w, r)
}
}
func middlewareTwo(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Step Two")
next.ServeHTTP(w, r)
}
}
参数化路由
路由参数需要用{}作为范围限定符：
router.HandleFunc("/hello/{name}", handlerFunc, "GET")
router.HandleGroup("/api",
SubHandleFunc("/item/{id}", handlerFunc, "GET")
)
获取路由变量
使用RouteVariables获取路由参数：
/*
r = HandlerFunc的*Request
*/
rv := bellt.RouteVariables(r)
在HandlerFunc中使用：
func exampleHandler(w http.ResponseWriter, r *http.Request) {
rv := bellt.RouteVariables(r)
w.WriteHeader(http.StatusOK)
w.Write([]byte(fmt.Sprintf(`Hello %v gopher!`, rv.GetVar("color"))))
}
完整参数化路由示例：
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
router.HandleFunc("/contact/{id}/{user}", exampleHandler, "GET")
router.HandleGroup("/api",
router.SubHandleFunc("/check/{id}/{user}", exampleHandler, "GET"),
)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func exampleHandler(w http.ResponseWriter, r *http.Request) {
rv := bellt.RouteVariables(r)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write([]byte(fmt.Sprintf(`{"id": %v, "user": %v}`, rv.GetVar("user"), rv.GetVar("id"))))
}
完整示例
package main
import (
"fmt"
"log"
"net/http"
"github.com/GuilhermeCaruso/bellt"
)
func main() {
router := bellt.NewRouter()
router.HandleFunc("/contact/{id}/{user}", bellt.Use(
exampleHandler,
middlewareOne,
middlewareTwo,
), "GET")
router.HandleFunc("/contact", bellt.Use(
exampleNewHandler,
middlewareOne,
middlewareTwo,
), "GET")
router.HandleGroup("/api",
router.SubHandleFunc("/check", bellt.Use(
exampleNewHandler,
middlewareOne,
middlewareTwo,
), "GET"),
router.SubHandleFunc("/check/{id}/{user}", bellt.Use(
exampleHandler,
middlewareOne,
middlewareTwo,
), "GET"),
)
log.Fatal(http.ListenAndServe(":8080", nil))
}
func exampleHandler(w http.ResponseWriter, r *http.Request) {
rv := bellt.RouteVariables(r)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write([]byte(fmt.Sprintf(`{"id": %v, "user": %v}`, rv.GetVar("user"), rv.GetVar("id"))))
}
func exampleNewHandler(w http.ResponseWriter, r *http.Request) {
rv := bellt.RouteVariables(r)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
w.Write([]byte(`{"msg": "Works"}`))
}
func middlewareOne(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Step One")
next.ServeHTTP(w, r)
}
}
func middlewareTwo(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Step Two")
next.ServeHTTP(w, r)
}
}
性能测试
Bellt在请求性能测试中表现优异：
作者
Guilherme Caruso (@guicaruso_ on twitter)
许可证
MIT licensed. 详见LICENSE文件。
更多关于golang轻量级HTTP路由插件库bellt的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html
1 回复
更多关于golang轻量级HTTP路由插件库bellt的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html
Bellt - 轻量级Golang HTTP路由库使用指南
Bellt是一个极简的Golang HTTP路由库，它的设计目标是简单、轻量且高性能。下面我将详细介绍如何使用Bellt来构建你的HTTP服务。
安装Bellt
首先安装Bellt库：
go get github.com/teamlint/bellt
基本使用
1. 创建路由实例
package main
import (
"net/http"
"github.com/teamlint/bellt"
)
func main() {
// 创建路由实例
router := bellt.NewRouter()
// 添加路由
router.Get("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, Bellt!"))
})
// 启动服务器
http.ListenAndServe(":8080", router)
}
2. 支持多种HTTP方法
Bellt支持常见的HTTP方法：
router.Get("/get", getHandler)
router.Post("/post", postHandler)
router.Put("/put", putHandler)
router.Delete("/delete", deleteHandler)
router.Patch("/patch", patchHandler)
router.Options("/options", optionsHandler)
3. 路径参数
Bellt支持路径参数：
router.Get("/user/:id", func(w http.ResponseWriter, r *http.Request) {
// 获取路径参数
id := bellt.Param(r, "id")
w.Write([]byte("User ID: " + id))
})
4. 路由分组
可以创建路由分组来组织代码：
api := router.Group("/api")
{
api.Get("/users", getUsersHandler)
api.Post("/users", createUserHandler)
user := api.Group("/user")
{
user.Get("/:id", getUserHandler)
user.Put("/:id", updateUserHandler)
user.Delete("/:id", deleteUserHandler)
}
}
5. 中间件支持
Bellt支持中间件：
// 日志中间件
func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Printf("Request: %s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r)
})
}
func main() {
router := bellt.NewRouter()
// 应用全局中间件
router.Use(loggingMiddleware)
// 路由特定的中间件
router.Get("/admin", adminHandler, authMiddleware)
}
6. 静态文件服务
router.ServeFiles("/static/*filepath", http.Dir("./public"))
完整示例
下面是一个完整的示例，展示了Bellt的主要功能：
package main
import (
"log"
"net/http"
"github.com/teamlint/bellt"
)
func main() {
router := bellt.NewRouter()
// 全局中间件
router.Use(loggingMiddleware)
// 基本路由
router.Get("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Welcome to Bellt!"))
})
// 路径参数
router.Get("/hello/:name", func(w http.ResponseWriter, r *http.Request) {
name := bellt.Param(r, "name")
w.Write([]byte("Hello, " + name + "!"))
})
// 路由分组
api := router.Group("/api")
{
api.Get("/users", getUsers)
api.Post("/users", createUser)
// 带中间件的路由
api.Get("/private", privateHandler, authMiddleware)
}
// 静态文件服务
router.ServeFiles("/static/*filepath", http.Dir("./public"))
log.Println("Server started on :8080")
http.ListenAndServe(":8080", router)
}
func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log.Printf("%s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r)
})
}
func authMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 简单的认证检查
if r.Header.Get("Authorization") != "secret" {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
next.ServeHTTP(w, r)
})
}
func getUsers(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("User list"))
}
func createUser(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("User created"))
}
func privateHandler(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Private area"))
}
Bellt的特点
- 轻量级：代码量少，不依赖其他库
- 高性能：基于标准库http.Handler接口，性能接近原生
- 简单API：学习曲线低，易于上手
- 中间件支持：兼容标准库中间件
- 路由分组：方便组织大型应用
与其他路由库的比较
- 比
gorilla/mux更轻量 - 比
httprouter更简单 - 比
gin更接近标准库
Bellt非常适合小型到中型项目，特别是当你需要轻量级路由功能而不想引入复杂框架时。
希望这个指南能帮助你快速上手Bellt路由库！
