异步运行时

提示

hyperlane 框架在 v3.0.0 之前不对异步做任何处理，如果需要异步操作，可以引入第三方库 hyperlane 框架在 v3.0.0 之后内置异步机制，具体逻辑如下：

• 先处理所有的同步中间件
• 再处理所有的异步中间件，异步中间件执行能保证和代码注册顺序一致
• 再执行同步路由，如果同步路由存在则不会执行同名的异步路由
• 最后执行异步路由

框架本身异步使用

server
    .async_router("/", move |arc_lock_controller_data| async move {
        let controller_data_arc = arc_lock_controller_data.write().unwrap();
        println!("hello");
    })
    .await;

下面是使用 tokio 库的异步运行时示例代码

依赖配置

[dependencies]
tokio = { version = "1.43.0", features = ["full"] }

示例代码

use hyperlane::*;
use runtime::Runtime;
use tokio::*;

async fn some_async_task() -> i32 {
    println!("Starting the task...");
    // 模拟异步操作
    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    println!("Task completed!");
    0
}

#[tokio::main]
async fn main() {
    let mut server: Server = Server::new();
    server.host("0.0.0.0");
    server.port(60000);
    server.log_size(1_024_000);
    server.router("/", move |controller_data| {
        let rt = Runtime::new().unwrap();
        // 使用 block_on 启动异步代码
        rt.block_on(async move {
            let controller_data_arc = Arc::new(controller_data.clone());
            let async_task = async move {
                let handle: task::JoinHandle<()> = tokio::spawn(async {
                    let result: i32 = some_async_task().await;
                    println!("Result of the async task: {}", result);
                });
                // 模拟异步任务
                handle.await.unwrap();
                let stream: Arc<TcpStream> = controller_data_arc.get_stream().clone().unwrap();
                let res: ResponseResult = controller_data_arc
                    .get_response()
                    .clone()
                    .set_body("hello world".into())
                    .send(&stream);
                controller_data_arc.get_log().log_debug(
                    format!("Response => {:?}\n", String::from_utf8_lossy(&res.unwrap())),
                    |data| data.clone(),
                );
            };
            // 使用 tokio::spawn 启动一个新的异步任务
            tokio::spawn(async_task).await.unwrap();
        });
    });
    server.listen();
}

异步闭包捕获外部变量

使用 async move

let test_string: String = "test".to_owned();
server
    .async_router("/test/async", move |_| {
        let tmp_test_string = test_string.clone();
        async move {
            println!("{:?}", tmp_test_string);
        }
    })
    .await;

使用 async_func!

let test_string: String = "test".to_owned();
let func = async_func!(test_string, |data| {
    println!("async_move => {:?}", test_string);
    println!("{:?}", data);
});
server.async_router("/test/async", func).await;

赞赏

作为这个项目的唯一开发者，我一直在努力确保后端服务器的稳定运行和服务的持续提供。这个项目凝聚了我所有的心血和热情，但服务器费用和网站维护确实是一个不小的负担。

如果您觉得这个项目对您有帮助，或希望支持一个坚持不懈的个人开发者，无论金额大小，您的赞助都将是对我的莫大鼓励。每一份支持都会直接用于服务器和维护成本，让这个项目能够继续为大家提供服务。感谢您的信任和支持！