1. Toy模板网首页
  2. > Toy博客

rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）

7月前 作者：每天都要加油呀！ 分类：Toy博客 阅读(36) 违法举报

这篇具有很好参考价值的文章主要介绍了rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Actix-web定义中间件(middleware)记录接口耗时

actix-web的官网关于中间件的介绍如下

  • https://actix.rs/docs/middleware/

这里使用的是最新版的actix-web，旧版本的可能接口不太一样

# actix-web
actix-rt = "2.6.0"
actix-web = "4.0.0"

中间件简介

我们添加的中间件能干什么？我们用一段代码来观察一下

下面是官方提供的中间件的定义方式之一，我们可以看到闭包里面有两个参数req和srv

  • 其中req（actix_web::dev::ServiceRequest）就是请求了，你可以通过它来获取请求的各种属性，比如请求的路径 req.path()
  • srv 是一个 &mut dyn actix_web::dev::Service 类型的参数，代表服务处理程序。通过调用 srv.call(req)，我们将请求传递给实际的服务处理程序进行处理。这里其实使用的是装饰器模式，这使得我们能在具体service方法调用前后做一些操作。官网上写到可以添加这些操作
    • Pre-process the Request：在请求时做前置处理
    • Post-process a Response：在响应时进行后置处理
    • Modify application state：修改state。state是我actix-web在整个调用链路中的上下文，可以用来存储我们自己想要保存的数据
    • Access external services (redis, logging, sessions)：可以访问外部的服务，例如redis等等
use actix_web::{dev::Service as _, web, App};
use futures_util::future::FutureExt;

#[actix_web::main]
async fn main() {
    let app = App::new()
        .wrap_fn(|req, srv| {
            // Pre-process the Request
            println!("Hi from start. You requested: {}", req.path());
            srv.call(req).map(|res| {
                // Post-process a Response
                println!("Hi from response");
                res
            })
        })
        .route(
            "/index.html",
            web::get().to(|| async { "Hello, middleware!" }),
        );
}

中间件添加的两种方式（接口耗时中间件）

上述添加中间件的方式其实是通过wrap_fn来实现的，我们可以通过传入闭包的方式完成我们中间件的逻辑

但是一般我们中间件处理的逻辑可能很多，在闭包中修改会显得很冗余，我们还可以通过方法warp传入一个实现了 Service trait and Transform trait 的struct，这样就会调用我们实现好的方法

在实现前我们需要先添加一些依赖

# actix-web
actix-rt = "2.6.0"
actix-web = "4.0.0"
# 提供对异步编程的支持和工具
futures-util = "0.3"

使用wrap_fn + 闭包实现

use actix_web::{dev::Service as _, web, App};
use futures_util::future::FutureExt;
use std::time::{Duration, Instant};

#[actix_web::main]
async fn main() {
    let app = App::new()
        .wrap_fn(|req, srv| {
            let start_time = Instant::now();
            let path = req.path().to_owned();
            let fut = srv.call(req);
            async move {
                let res = fut.await;
                let elapsed_time = start_time.elapsed();
                println!(
                    "Request to {} took {:?}",
                    path,
                    elapsed_time
                );
                res
            }
        })
        .route(
            "/index.html",
            web::get().to(|| async { "Hello, middleware!" }),
        );
}

这样就能打印接口耗时的日志了

Request to /index.html took 381.325909ms

使用warp + struct实现

使用struct需要实现两个trait：Transform和Service

// 中间件 => 打印接口耗时

use std::{future::{ready, Ready}, time::Instant};

use actix_web::{
    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
    Error,
};
use futures_util::future::LocalBoxFuture;

// There are two steps in middleware processing.
// 1. Middleware initialization, middleware factory gets called with
//    next service in chain as parameter.
// 2. Middleware's call method gets called with normal request.
pub struct Timed;

// Middleware factory is `Transform` trait
// `S` - type of the next service
// `B` - type of response's body
impl<S, B> Transform<S, ServiceRequest> for Timed
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = TimedMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(TimedMiddleware { service }))
    }
}

pub struct TimedMiddleware<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for TimedMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);
  
    fn call(&self, req: ServiceRequest) -> Self::Future {
        let start_time = Instant::now();
        let path = req.path().to_owned();
        let method = req.method().to_string();
        let remote_addr = req.connection_info().peer_addr().unwrap_or("unknown").to_string();
        let version = format!("{:?}", req.version()); // 使用 format! 宏转换版本号为字符串
        let headers = req.headers().clone();
        println!("{}", "1. Pre-process the Request");
        let fut = self.service.call(req);

        Box::pin(async move {
            let res = fut.await?;
            let elapsed = start_time.elapsed();
            let status = res.status();
            let content_length = res
                .headers()
                .get(actix_web::http::header::CONTENT_LENGTH)
                .and_then(|v| v.to_str().ok())
                .unwrap_or("-");

            let user_agent = headers
                .get(actix_web::http::header::USER_AGENT)
                .and_then(|v| v.to_str().ok())
                .unwrap_or("-");
            println!("{}", "2. Post-process a Response")
            println!("{} {} {} {} {} {} {}  time took [{:.6}] ms",
                remote_addr,
                method,
                path,
                version,
                status.as_u16(),
                content_length,
                user_agent,
                elapsed.as_millis());

            Ok(res)
        })
    }
}

在主程序中添加

use actix_web::{dev::Service as _, web, App};
use futures_util::future::FutureExt;
use std::time::{Duration, Instant};

#[actix_web::main]
async fn main() {
    let app = App::new()
        .wrap_fn(|req, srv| {
          	println!("{}", "2. Pre-process the Request")
            let start_time = Instant::now();
            let path = req.path().to_owned();
            let fut = srv.call(req);
            async move {
                let res = fut.await;
                let elapsed_time = start_time.elapsed();
                println!("{}", "3. Post-process a Response")
                println!(
                    "Request to {} took {:?}",
                    path,
                    elapsed_time
                );
                res
            }
        })
  			.wrap(Timed)
        .route(
            "/index.html",
            web::get().to(|| async { "Hello, middleware!" }),
        );
}

打印情况

1. Pre-process the Request
2. Pre-process the Request
3. Post-process a Response
Request to /index.html took 70.694224ms
4. Post-process a Response
127.0.0.1 GET /index.html HTTP/1.1 200 - Apifox/1.0.0 (https://www.apifox.cn)  time took [70] ms

中间件调用顺序

如果我们有多个中间件，调用顺序可以从官方上看到这样一句话

Warning: if you use wrap() or wrap_fn() multiple times, the last occurrence will be executed first.

也就是后面添加的中间件会先执行

笔者根据上面添加的中间件，对于前置和后置处理我们可以总结出调用顺序

  • 前置比后置处理先调用
  • 前置处理是后添加的先执行
  • 后置处理按照中间件添加的属性进行执行

actix自带的接口耗时中间件

其实在actix中自带了接口耗时的记录，我们只需要指定日志，并启用就可以看到了

# 日志相关
log = "0.4.0"
env_logger = "0.10.0"

use actix_web::{dev::Service as _, web, App, middleware};
use futures_util::future::FutureExt;
use std::time::{Duration, Instant};
use log::info;

#[actix_web::main]
async fn main() {
  	// 初始化日志
    init_logger();
    let app = App::new()
  			// 日志中间件
        .wrap(middleware::Logger::default())
        .wrap_fn(|req, srv| {
          	println!("{}", "2. Pre-process the Request")
            let start_time = Instant::now();
            let path = req.path().to_owned();
            let fut = srv.call(req);
            async move {
                let res = fut.await;
                let elapsed_time = start_time.elapsed();
                println!("{}", "3. Post-process a Response")
                println!(
                    "Request to {} took {:?}",
                    path,
                    elapsed_time
                );
                res
            }
        })
  			.wrap(Timed)
        .route(
            "/index.html",
            web::get().to(|| async { "Hello, middleware!" }),
        );
}


fn init_logger() {
    use env_logger::fmt::Color;
    use env_logger::Env;
    use log::LevelFilter;

    let env = Env::default().filter_or("MY_LOG_LEVEL", "debug");
    // 设置日志打印格式
    env_logger::Builder::from_env(env)
        .format(|buf, record| {
            let level_color = match record.level() {
                log::Level::Error => Color::Red,
                log::Level::Warn => Color::Yellow,
                log::Level::Info => Color::Green,
                log::Level::Debug | log::Level::Trace => Color::Cyan,
            };

            let mut level_style = buf.style();
            level_style.set_color(level_color).set_bold(true);

            let mut style = buf.style();
            style.set_color(Color::White).set_dimmed(true);

            writeln!(
                buf,
                "{} {} [{}] {}",
                Local::now().format("%Y-%m-%d %H:%M:%S"),
                level_style.value(record.level()),
                style.value(record.module_path().unwrap_or("<unnamed>")),
                record.args()
            )
        })
        .filter(None, LevelFilter::Debug)
        .init();
    info!("env_logger initialized.");
}

日志打印

2023-08-24 16:06:14 INFO [teacher_service] env_logger initialized.
2023-08-24 16:06:14 INFO [actix_server::builder] starting 2 workers
2023-08-24 16:06:14 INFO [actix_server::server] Actix runtime found; starting in Actix runtime
1. Pre-process the Request
2. Pre-process the Request
2023-08-24 16:06:50 INFO [teacher_service::my_middleware::auth] 2. Hi from start. You requested: /teacher
2023-08-24 16:06:50 INFO [teacher_service] 1. Hi from start. You requested: /teacher
2023-08-24 16:06:50 INFO [teacher_service] 2. Hi from response
2023-08-24 16:06:50 INFO [teacher_service::my_middleware::auth] 1. Hi from response
3. Post-process a Response
Request to /teacher took 355.839222ms
4. Post-process a Response
2023-08-24 16:06:50 INFO [teacher_service::my_middleware::timedMiddleware] 127.0.0.1 GET /teacher HTTP/1.1 200 - Apifox/1.0.0 (https://www.apifox.cn)  time took [355] ms
2023-08-24 16:06:50 INFO [actix_web::middleware::logger] 127.0.0.1 "GET /teacher HTTP/1.1" 200 191 "-" "Apifox/1.0.0 (https://www.apifox.cn)" 0.355607

最后一行就是actix日志记录请求的调用情况，最后一个参数就是调用时间，单位是秒

鉴权中间件

我们用相同的思路，写一个鉴权的中间件，这里具体的校验规则读者可以实现一下

use std::future::{ready, Ready};

use actix_web::{
    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
    error,
    http::header::HeaderValue,
    middleware::ErrorHandlerResponse,
    Error, HttpResponse,
};
use futures_util::{
    future::{self, LocalBoxFuture},
    FutureExt,
};
use log::info;

// There are two steps in middleware processing.
// 1. Middleware initialization, middleware factory gets called with
//    next service in chain as parameter.
// 2. Middleware's call method gets called with normal request.
pub struct Auth;

// Middleware factory is `Transform` trait
// `S` - type of the next service
// `B` - type of response's body
impl<S, B> Transform<S, ServiceRequest> for Auth
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = AuthMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(AuthMiddleware { service }))
    }
}

pub struct AuthMiddleware<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for AuthMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        // 进行鉴权操作，判断是否有权限
        if has_permission(&req) {
            // 有权限，继续执行后续中间件
            let fut = self.service.call(req);
            Box::pin(async move {
                let res = fut.await?;
                Ok(res)
            })
        } else {
            // 没有权限，立即返回响应
            Box::pin(async move {
                // 鉴权失败，返回未授权的响应，停止后续中间件的调用
                Err(error::ErrorUnauthorized("Unauthorized"))
            })
        }
    }
}

fn has_permission(req: &ServiceRequest) -> bool {
    // 实现你的鉴权逻辑，根据需求判断是否有权限
    // 返回 true 表示有权限，返回 false 表示没有权限
    // unimplemented!()
    let value = HeaderValue::from_str("").unwrap();
    let token = req.headers().get("token").unwrap_or(&value);
    token.len() > 0 || req.path().to_string() == "/login"
}

接下来我们在启动的App上加上中间件，这里我们要注意⚠️，如果我们有很多中间件，我们肯定是想要我们的鉴权中间件先执行的，这样如果鉴权没有过，就不执行后面中间件的逻辑

根据官方的提示：后添加的中间件会先执行。我们应该把鉴权中间件放到最后面的位置

use actix_web::{dev::Service as _, web, App, middleware};
use futures_util::future::FutureExt;
use std::time::{Duration, Instant};
use log::info;

#[actix_web::main]
async fn main() {
  	// 初始化日志
    init_logger();
    let app = App::new()
  			// 日志中间件
        .wrap(middleware::Logger::default())
        .wrap_fn(|req, srv| {
          	println!("{}", "2. Pre-process the Request")
            let start_time = Instant::now();
            let path = req.path().to_owned();
            let fut = srv.call(req);
            async move {
                let res = fut.await;
                let elapsed_time = start_time.elapsed();
                println!("{}", "3. Post-process a Response")
                println!(
                    "Request to {} took {:?}",
                    path,
                    elapsed_time
                );
                res
            }
        })
  			.wrap(Timed)
  			// 添加自己中间件的路径
        .wrap(my_middleware::auth::Auth)
        .route(
            "/index.html",
            web::get().to(|| async { "Hello, middleware!" }),
        );
}


fn init_logger() {
    use env_logger::fmt::Color;
    use env_logger::Env;
    use log::LevelFilter;

    let env = Env::default().filter_or("MY_LOG_LEVEL", "debug");
    // 设置日志打印格式
    env_logger::Builder::from_env(env)
        .format(|buf, record| {
            let level_color = match record.level() {
                log::Level::Error => Color::Red,
                log::Level::Warn => Color::Yellow,
                log::Level::Info => Color::Green,
                log::Level::Debug | log::Level::Trace => Color::Cyan,
            };

            let mut level_style = buf.style();
            level_style.set_color(level_color).set_bold(true);

            let mut style = buf.style();
            style.set_color(Color::White).set_dimmed(true);

            writeln!(
                buf,
                "{} {} [{}] {}",
                Local::now().format("%Y-%m-%d %H:%M:%S"),
                level_style.value(record.level()),
                style.value(record.module_path().unwrap_or("<unnamed>")),
                record.args()
            )
        })
        .filter(None, LevelFilter::Debug)
        .init();
    info!("env_logger initialized.");
}

这样当我们鉴权失败后，后续的中间件就不会执行了（下面笔者写了一个接口）

rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）,rust,rust,前端,中间件

鉴权成功

rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）,rust,rust,前端,中间件

日志也符合预期

rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）,rust,rust,前端,中间件文章来源地址https://www.toymoban.com/news/detail-671101.html

到了这里，关于rust actix-web定义中间件(middleware)记录接口耗时（接口耗时中间件和鉴权中间件）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • [架构之路-239]：目标系统 - 纵向分层 - 中间件middleware

    [架构之路-239]：目标系统 - 纵向分层 - 中间件middleware

    目录 前言： 一、中间件概述 1.1 中间件在软件层次中的位置 1.2 什么是中间件 1.3 为什么需要中间件 1.4 中间件应用场合（应用程序不用的底层需求：计算、存储、通信） 1.5 中间件分类 - 按内容分 二、嵌入式系统的中间件 2.1 概述 2.2 案例 三、分布式系统的中间件 3.1 概述

    2024年02月07日
    浏览(52)
  • 【Python开发】FastAPI 09：middleware 中间件及跨域

    【Python开发】FastAPI 09：middleware 中间件及跨域

    FastAPI 提供了一些中间件来增强它的功能，类似于 Spring 的切面编程，中间件可以在请求处理前或处理后执行一些操作，例如记录日志、添加请求头、鉴权等，跨域也是 FastAPI 中间件的一部分。 目录 1 中间件 1.1 创建中间件 1.2 使用中间件  2 跨域 2.1 跨域详解 2.2 使用 CORSM

    2024年02月09日
    浏览(53)
  • 【从零开始的rust web开发之路 二】axum中间件和共享状态使用

    【从零开始的rust web开发之路 二】axum中间件和共享状态使用

    第一章 axum学习使用 第二章 axum中间件使用 上篇文件讲了路由和参数相应相关的。axum还有个关键的地方是中间件的使用，这篇文件就来说说。 这个概念跟gin框架的中间件概念一样，类似于springboot项目当中的请求过滤器，在请求过来的时候链式执行一些操作。例如鉴权，日志

    2024年02月11日
    浏览(39)
  • 在Node.js中，什么是中间件（middleware）？它们的作用是什么？

    在Node.js中，什么是中间件（middleware）？它们的作用是什么？

    聚沙成塔·每天进步一点点 前端入门之旅：探索Web开发的奇妙世界 欢迎来到前端入门之旅！感兴趣的可以订阅本专栏哦！这个专栏是为那些对Web开发感兴趣、刚刚踏入前端领域的朋友们量身打造的。无论你是完全的新手还是有一些基础的开发者，这里都将为你提供一个系统而

    2024年02月06日
    浏览(31)

  • Golang web 项目中实现自定义 recovery 中间件

    在 Golang 的 Web 项目中，自定义 recovery 中间件是一种常见的做法，用于捕获并处理应用程序的运行时错误，以避免整个应用程序崩溃并返回对应格式的响应数据。 很多三方 web 框架（例如 gin、echo）都提供了官方实现的 recovery 中间件，但是官方实现的中间件并不一定能满足自

    2024年02月09日
    浏览(39)
  • 探索Scrapy中间件：自定义Selenium中间件实例解析

    探索Scrapy中间件：自定义Selenium中间件实例解析

    Scrapy是一个强大的Python爬虫框架，可用于从网站上抓取数据。本教程将指导你创建自己的Scrapy爬虫。其中，中间件是其重要特性之一，允许开发者在爬取过程中拦截和处理请求与响应，实现个性化的爬虫行为。 本篇博客将深入探讨Scrapy中间件的关键作用，并以一个实例详细介

    2024年02月04日
    浏览(53)
  • GoZero微服务个人探究之路（七）添加中间件、自定义中间件

    GoZero微服务个人探究之路（七）添加中间件、自定义中间件

    官方已经自己实现了很多中间件，我们可以方便的直接使用，不用重复造轮子了 开启方式可以看官方文档 中间件 | go-zero Documentation 在业务逻辑中，我们需要实现自定义功能的中间件 ------这里我们以实现跨源访问的中间件（详情可见这篇文章flutter开发web应用网络请求后台失

    2024年01月21日
    浏览(42)

  • 【ASP.NET Core 基础知识】--中间件--创建自定义中间件

    一、为什么需要自定义中间件 自定义中间件在ASP.NET Core中的应用主要有以下几个原因： 满足特定需求： 默认情况下，ASP.NET Core提供了许多内置的中间件来处理常见的任务，如身份验证、授权、静态文件服务等。然而，某些项目可能有特定的需求，需要定制化的处理流程，这

    2024年01月17日
    浏览(52)
  • 中间件定义

    中间件定义

    中间件(middleware)是基础软件的一大类，属于可复用的软件范畴。中间件在操作系统软件，网络和数据库之上，应用软件之下，总的作用是为处于自己上层的应用软件提供运行于开发的环境，帮助用户灵活、高效的开发和集成复杂的应用软件。   IDC对中间件的定义为：中间件是

    2024年02月09日
    浏览(29)

  • Web中间件常见漏洞

    Web中间件常见漏洞 我们常见的中间件有apache,tomcat,IIS,weblogic(其实就是web容器)，这些中间件可以设置支持的HTTP方法。每一个HTTP方法都有其对应的功能，在这些方法中，PUT可以直接从客户机上传文件到服务器。如果中间件开放了HTTP中的PUT方法，那么恶意攻击者就可以直接上传

    2024年02月14日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包