如何在Actix-Web中间件中获取并修改响应体文本？

I totally get your frustration—working with Actix Web's middleware body handling can feel tricky at first. The core issue here is that the response body is wrapped in an abstract Body type, so we need to extract its content, modify it, then package it back into a valid response.

Let's adjust your SayHiMiddleware to achieve what you want. Here's the step-by-step implementation:

Updated sample.rs Code #

use actix_service::{Service, Transform};
use actix_web::{
    dev::{ServiceRequest, ServiceResponse},
    body::{Body, BytesBody},
    Error, HttpResponse,
};
use futures::{future::{ok, FutureResult}, Future, Poll};

pub struct SayHi;

impl<S, B> Transform<S> for SayHi
where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: Body + 'static, // Add Body trait constraint to enable body conversion
{
    type Request = ServiceRequest;
    type Response = ServiceResponse<BytesBody>; // Use concrete BytesBody for modified response
    type Error = Error;
    type InitError = ();
    type Transform = SayHiMiddleware<S>;
    type Future = FutureResult<Self::Transform, Self::InitError>;

    fn new_transform(&self, service: S) -> Self::Future {
        ok(SayHiMiddleware { service })
    }
}

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

impl<S, B> Service for SayHiMiddleware<S>
where
    S: Service<Request = ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: Body + 'static, // Ensure body can be converted to bytes
{
    type Request = ServiceRequest;
    type Response = ServiceResponse<BytesBody>;
    type Error = Error;
    type Future = Box<dyn Future<Item = Self::Response, Error = Self::Error>>;

    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        self.service.poll_ready()
    }

    fn call(&mut self, req: ServiceRequest) -> Self::Future {
        println!("Hi from start. You requested: {}", req.path());

        let fut = self.service.call(req);

        Box::new(fut.and_then(|res| {
            // Split the response into request context and HTTP response parts
            let (req_ctx, http_resp) = res.into_parts();
            let body = http_resp.body();

            // Convert abstract body to Bytes (handles streaming/non-streaming bodies)
            body.into_bytes().map_err(Error::from).and_then(|bytes| {
                // Convert bytes to string (add proper UTF-8 error handling for production)
                let mut body_text = String::from_utf8(bytes.to_vec())
                    .unwrap_or_else(|_| "Failed to parse body as UTF-8".to_string());
                
                // Modify the body text as needed
                body_text += " [Appended by SayHiMiddleware]";
                
                // Wrap modified text back into a BytesBody
                let new_body = BytesBody::from(body_text);
                
                // Reconstruct the HTTP response, preserving original headers and status
                let new_http_resp = HttpResponse::build(http_resp.status())
                    .headers(http_resp.headers().clone())
                    .body(new_body);
                
                // Package back into ServiceResponse and return
                Ok(ServiceResponse::new(req_ctx, new_http_resp))
            })
        }))
    }
}

Key Changes Explained: #

• Trait Constraints: Added B: Body + 'static to ensure the response body supports conversion to raw bytes.
• Concrete Body Type: Switched the middleware's response body to BytesBody—this is a straightforward type to work with after modifying content.
• Body Extraction: Used body.into_bytes() to convert the abstract body into a future that resolves to raw bytes, handling both streaming and static responses.
• Content Modification: Converted bytes to a string, appended custom text, then converted back to BytesBody. For binary content, skip the string step and modify bytes directly.
• Response Reconstruction: Built a new HTTP response with the modified body, keeping the original status code and headers intact, then wrapped it back into a ServiceResponse.

Notes for Production: #

• Replace the unwrap_or_else with proper error handling (e.g., return a 500 error) if UTF-8 parsing fails.
• If you're using Actix Web 4.x+, the API uses async/await instead of futures 0.1, but the core logic of extracting, modifying, and reconstructing the response remains identical.

内容的提问来源于stack exchange，提问作者user1848258