Advanced Routing System Dynamic URL RESTful API Design（1750818294761000）

#webdev #programming #rust #java

As a junior student learning web development, routing systems have always been one of the most complex parts for me. Traditional framework routing configurations often require lots of boilerplate code and lack type safety. When I encountered this Rust framework's routing system, I was deeply impressed by its simplicity and powerful functionality.

Core Philosophy of the Routing System

This framework's routing system design philosophy is "convention over configuration." Through attribute macros and the type system, it makes route definitions both concise and type-safe.

use hyperlane::*;

// Basic route definition
#[get]
async fn home_page(ctx: Context) {
    ctx.set_response_status_code(200).await;
    ctx.set_response_body("Welcome to Home Page").await;
}

#[post]
async fn create_user(ctx: Context) {
    let body = ctx.get_request_body().await;
    // Handle user creation logic
    ctx.set_response_status_code(201).await;
    ctx.set_response_body("User created").await;
}

// Support multiple HTTP methods
#[methods(get, post)]
async fn flexible_handler(ctx: Context) {
    let method = ctx.get_request_method().await;
    match method {
        Method::GET => {
            ctx.set_response_body("GET request handled").await;
        }
        Method::POST => {
            ctx.set_response_body("POST request handled").await;
        }
        _ => {
            ctx.set_response_status_code(405).await;
        }
    }
}

#[tokio::main]
async fn main() {
    let server = Server::new();
    server.host("0.0.0.0").await;
    server.port(8080).await;

    // Register routes
    server.route("/", home_page).await;
    server.route("/users", create_user).await;
    server.route("/flexible", flexible_handler).await;

    server.run().await.unwrap();
}

This declarative route definition approach makes code very clear. Each function's purpose is immediately apparent, and the compiler can check route correctness at compile time.

Dynamic Routing: The Art of Parameterized URLs

Dynamic routing is a core feature of modern web applications. This framework provides powerful and flexible dynamic routing support:

use hyperlane::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
    created_at: chrono::DateTime<chrono::Utc>,
}

// Simple path parameters
#[get]
async fn get_user_by_id(ctx: Context) {
    let params = ctx.get_route_params().await;
    let user_id: u32 = match params.get("id").and_then(|id| id.parse().ok()) {
        Some(id) => id,
        None => {
            ctx.set_response_status_code(400).await;
            ctx.set_response_body("Invalid user ID").await;
            return;
        }
    };

    // Simulate fetching user from database
    let user = User {
        id: user_id,
        name: format!("User {}", user_id),
        email: format!("user{}@example.com", user_id),
        created_at: chrono::Utc::now(),
    };

    let response = serde_json::to_string(&user).unwrap();
    ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON).await;
    ctx.set_response_status_code(200).await;
    ctx.set_response_body(response).await;
}

// Multi-level path parameters
#[get]
async fn get_user_posts(ctx: Context) {
    let params = ctx.get_route_params().await;
    let user_id = params.get("user_id").unwrap_or("0");
    let post_id = params.get("post_id").unwrap_or("0");

    let response = serde_json::json!({
        "user_id": user_id,
        "post_id": post_id,
        "title": format!("Post {} by User {}", post_id, user_id),
        "content": "This is a sample post content."
    });

    ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON).await;
    ctx.set_response_status_code(200).await;
    ctx.set_response_body(response.to_string()).await;
}

// Wildcard routing
#[get]
async fn serve_static_files(ctx: Context) {
    let params = ctx.get_route_params().await;
    let file_path = params.get("file").unwrap_or("index.html");

    // Security check: prevent path traversal attacks
    if file_path.contains("..") || file_path.starts_with('/') {
        ctx.set_response_status_code(403).await;
        ctx.set_response_body("Forbidden").await;
        return;
    }

    let full_path = format!("static/{}", file_path);

    // Simulate file serving
    match tokio::fs::read(&full_path).await {
        Ok(content) => {
            let content_type = get_content_type(&file_path);
            ctx.set_response_header(CONTENT_TYPE, content_type).await;
            ctx.set_response_status_code(200).await;
            ctx.set_response_body(content).await;
        }
        Err(_) => {
            ctx.set_response_status_code(404).await;
            ctx.set_response_body("File not found").await;
        }
    }
}

fn get_content_type(file_path: &str) -> &'static str {
    match file_path.split('.').last() {
        Some("html") => "text/html",
        Some("css") => "text/css",
        Some("js") => "application/javascript",
        Some("json") => "application/json",
        Some("png") => "image/png",
        Some("jpg") | Some("jpeg") => "image/jpeg",
        _ => "application/octet-stream",
    }
}

#[tokio::main]
async fn main() {
    let server = Server::new();
    server.host("0.0.0.0").await;
    server.port(8080).await;

    // Register dynamic routes
    server.route("/users/{id}", get_user_by_id).await;
    server.route("/users/{user_id}/posts/{post_id}", get_user_posts).await;
    server.route("/static/{file:^.*$}", serve_static_files).await;

    server.run().await.unwrap();
}

This example demonstrates three different types of dynamic routing:

Simple parameter routing: /users/{id}
Multi-level parameter routing: /users/{user_id}/posts/{post_id}
Wildcard routing: /static/{file:^.*$}

RESTful API Design: Best Practices

RESTful APIs are the standard for modern web services. This framework makes implementing RESTful APIs very simple:

use hyperlane::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

#[derive(Serialize, Deserialize, Clone)]
struct Article {
    id: u32,
    title: String,
    content: String,
    author: String,
    created_at: chrono::DateTime<chrono::Utc>,
    updated_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Deserialize)]
struct CreateArticleRequest {
    title: String,
    content: String,
    author: String,
}

#[derive(Deserialize)]
struct UpdateArticleRequest {
    title: Option<String>,
    content: Option<String>,
}

// Simulate data storage
type ArticleStore = Arc<RwLock<HashMap<u32, Article>>>;

static mut ARTICLE_STORE: Option<ArticleStore> = None;

fn get_article_store() -> &'static ArticleStore {
    unsafe {
        ARTICLE_STORE.get_or_insert_with(|| {
            Arc::new(RwLock::new(HashMap::new()))
        })
    }
}

// GET /articles - Get all articles
#[get]
async fn list_articles(ctx: Context) {
    let store = get_article_store();
    let articles = store.read().await;
    let article_list: Vec<Article> = articles.values().cloned().collect();

    let response = serde_json::to_string(&article_list).unwrap();
    ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON).await;
    ctx.set_response_status_code(200).await;
    ctx.set_response_body(response).await;
}

// GET /articles/{id} - Get specific article
#[get]
async fn get_article(ctx: Context) {
    let params = ctx.get_route_params().await;
    let article_id: u32 = match params.get("id").and_then(|id| id.parse().ok()) {
        Some(id) => id,
        None => {
            ctx.set_response_status_code(400).await;
            ctx.set_response_body("Invalid article ID").await;
            return;
        }
    };

    let store = get_article_store();
    let articles = store.read().await;

    match articles.get(&article_id) {
        Some(article) => {
            let response = serde_json::to_string(article).unwrap();
            ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON).await;
            ctx.set_response_status_code(200).await;
            ctx.set_response_body(response).await;
        }
        None => {
            ctx.set_response_status_code(404).await;
            ctx.set_response_body("Article not found").await;
        }
    }
}

// POST /articles - Create new article
#[post]
async fn create_article(ctx: Context) {
    let body = ctx.get_request_body().await;
    let request: CreateArticleRequest = match serde_json::from_slice(&body) {
        Ok(req) => req,
        Err(_) => {
            ctx.set_response_status_code(400).await;
            ctx.set_response_body("Invalid JSON").await;
            return;
        }
    };

    let store = get_article_store();
    let mut articles = store.write().await;

    let article_id = articles.len() as u32 + 1;
    let now = chrono::Utc::now();

    let article = Article {
        id: article_id,
        title: request.title,
        content: request.content,
        author: request.author,
        created_at: now,
        updated_at: now,
    };

    articles.insert(article_id, article.clone());

    let response = serde_json::to_string(&article).unwrap();
    ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON).await;
    ctx.set_response_header("Location", format!("/articles/{}", article_id)).await;
    ctx.set_response_status_code(201).await;
    ctx.set_response_body(response).await;
}

#[tokio::main]
async fn main() {
    let server = Server::new();
    server.host("0.0.0.0").await;
    server.port(8080).await;

    // RESTful API routes
    server.route("/articles", list_articles).await;
    server.route("/articles", create_article).await;
    server.route("/articles/{id}", get_article).await;

    server.run().await.unwrap();
}

Real Application Results

In my projects, this routing system brought significant benefits:

Development Efficiency: Declarative route definitions greatly reduced boilerplate code
Type Safety: Compile-time checking avoided runtime routing errors
Excellent Performance: Efficient routing matching algorithm supports high-concurrency access
Easy Maintenance: Clear routing structure makes code easier to understand and maintain

Through monitoring data, I found that after using this routing system: