Rust轻量级路由库burn-router使用指南

介绍

burn-router是一个轻量级、高性能的Rust Web路由库，专为构建高效Web应用而设计。它具有以下特点：

• 极简设计：核心功能精简，不包含多余依赖
• 高性能：基于Trie树的路由匹配算法，查找效率高
• 灵活路由：支持参数路由、通配符和正则匹配
• 中间件支持：可扩展的中间件系统

安装

在Cargo.toml中添加依赖：

[dependencies]
burn-router = "0.3"

基本使用

1. 创建路由和处理函数

use burn_router::{Router, Request, Response};

// 首页处理函数
async fn index(_req: Request) -> Response {
    Response::new().body("Hello, Burn Router!")
}

// 问候处理函数
async fn greet(req: Request) -> Response {
    let name = req.params().get("name").unwrap();
    Response::new().body(format!("Hello, {}!", name))
}

#[tokio::main]
async fn main() {
    let mut router = Router::new();
    
    // 添加路由
    router.get("/", index);
    router.get("/greet/:name", greet);
    
    // 启动服务器
    router.serve("127.0.0.1:8080").await.unwrap();
}

2. 路由参数

burn-router支持多种参数匹配方式：

// 路径参数示例
router.get("/user/:id", user_handler);

// 通配符匹配示例
router.get("/post/*", post_handler);

// 正则匹配示例
router.get(r"/date/(\d{4}-\d{2}-\d{2})", date_handler);

3. 中间件使用

use burn_router::middleware::{Middleware, Next};

// 日志中间件
async fn logger_middleware(req: Request, next: Next) -> Response {
    println!("Request: {} {}", req.method(), req.path());
    next.run(req).await
}

fn main() {
    let mut router = Router::new();
    // 添加全局中间件
    router.with(logger_middleware);
    
    // 路由定义...
}

高级功能

1. 路由分组

let mut api_router = Router::new();
api_router.get("/users", list_users);
api_router.post("/users", create_user);

let mut main_router = Router::new();
// 挂载子路由
main_router.nest("/api", api_router);

2. 自定义错误处理

use burn_router::Error;

// 404处理函数
async fn handle_404(_req: Request) -> Response {
    Response::new().status(404).body("Not Found")
}

fn main() {
    let mut router = Router::new();
    // 设置错误处理
    router.set_error_handler(Error::NotFound, handle_404);
    // ...
}

3. 限制HTTP方法

// 同一路径不同方法
router.route("/user")
    .get(get_user)
    .post(create_user)
    .put(update_user)
    .delete(delete_user);

性能优化技巧

1. 路由顺序：将最频繁访问的路由放在前面
2. 减少动态路由：尽量使用静态路由
3. 合理使用中间件：避免不必要的中间件处理

完整示例demo

下面是一个完整的burn-router使用示例，包含路由、中间件和错误处理：

use burn_router::{Router, Request, Response, Error};
use burn_router::middleware::{Middleware, Next};

// 处理函数
async fn home(_req: Request) -> Response {
    Response::new().body("Welcome to Home Page")
}

async fn user_profile(req: Request) -> Response {
    let id = req.params().get("id").unwrap();
    Response::new().body(format!("User Profile: {}", id))
}

async fn about(_req: Request) -> Response {
    Response::new().body("About Us")
}

// 自定义404处理
async fn not_found(_req: Request) -> Response {
    Response::new().status(404).body("Custom 404 Page")
}

// 认证中间件
async fn auth_middleware(req: Request, next: Next) -> Response {
    if let Some(token) = req.headers().get("Authorization") {
        println!("Auth token: {}", token);
        next.run(req).await
    } else {
        Response::new().status(401).body("Unauthorized")
    }
}

// 日志中间件
async fn logger_middleware(req: Request, next: Next) -> Response {
    println!("[{}] {}", req.method(), req.path());
    next.run(req).await
}

#[tokio::main]
async fn main() {
    let mut router = Router::new();
    
    // 添加中间件
    router.with(logger_middleware);
    router.with(auth_middleware);
    
    // 添加路由
    router.get("/", home);
    router.get("/about", about);
    router.get("/user/:id", user_profile);
    
    // 设置错误处理
    router.set_error_handler(Error::NotFound, not_found);
    
    // 启动服务器
    println!("Server running on http://127.0.0.1:8080");
    router.serve("127.0.0.1:8080").await.unwrap();
}

示例项目结构

src/
├── main.rs
├── handlers/
│   ├── mod.rs
│   ├── user.rs
│   └── post.rs
└── middleware/
    ├── mod.rs
    └── auth.rs

通过burn-router，你可以快速构建高效、可维护的Rust Web应用路由系统。它的轻量级设计特别适合需要高性能路由的场景。