如何在actix-web服务器上动态流式生成tar/7z/zip归档文件？

核心思路是利用Actix-Web的流式响应能力，将归档文件的生成过程直接与响应流绑定，边生成边输出数据，完全避免内存积压或临时文件的使用。以下是针对不同归档格式的具体实现方案：

依赖准备 #

在Cargo.toml中添加所需依赖：

[dependencies]
actix-web = "4"
tokio = { version = "1", features = ["full"] }
tar = "0.4"
zip = "0.6"
async-compression = { version = "0.4", features = ["tokio", "gzip", "deflate"] }
sevenz-rust = "0.2" # 用于纯Rust实现7z归档

1. Tar归档（含Gzip压缩） #

基础Tar流式输出 #

use actix_web::{get, HttpResponse};
use tar::Builder;
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;
use std::io::Cursor;

#[get("/download/tar")]
async fn download_tar() -> HttpResponse {
    // 创建MPSC通道，用于在生成线程和响应线程间传递数据
    let (sender, receiver) = mpsc::channel(1024);

    tokio::spawn(async move {
        let mut cursor = Cursor::new(Vec::new());
        let mut tar_builder = Builder::new(&mut cursor);

        // 模拟动态生成文件，替换为你的业务逻辑
        for i in 0..5 {
            let file_name = format!("file_{}.txt", i);
            let file_content = format!("This is content of {}", file_name).as_bytes();

            // 添加文件到Tar包
            tar_builder.append_file(file_name, Cursor::new(file_content)).unwrap();

            // 发送当前生成的Tar数据块
            let data = cursor.get_ref().clone();
            sender.send(Ok(data)).await.unwrap();
            // 重置cursor以复用内存
            cursor.set_position(0);
            cursor.get_mut().clear();
        }

        // 完成Tar构建，发送剩余数据
        tar_builder.finish().unwrap();
        let data = cursor.get_ref().clone();
        sender.send(Ok(data)).await.unwrap();
    });

    // 将MPSC接收器转换为Actix可识别的流
    let stream = ReceiverStream::new(receiver);

    HttpResponse::Ok()
        .append_header(("Content-Disposition", "attachment; filename=\"archive.tar\""))
        .append_header(("Content-Type", "application/x-tar"))
        .streaming(stream)
}

Gzip压缩版Tar #

结合async-compression实现流式压缩：

use actix_web::{get, HttpResponse};
use tar::Builder;
use async_compression::tokio::write::GzipEncoder;
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;
use std::io::Cursor;

#[get("/download/tar.gz")]
async fn download_tar_gz() -> HttpResponse {
    let (sender, receiver) = mpsc::channel(1024);

    tokio::spawn(async move {
        let mut cursor = Cursor::new(Vec::new());
        let mut gzip_encoder = GzipEncoder::new(&mut cursor);
        let mut tar_builder = Builder::new(&mut gzip_encoder);

        for i in 0..5 {
            let file_name = format!("file_{}.txt", i);
            let file_content = format!("This is content of {}", file_name).as_bytes();

            tar_builder.append_file(file_name, Cursor::new(file_content)).unwrap();
            // 刷新压缩器，确保数据写入cursor
            gzip_encoder.flush().await.unwrap();

            let data = cursor.get_ref().clone();
            sender.send(Ok(data)).await.unwrap();
            cursor.set_position(0);
            cursor.get_mut().clear();
        }

        // 完成Tar构建和压缩
        tar_builder.finish().unwrap();
        gzip_encoder.finish().await.unwrap();

        let data = cursor.get_ref().clone();
        sender.send(Ok(data)).await.unwrap();
    });

    let stream = ReceiverStream::new(receiver);

    HttpResponse::Ok()
        .append_header(("Content-Disposition", "attachment; filename=\"archive.tar.gz\""))
        .append_header(("Content-Type", "application/gzip"))
        .streaming(stream)
}

2. Zip归档 #

利用zip库实现流式输出，注意同步操作需结合Tokio任务处理：

use actix_web::{get, HttpResponse};
use zip::{ZipWriter, write::FileOptions};
use tokio::sync::mpsc;
use tokio_stream::wrappers::ReceiverStream;
use std::io::Cursor;

#[get("/download/zip")]
async fn download_zip() -> HttpResponse {
    let (sender, receiver) = mpsc::channel(1024);

    tokio::spawn(async move {
        let mut cursor = Cursor::new(Vec::new());
        let mut zip_writer = ZipWriter::new(&mut cursor);

        // 配置压缩选项
        let zip_options = FileOptions::default()
            .compression_method(zip::CompressionMethod::Deflated)
            .unix_permissions(0o644);

        for i in 0..5 {
            let file_name = format!("file_{}.txt", i);
            let file_content = format!("This is content of {}", file_name).as_bytes();

            // 启动文件写入
            zip_writer.start_file(file_name, zip_options).unwrap();
            zip_writer.write_all(file_content).unwrap();

            // 发送当前Zip数据块
            let data = cursor.get_ref().clone();
            sender.send(Ok(data)).await.unwrap();
            cursor.set_position(0);
            cursor.get_mut().clear();
        }

        // 完成Zip构建
        zip_writer.finish().unwrap();
        let data = cursor.get_ref().clone();
        sender.send(Ok(data)).await.unwrap();
    });

    let stream = ReceiverStream::new(receiver);

    HttpResponse::Ok()
        .append_header(("Content-Disposition", "attachment; filename=\"archive.zip\""))
        .append_header(("Content-Type", "application/zip"))
        .streaming(stream)
}

3. 7z归档 #

方案一：纯Rust实现（基于sevenz-rust） #

由于sevenz-rust是同步库，需用block_in_place包装同步操作：

use actix_web::{get, HttpResponse};
use sevenz_rust::SevenZWriter;
use tokio::{sync::mpsc, task};
use tokio_stream::wrappers::ReceiverStream;
use std::io::Cursor;

#[get("/download/7z")]
async fn download_7z() -> HttpResponse {
    let (sender, receiver) = mpsc::channel(1024);

    tokio::spawn(async move {
        let mut cursor = Cursor::new(Vec::new());
        let mut sz_writer = SevenZWriter::new(&mut cursor).unwrap();

        // 在阻塞线程中执行同步的7z写入操作
        task::block_in_place(|| {
            for i in 0..5 {
                let file_name = format!("file_{}.txt", i);
                let file_content = format!("This is content of {}", file_name).as_bytes();

                sz_writer.push_data(file_name.as_str(), file_content).unwrap();

                // 发送数据块
                let data = cursor.get_ref().clone();
                sender.blocking_send(Ok(data)).unwrap();
                cursor.set_position(0);
                cursor.get_mut().clear();
            }

            // 完成7z构建
            sz_writer.finish().unwrap();
            let data = cursor.get_ref().clone();
            sender.blocking_send(Ok(data)).unwrap();
        });
    });

    let stream = ReceiverStream::new(receiver);

    HttpResponse::Ok()
        .append_header(("Content-Disposition", "attachment; filename=\"archive.7z\""))
        .append_header(("Content-Type", "application/x-7z-compressed"))
        .streaming(stream)
}

方案二：调用系统7z命令（适合复杂场景） #

通过管道获取7z命令的输出流，适合需要高压缩率或高级功能的场景：

use actix_web::{get, HttpResponse};
use tokio::process::Command;
use tokio_stream::{wrappers::ReadStream, StreamExt};

#[get("/download/7z/cmd")]
async fn download_7z_cmd() -> HttpResponse {
    // 模拟动态文件列表，替换为你的业务数据
    let files = vec![
        ("file_0.txt", "Content for file 0"),
        ("file_1.txt", "Content for file 1"),
        ("file_2.txt", "Content for file 2"),
    ];

    // 启动7z命令，从标准输入读取文件，输出到标准输出
    let mut child = Command::new("7z")
        .arg("a")
        .arg("-si") // 从标准输入读取文件数据
        .arg("-so") // 将归档输出到标准输出
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .unwrap();

    let mut stdin = child.stdin.take().unwrap();
    let stdout = child.stdout.take().unwrap();

    // 异步向7z标准输入写入文件数据
    tokio::spawn(async move {
        for (name, content) in files {
            // 7z -si格式：文件名\n内容\n
            stdin.write_all(name.as_bytes()).await.unwrap();
            stdin.write_all(b"\n").await.unwrap();
            stdin.write_all(content.as_bytes()).await.unwrap();
            stdin.write_all(b"\n").await.unwrap();
        }
        stdin.flush().await.unwrap();
        drop(stdin); // 关闭输入，通知7z处理完成
    });

    // 将命令输出转换为Actix流
    let stream = ReadStream::new(stdout);

    HttpResponse::Ok()
        .append_header(("Content-Disposition", "attachment; filename=\"archive_cmd.7z\""))
        .append_header(("Content-Type", "application/x-7z-compressed"))
        .streaming(stream)
}

注意事项 #

• 错误处理：示例中使用unwrap简化代码，实际项目需替换为严谨的错误处理（如返回actix_web::Error）。
• 通道缓冲：MPSC通道的大小可根据单文件数据量调整，避免内存过度占用。
• 性能优化：对于大文件，建议分块读取/生成，避免一次性加载全部内容到内存。

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