Architecture（1750330783854700）

As a third-year computer science student, I have repeatedly experienced how architecture design determines code maintainability and development efficiency. Every time a project grows or requirements change, poor architecture becomes a nightmare. Only after using this Rust web framework did I truly understand that "architecture is productivity." Today, from the perspective of a ten-year editor and developer, I want to share my thoughts on modern web architecture, modularity, type safety, and error handling, based on real project experience. The Power of Layered Architecture In traditional Node.js or Python web frameworks, project structure often becomes chaotic as business grows. In contrast, this framework naturally supports layered architecture, making code organization clear and maintenance easy. // lib.rs - Main application structure pub mod controllers; pub mod services; pub mod repositories; pub mod models; pub mod middleware; pub mod errors; pub mod config; use hyperlane::prelude::*; #[derive(Clone)] pub struct AppState { pub db_pool: PgPool, pub redis_pool: Pool, pub config: AppConfig, } pub fn create_app(state: AppState) -> App { App::new() .with_state(state) .route("/api/users", get(controllers::users::list)) .route("/api/users", post(controllers::users::create)) .route("/api/users/:id", get(controllers::users::get_by_id)) .route("/api/users/:id", put(controllers::users::update)) .route("/api/users/:id", delete(controllers::users::delete)) .middleware(middleware::logging::LoggingMiddleware) .middleware(middleware::auth::AuthMiddleware) .middleware(middleware::cors::CorsMiddleware) } Type Safety and Modularity In this framework, type safety is not just a slogan but a guarantee for every line of code. Whether it's request parameters, database models, or middleware, the type system catches potential errors at compile time. #[derive(Debug, Clone, Serialize, Deserialize)] pub struct User { pub id: Option, pub name: String, pub email: String, pub created_at: DateTime, } // Controller layer pub async fn create( State(state): State, Json(user_data): Json ) -> Result { let user = services::user_service::create_user(user_data, &state.db_pool).await?; Ok((StatusCode::CREATED, Json(user))) } Elegant Error Handling In dynamic language frameworks like Express.js, errors often surface at runtime, making debugging painful. This framework leverages the Result type and custom error systems to elevate error handling to the architectural level. #[derive(Debug, thiserror::Error)] enum AppError { #[error("Validation error: {0}")] Validation(String), #[error("Database error: {0}")] Database(#[from] sqlx::Error), #[error("Auth error: {0}")] Auth(String), #[error("Not found: {0}")] NotFound(String), #[error("Internal server error")] Internal, } impl IntoResponse for AppError { fn into_response(self) -> Response { let (status, error_code, message) = match self { AppError::Validation(msg) => ( StatusCode::BAD_REQUEST, "VALIDATION_ERROR", msg ), AppError::Database(e) => ( StatusCode::INTERNAL_SERVER_ERROR, "DATABASE_ERROR", e.to_string() ), AppError::Auth(msg) => ( StatusCode::UNAUTHORIZED, "AUTH_ERROR", msg ), AppError::NotFound(resource) => ( StatusCode::NOT_FOUND, "NOT_FOUND", format!("Resource not found: {}", resource) ), AppError::Internal => ( StatusCode::INTERNAL_SERVER_ERROR, "INTERNAL_ERROR", "Internal server error".to_string() ), }; let body = serde_json::json!({ "error": { "code": error_code, "message": message, "timestamp": chrono::Utc::now().to_rfc3339() } }); Response::builder() .status(status) .header("content-type", "application/json") .body(Json(body).into_response()) .unwrap() } } Middleware and Extensibility The middleware mechanism in this framework is extremely flexible, supporting chain calls and custom extensions. Compared to Spring Boot's interceptors or Express's middleware chain, here you get both type safety and high expressiveness. #[derive(Clone)] struct LoggingMiddleware; impl Middleware for LoggingMiddleware { async fn call( self, request: Request, next: Next ) -> Result { let start = Instant::now(); let method = request.method().clone(); let uri = request.uri().clone(); let

// lib.rs - Main application structure
pub mod controllers;
pub mod services;
pub mod repositories;
pub mod models;
pub mod middleware;
pub mod errors;
pub mod config;

use hyperlane::prelude::*;

#[derive(Clone)]
pub struct AppState {
    pub db_pool: PgPool,
    pub redis_pool: Pool<Redis>,
    pub config: AppConfig,
}

pub fn create_app(state: AppState) -> App {
    App::new()
        .with_state(state)
        .route("/api/users", get(controllers::users::list))
        .route("/api/users", post(controllers::users::create))
        .route("/api/users/:id", get(controllers::users::get_by_id))
        .route("/api/users/:id", put(controllers::users::update))
        .route("/api/users/:id", delete(controllers::users::delete))
        .middleware(middleware::logging::LoggingMiddleware)
        .middleware(middleware::auth::AuthMiddleware)
        .middleware(middleware::cors::CorsMiddleware)
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: Option<i32>,
    pub name: String,
    pub email: String,
    pub created_at: DateTime<Utc>,
}

// Controller layer
pub async fn create(
    State(state): State<AppState>,
    Json(user_data): Json<CreateUserRequest>
) -> Result<impl IntoResponse, AppError> {
    let user = services::user_service::create_user(user_data, &state.db_pool).await?;
    Ok((StatusCode::CREATED, Json(user)))
}

#[derive(Debug, thiserror::Error)]
enum AppError {
    #[error("Validation error: {0}")]
    Validation(String),
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    #[error("Auth error: {0}")]
    Auth(String),
    #[error("Not found: {0}")]
    NotFound(String),
    #[error("Internal server error")]
    Internal,
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, error_code, message) = match self {
            AppError::Validation(msg) => (
                StatusCode::BAD_REQUEST,
                "VALIDATION_ERROR",
                msg
            ),
            AppError::Database(e) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "DATABASE_ERROR",
                e.to_string()
            ),
            AppError::Auth(msg) => (
                StatusCode::UNAUTHORIZED,
                "AUTH_ERROR",
                msg
            ),
            AppError::NotFound(resource) => (
                StatusCode::NOT_FOUND,
                "NOT_FOUND",
                format!("Resource not found: {}", resource)
            ),
            AppError::Internal => (
                StatusCode::INTERNAL_SERVER_ERROR,
                "INTERNAL_ERROR",
                "Internal server error".to_string()
            ),
        };

        let body = serde_json::json!({
            "error": {
                "code": error_code,
                "message": message,
                "timestamp": chrono::Utc::now().to_rfc3339()
            }
        });

        Response::builder()
            .status(status)
            .header("content-type", "application/json")
            .body(Json(body).into_response())
            .unwrap()
    }
}