Rust网络服务框架ntex-service的使用：高性能异步服务构建与中间件扩展

安装

在项目目录中运行以下Cargo命令：

cargo add ntex-service

或在Cargo.toml中添加以下行：

ntex-service = "3.5.0"

基本使用

以下是一个使用ntex-service构建高性能异步服务的完整示例：

use ntex_service::{Service, ServiceFactory};
use std::future::{ready, Ready};
use std::task::{Context, Poll};

// 定义简单的服务
struct EchoService;

impl Service<String> for EchoService {
    type Response = String;
    type Error = std::io::Error;
    type Future = Ready<Result<Self::Response, Self::Error>>;

    fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&self, req: String) -> Self::Future {
        ready(Ok(req))
    }
}

// 定义服务工厂
struct EchoServiceFactory;

impl ServiceFactory<String> for EchoServiceFactory {
    type Response = String;
    type Error = std::io::Error;
    type Service = EchoService;
    type InitError = ();
    type Future = Ready<Result<Self::Service, Self::InitError>>;

    fn new_service(&self, _: ()) -> Self::Future {
        ready(Ok(EchoService))
    }
}

#[ntex::main]
async fn main() -> std::io::Result<()> {
    // 使用服务工厂创建服务
    let factory = EchoServiceFactory;
    let service = factory.new_service(()).await.unwrap();
    
    // 调用服务
    let response = service.call("Hello, ntex!".to_string()).await?;
    println!("Received: {}", response);
    
    Ok(())
}

中间件扩展

ntex-service支持通过中间件扩展服务功能。以下是添加日志中间件的示例：

use ntex_service::{Middleware, Service, ServiceCall, Transform};
use std::future::{ready, Ready};
use std::task::{Context, Poll};

// 日志中间件
struct LogMiddleware;

impl<S> Transform<S> for LogMiddleware {
    type Service = LogService<S>;

    fn new_transform(&self, service: S) -> Self::Service {
        LogService { service }
    }
}

struct LogService<S> {
    service: S,
}

impl<S, Req> Service<Req> for LogService<S>
where
    S: Service<Req>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = ServiceCall<S, Req>;

    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&self, req: Req) -> Self::Future {
        println!("Request received");
        ServiceCall::new(self.service.call(req))
    }
}

// 使用中间件
#[ntex::main]
async fn main() -> std::io::Result<()> {
    let service = EchoService;
    let logged_service = LogMiddleware.new_transform(service);
    
    let response = logged_service.call("Hello with logging!".to_string()).await?;
    println!("Received: {}", response);
    
    Ok(())
}

完整示例

基于上述内容，这里提供一个结合了基本服务和中间件的完整示例：

use ntex_service::{Middleware, Service, ServiceCall, ServiceFactory, Transform};
use std::future::{ready, Ready};
use std::task::{Context, Poll};

// 1. 定义基本服务
struct GreetService;

impl Service<String> for GreetService {
    type Response = String;
    type Error = std::io::Error;
    type Future = Ready<Result<Self::Response, Self::Error>>;

    fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&self, name: String) -> Self::Future {
        ready(Ok(format!("Hello, {}!", name)))
    }
}

// 2. 定义服务工厂
struct GreetServiceFactory;

impl ServiceFactory<String> for GreetServiceFactory {
    type Response = String;
    type Error = std::io::Error;
    type Service = GreetService;
    type InitError = ();
    type Future = Ready<Result<Self::Service, Self::InitError>>;

    fn new_service(&self, _: ()) -> Self::Future {
        ready(Ok(GreetService))
    }
}

// 3. 定义计时中间件
struct TimingMiddleware;

impl<S> Transform<S> for TimingMiddleware {
    type Service = TimingService<S>;

    fn new_transform(&self, service: S) -> Self::Service {
        TimingService { service }
    }
}

struct TimingService<S> {
    service: S,
}

impl<S, Req> Service<Req> for TimingService<S>
where
    S: Service<Req>,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = ServiceCall<S, Req>;

    fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&self, req: Req) -> Self::Future {
        let start = std::time::Instant::now();
        let fut = self.service.call(req);
        println!("Request processed in {:?}", start.elapsed());
        fut
    }
}

// 4. 主程序
#[ntex::main]
async fn main() -> std::io::Result<()> {
    // 创建基础服务
    let factory = GreetServiceFactory;
    let service = factory.new_service(()).await.unwrap();
    
    // 添加中间件
    let timed_service = TimingMiddleware.new_transform(service);
    
    // 调用服务
    let response = timed_service.call("World".to_string()).await?;
    println!("{}", response);
    
    Ok(())
}

这个完整示例展示了：

1. 定义一个基本的问候服务
2. 创建服务工厂
3. 添加计时中间件来测量请求处理时间
4. 在主程序中组合这些组件并运行服务

项目信息

• 许可证: MIT OR Apache-2.0
• 版本: v1.75.0
• 分类: 异步编程, 网络编程

所有者

• ntex-rs/core团队
• Nikolay Kim (fafhrd91)