My Journey with the Hyperlane Framework

Introduction

As a third-year computer science student, I've been searching for a web framework that could both meet my learning needs and prove useful in practical projects. After several months of exploration and hands-on experience, I want to share my deep dive into a Rust web framework that has completely changed my perspective on modern web development.

First Encounter: From Confusion to Delight

When I first encountered this framework, I was relatively new to Rust and worried that the learning curve would be too steep. However, once I actually started using it, I discovered that the framework's design philosophy was incredibly user-friendly, allowing even students unfamiliar with Rust to get up and running quickly.

A Simple Start

use hyperlane::*;

use hyperlane_macros::*;



#[get]

async fn hello_world(ctx: Context) {

    ctx.set_response_status_code(200)

        .await

        .set_response_body("Hello, World!")

        .await;

}



#[tokio::main]

async fn main() {

    let server = Server::new();

    server.host("127.0.0.1").await;

    server.port(8080).await;

    server.route("/", hello_world).await;

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

}

That's it! Just a few lines of code to start a web server. Compared to the complex configuration and dependency management of other frameworks, the simplicity of this framework was truly impressive.

Deep Dive: Discovering More Possibilities

1. Flexible Routing System

The framework supports both static and dynamic routing, meeting various complex URL matching requirements:

// Static routing

server.route("/api/users", get_users).await;



// Dynamic routing

server.route("/api/users/{id}", get_user_by_id).await;



// Regular expression routing

server.route("/api/users/{id:\\d+}", get_user_by_id).await;

server.route("/files/{path:^.*$}", serve_file).await;

Getting parameters in dynamic routes is also very simple:

async fn get_user_by_id(ctx: Context) {

    let params = ctx.get_route_params().await;

    let user_id = ctx.get_route_param("id").await;



    // Handle business logic

    let user = find_user_by_id(user_id).await;

    ctx.set_response_body_json(&user).await;

}

2. Powerful Middleware System

Middleware is a crucial concept in web development, and this framework's middleware design gave me a deeper understanding of architecture:

async fn auth_middleware(ctx: Context) {

    let token = ctx.get_request_header("authorization").await;



    if let Some(token) = token {

        if validate_token(&token).await {

            // Authentication passed, continue processing

            return;

        }

    }



    // Authentication failed, return 401

    ctx.set_response_status_code(401)

        .await

        .set_response_body("Unauthorized")

        .await;

}



async fn logging_middleware(ctx: Context) {

    let start_time = std::time::Instant::now();

    let method = ctx.get_request_method().await;

    let path = ctx.get_request_path().await;



    // Process request

    // ...



    let duration = start_time.elapsed();

    println!("{} {} - {}ms", method, path, duration.as_millis());

}



// Register middleware

server.request_middleware(auth_middleware).await;

server.response_middleware(logging_middleware).await;

3. Perfect Support for Real-time Communication

WebSocket and Server-Sent Events support allowed me to build truly real-time applications:

#[ws]

#[get]

async fn websocket_handler(ctx: Context) {

    loop {

        let message = ctx.get_request_body().await;

        let response = process_message(&message).await;

        let _ = ctx.set_response_body(response).await.send_body().await;

    }

}



#[post]

async fn sse_pre_hook(ctx: Context) {

    let _ = ctx

        .set_response_header(CONTENT_TYPE, TEXT_EVENT_STREAM)

        .await

        .set_response_status_code(200)

        .await

        .send()

        .await;

}



async fn sse_post_hook(ctx: Context) {

    let _ = ctx.closed().await;

}



#[pre_hook(sse_pre_hook)]

#[post_hook(sse_post_hook)]

async fn sse_handler(ctx: Context) {

    for i in 0..100 {

        let event_data = format!("data: Event {}{}", i, HTTP_DOUBLE_BR);

        let _ = ctx.set_response_body(event_data).await.send_body().await;

        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;

    }

}

Performance Testing: Astonishing Results

During my learning process, I became very interested in the framework's performance. Through comparative testing, I discovered that this framework's performance was truly outstanding:

Stress Test Results

Using wrk for stress testing with 360 concurrent connections for 60 seconds:

• 
  Tokio: 340,130.92 QPS


• 
  This Framework: 324,323.71 QPS


• 
  Rocket: 298,945.31 QPS


• 
  Rust Standard Library: 291,218.96 QPS


• 
  Gin (Go): 242,570.16 QPS


• 
  Go Standard Library: 234,178.93 QPS


• 
  Node.js Standard Library: 139,412.13 QPS

This result was shocking! A relatively simple framework could achieve such high performance, even surpassing the Rust standard library and Go's Gin framework.

Memory Usage Optimization

The framework also excelled in memory management, significantly reducing GC pressure through reasonable memory allocation strategies and zero-copy technology:

// Efficient response building

ctx.set_response_body("Hello World").await;  // Zero-copy string

ctx.set_response_body_json(&data).await;     // Efficient JSON serialization

Real Project: Campus Second-hand Trading Platform

To verify the framework's practicality, I decided to develop a campus second-hand trading platform using it. This project allowed me to deeply experience various features of the framework:

Project Architecture

// User module

mod user {

    pub async fn register(ctx: Context) {

        let user_data: User = ctx.get_request_body_json().await;

        let result = user_service::create_user(user_data).await;

        ctx.set_response_body_json(&result).await;

    }



    pub async fn login(ctx: Context) {

        let credentials: LoginRequest = ctx.get_request_body_json().await;

        let token = auth_service::authenticate(&credentials).await;

        ctx.set_response_body_json(&LoginResponse { token }).await;

    }

}



// Product module

mod product {

    pub async fn create_product(ctx: Context) {

        let product: Product = ctx.get_request_body_json().await;

        let result = product_service::create(product).await;

        ctx.set_response_body_json(&result).await;

    }



    pub async fn get_products(ctx: Context) {

        let query = ctx.get_request_querys().await;

        let products = product_service::list(&query).await;

        ctx.set_response_body_json(&products).await;

    }

}



// Chat module

mod chat {

    #[ws]

    pub async fn websocket_handler(ctx: Context) {

        let user_id = get_user_from_context(&ctx).await;



        loop {

            let message = ctx.get_request_body().await;

            let chat_message = parse_chat_message(&message).await;



            // Broadcast message to relevant users

            broadcast_message(&chat_message).await;



            let response = format!("Message sent: {}", chat_message.content);

            let _ = ctx.set_response_body(response).await.send_body().await;

        }

    }

}

Database Integration

The framework's integration with databases was also very simple:

use sqlx::PgPool;



async fn get_user_by_id(ctx: Context) {

    let pool = ctx.get_data::<PgPool>().await;

    let user_id = ctx.get_route_param("id").await;



    let user = sqlx::query_as!(

        User,

        "SELECT * FROM users WHERE id = $1",

        user_id

    )

    .fetch_one(pool)

    .await?;



    ctx.set_response_body_json(&user).await;

}

Learning Insights: The Philosophy of Framework Design

Through several months of learning and practice, I gained a deep understanding of this framework's design philosophy:

1. Simple but Not Simplistic

The framework's API design follows the principle of "simple but not simplistic." While it's easy to use, the internal implementation is very complex and efficient. This design allows beginners to get started quickly while providing sufficient extensibility for advanced users.

2. Performance First

The framework has made many optimizations in terms of performance:

• Zero-copy technology reduces memory allocation


• Asynchronous I/O maximizes concurrent processing capabilities


• Intelligent connection pool management


• Efficient HTTP parser

3. Type Safety

Rust's type system allows the framework to detect many potential errors at compile time, greatly improving code reliability:

// Compile-time type checking

let user: User = ctx.get_request_body_json().await;  // Automatic type inference

let status: u16 = ctx.get_response_status_code().await;  // Type-safe status codes

4. Cross-platform Compatibility

The framework is implemented in pure Rust, supporting Windows, Linux, and macOS without additional platform-specific code.

Challenges Encountered and Solutions

1. Understanding Asynchronous Programming

When I first encountered asynchronous programming, I was quite fuzzy about the async/await concept. Through practice, I gradually understood the advantages of asynchronous programming:

// Synchronous approach (blocking)

let result = database_query().await;  // Blocks current thread



// Asynchronous approach (non-blocking)

let result = database_query().await;  // Doesn't block, can handle other requests

2. Error Handling

Rust's error handling mechanism taught me how to gracefully handle various exceptional situations:

async fn handle_request(ctx: Context) -> Result<(), Box<dyn std::error::Error>> {

    let data: UserData = ctx.get_request_body_json().await?;



    match process_data(data).await {

        Ok(result) => {

            ctx.set_response_body_json(&result).await;

            Ok(())

        }

        Err(e) => {

            ctx.set_response_status_code(500)

                .await

                .set_response_body(format!("Error: {}", e))

                .await;

            Ok(())

        }

    }

}

3. Memory Management

Rust's ownership system gave me a completely new understanding of memory management. Although the learning curve was steep, once mastered, I could write safer and more efficient code.

Comparison with Other Frameworks

During my learning process, I also tried several other web frameworks. Here's my comparative experience:

Comparison with Express.js

Express.js was the framework I was most familiar with before, but compared to this Rust framework:

• 
  Performance: The Rust framework's performance is 2-3 times that of Express.js


• 
  Type Safety: Rust's static type checking makes code more reliable


• 
  Memory Safety: No need to worry about memory leaks and null pointers


• 
  Concurrent Processing: Stronger asynchronous processing capabilities

Comparison with Spring Boot

Spring Boot is powerful but relatively complex:

• 
  Startup Speed: The Rust framework starts faster


• 
  Memory Usage: Less memory consumption


• 
  Learning Curve: Easier to get started for students


• 
  Simple Deployment: Compiles into a single executable file

Future Plans

Based on this learning experience, I have new plans for my future technical development:

1. Deep Learning of Rust

Rust's design philosophy and performance advantages have made me decide to make it one of my primary technology stacks.

2. Open Source Contributions

I hope to contribute some code to this framework, such as adding more middleware, optimizing documentation, etc.

3. Technical Sharing

I plan to share this learning experience in the school's technical community to help more students understand modern web development technologies.

Conclusion

This deep dive into this Rust web framework has given me a completely new understanding of modern web development. It not only taught me the Rust language but, more importantly, helped me understand the charm of high-performance, type-safe systems programming.

For students who are also learning web development, I strongly recommend trying this framework. Although the learning curve may be steeper than some scripting language frameworks, the time and effort invested are absolutely worth it. It not only helps you build high-performance web applications but, more importantly, cultivates your systems programming mindset.

In this rapidly evolving technological era, mastering a systems-level programming language and related frameworks will bring huge advantages to your career development. And this framework is the perfect starting point for your journey.

This article is written by a third-year computer science student who learned and used this framework through practical projects, hoping to provide some reference for students who are also looking for ideal development tools.