使用Rust语言搞定图片上传功能的示例详解_rust

1、下载引入

cargo.toml安装依赖

已经有的就不需要额外添加了

这里我额外移入了uuid 生成唯一文件名

[dependencies]
actix-web = "4.0"  # 开发 restful api接口
actix-multipart = "0.4" # 处理文件上传
tokio = { version = "1", features = ["full"] } # 异步运行时，网络、文件i/o异步任务
futures = "0.3" # 异步编程 
serde = { version = "1.0", features = ["derive"] } # 序列化和反序列化
serde_json = "1.0" # 帮我们生成文件名
uuid = "1.0"   # 帮我们生成文件名
mime_guess = "2.0" # 猜测文件类型


更换为下面的 2025-08-01
uuid = { version = "1.17.0", features = ["v4"] }


// 添加文件依赖
  actix-files = "0.6.2"  # 静态文件服务

uuid最新版本地址：https://crates.io/crates/uuid

2、使用

入口申明模块

路由入口，我们新建一个upload模块

main.rs文件之中申明模块

httpserver::new(move || {
        let cors = cors::default()
            .allow_any_origin()
            .allow_any_method()
            .allow_any_header(); // 允许所有来源
        app::new()
            // 添加 cors 中间件
            .wrap(cors)
            // 2. 注入数据库连接池
            .app_data(web::data::new(pool.clone()))
            // 3. 注册模块路由加前缀
            .service(
                web::scope("/api") // 这里加上 /api 前缀
                    .configure(modules::user::routes::config),
                    .configure(modules::upload::routes::config),
            )
            // 3. 注册路由
            .route("/", web::get().to(welcome))
    })

申明模块入口

这里需要申明外层模块和子模块两个部分

src\modules\mod.rs

pub mod upload;
pub mod user;


src\modules\upload\mod.rs
pub mod handlers;
pub mod routes; // 必须有这一行，否则无法使用路由

routes.rs模块之中添加接口

routes.rs模块添加接口

use actix_web::web;
pub fn config(cfg: &mut web::serviceconfig) {
  cfg.route("/upload/image", web::post().to(crate::modules::upload::handlers::uploadimg));
}

测试接口逻辑

handlers.rs之中处理方法逻辑，编写我们的上传，这里我们先测试一下

handlers.rs

// # 处理函数（可选）
use actix_web::{web, httprequest, httpresponse, responder};
use sqlx::{mysqlpool,mysql, pool};
use crate::common::response::apiresponse;// 导入 apiresponse 模型

// 上传图片接口
pub async fn uploadimg() -> httpresponse {
    httpresponse::ok().json(apiresponse {
        code: 200,
        msg: "接口信息",
        data:  none::<()>,
    })
}

测试我们的接口，返回如下

{
    "code": 200,
    "msg": "接口信息"
}

3、功能实现

上传文件逻辑

接下来我们参考我们之前的接口部分，返回上传图片成功以后的数据，这里我们先以实现功能为主

// // # 处理函数（可选）
// use actix_web::{web, httprequest, httpresponse, responder};
// use sqlx::{mysqlpool,mysql, pool};

// // 上传图片接口
// pub async fn uploadimg() -> httpresponse {
//     httpresponse::ok().json(apiresponse {
//         code: 200,
//         msg: "接口信息",
//         data:  none::<()>,
//     })
// }


use actix_web::{web, httpresponse, responder};
use actix_multipart::multipart;
use futures::streamext;
use std::fs::{create_dir_all, file};
use std::io::write;
use uuid::uuid;
use crate::common::response::apiresponse;
use std::env;
use std::path::path;

// 定义响应数据结构
#[derive(serde::serialize)]
struct uploadresponse {
    fullpath: string,
    relativepath: string,
    size: u64,
    filename: string,
    filetype: string,
    fileuid: string,
}

const upload_dir: &str = "./uploads";
const allowed_mime_types: [&str; 3] = ["image/jpeg", "image/png", "image/gif"];

pub async fn upload_img(mut payload: multipart) -> impl responder {
    // 创建上传目录（如果不存在）
    if let err(e) = create_dir_all(upload_dir) {
        return internal_server_error(&format!("创建目录失败: {}", e));
    }

    // 获取基础url（从环境变量或使用默认值）
    let base_url = env::var("base_url")
        .unwrap_or_else(|_| "http://localhost:8080".to_string());

    // 遍历多部分表单字段
    while let some(field_result) = payload.next().await {
        let mut field = match field_result {
            ok(f) => f,
            err(e) => return bad_request(&format!("字段解析失败: {}", e)),
        };

        // 获取内容处置头部
        let content_disposition = field.content_disposition();
        
        // 获取文件名
        let original_file_name = match content_disposition.get_filename() {
            some(name) => name.to_string(),
            none => continue,  // 跳过非文件字段
        };

        // 验证文件类型
        let mime_type = field.content_type().to_string();
        if !allowed_mime_types.contains(&mime_type.as_str()) {
            return bad_request("只允许 jpeg、png 或 gif 图片");
        }

        // 生成唯一文件名和路径
        let extension = get_extension(&mime_type);
        let file_id = uuid::new_v4().to_string();
        let unique_name = format!("{}.{}", file_id, extension);
        let file_path = format!("{}/{}", upload_dir, unique_name);
        let relative_path = format!("/uploads/{}", unique_name);
        let absolute_path = format!("{}{}", base_url, relative_path);

        // 保存文件内容并获取文件大小
        let file_size = match save_file(&mut field, &file_path).await {
            ok(size) => size,
            err(e) => {
                return internal_server_error(&format!("文件保存失败: {}", e));
            }
        };

        // 创建响应数据
        let response_data = uploadresponse {
            fullpath: absolute_path,
            relativepath: relative_path,
            size: file_size,
            filename: format!("图片-{}", original_file_name),
            filetype: mime_type,
            fileuid: file_id,
        };

        // 返回成功响应
        return httpresponse::ok().json(apiresponse {
            code: 200,
            msg: "图片上传成功",
            data: some(response_data),
        });
    }

    // 没有找到有效的文件字段
    bad_request("未检测到上传的文件")
}

/// 根据 mime 类型获取文件扩展名
fn get_extension(mime_type: &str) -> &str {
    match mime_type {
        "image/jpeg" => "jpg",
        "image/png" => "png",
        "image/gif" => "gif",
        _ => "bin", // 不会发生（前面已验证）
    }
}

/// 保存上传的文件并返回文件大小
async fn save_file(field: &mut actix_multipart::field, path: &str) -> std::io::result<u64> {
    let mut file = file::create(path)?;
    let mut total_size = 0;
    
    // 处理每个数据块
    while let some(chunk_result) = field.next().await {
        // 处理可能的 multiparterror
        let chunk = chunk_result.map_err(|e| {
            std::io::error::new(
                std::io::errorkind::other, 
                format!("读取数据块失败: {}", e)
            )
        })?;
        
        // 写入文件并更新大小
        file.write_all(&chunk)?;
        total_size += chunk.len() as u64;
    }
    
    file.flush()?;
    ok(total_size)
}

/// 400 错误响应
fn bad_request(msg: &str) -> httpresponse {
    httpresponse::badrequest().json(apiresponse::<()> {
        code: 400,
        msg:"错误",
        data: none,
    })
}

/// 500 错误响应
fn internal_server_error(msg: &str) -> httpresponse {
    httpresponse::internalservererror().json(apiresponse::<()> {
        code: 500,
        msg:"错误",
        data: none,
    })
}

测试上传图片接口

测试接口这个时候给我们返回的数据如下

{
    "code": 200,
    "msg": "图片上传成功",
    "data": {
        "fullpath": "http://localhost:8888/uploads/68007a03-497e-4982-8316-10881289cb1e.png",
        "relativepath": "/uploads/68007a03-497e-4982-8316-10881289cb1e.png",
        "size": 10739,
        "filename": "图片-imgjiance2.png",
        "filetype": "image/png",
        "fileuid": "68007a03-497e-4982-8316-10881289cb1e"
    }
}

文件归位

现在可以看到我们传入的文件都在upload下，我们分配一下，图片和视频区别后面

pub async fn upload_img(mut payload: multipart) -> impl responder {
    // 创建图片存储目录（如果不存在）
    let image_dir = format!("{}/{}", base_upload_dir, image_subdir);
    if let err(e) = create_dir_all(&image_dir) {
        return internal_server_error(&format!("创建目录失败: {}", e));
    }

    // 获取基础url（从环境变量或使用默认值）
    let base_url = env::var("base_url")
        .unwrap_or_else(|_| "http://localhost:3000".to_string());

    // 遍历多部分表单字段
    while let some(field_result) = payload.next().await {
        let mut field = match field_result {
            ok(f) => f,
            err(e) => return bad_request(&format!("字段解析失败: {}", e)),
        };

        // 获取内容处置头部
        let content_disposition = field.content_disposition();
        
        // 获取文件名
        let original_file_name = match content_disposition.get_filename() {
            some(name) => name.to_string(),
            none => continue,  // 跳过非文件字段
        };

        // 验证文件类型
        let mime_type = field.content_type().to_string();
        if !allowed_mime_types.contains(&mime_type.as_str()) {
            return bad_request("只允许 jpeg、png 或 gif 图片");
        }

        // 生成唯一文件名和路径
        let extension = get_extension(&mime_type);
        let file_id = uuid::new_v4().to_string();
        let unique_name = format!("{}.{}", file_id, extension);
        
        // 文件存储路径（包含子目录）
        let file_path = format!("{}/{}", image_dir, unique_name);
        
        // url 路径（包含子目录）
        let relative_path = format!("/uploads/{}/{}", image_subdir, unique_name);
        let absolute_path = format!("{}{}", base_url, relative_path);

        // 保存文件内容并获取文件大小
        let file_size = match save_file(&mut field, &file_path).await {
            ok(size) => size,
            err(e) => {
               return internal_server_error(&format!("文件保存失败: {}", e));
            }
        };

        // 创建响应数据
        let response_data = uploadresponse {
            fullpath: absolute_path,
            relativepath: relative_path,
            size: file_size,
            filename: format!("图片-{}", original_file_name),
            filetype: mime_type,
            fileuid: file_id,
        };

        // 返回成功响应
        return httpresponse::ok().json(apiresponse {
            code: 200,
            msg: "图片上传成功".to_string(),
            data: some(response_data),
        });
    }

    // 没有找到有效的文件字段
    bad_request("未检测到上传的文件")
}

这个时候返回的接口地址,已经成为我们想要的路径了

{
    "code": 200,
    "msg": "图片上传成功",
    "data": {
        "fullpath": "http://localhost:8888/uploads/images/a8d23e18-7155-429e-aea2-5c0f70a545e5.png",
        "relativepath": "/uploads/images/a8d23e18-7155-429e-aea2-5c0f70a545e5.png",
        "size": 10739,
        "filename": "图片-imgjiance2.png",
        "filetype": "image/png",
        "fileuid": "a8d23e18-7155-429e-aea2-5c0f70a545e5"
    }
}

文件静态路径

但是访问我们的图片地址，却无法访问，这是为什么呢？

这是因为我们服务器上还没有装静态文件服务,在我们跟入口文件之中配置

依赖前提必须安装这个依赖

// 依赖前提
actix-files = "0.6.2"  # 静态文件服务

在主文件之中引入

// 文件服务
use actix_files as fs;
use std::fs::create_dir_all; // 创建目录

入口文件之中添加我们的静态文件地址

async fn main() -> std::io::result<()> {
    dotenv().ok(); // 一定要在读取环境变量之前调用

    // 显式设置日志级别和输出格式
    builder::new()
        .parse_filters("info") // 设置日志级别为 info
        .init(); // 初始化日志记录器

    
    info!("日志系统已初始化！！！");
    
    // 确保上传目录存在
    let upload_dirs = [
        "./uploads",
        "./uploads/images",
        "./uploads/documents",
        "./uploads/videos",
        "./uploads/others"
    ];
    for dir in &upload_dirs {
        if let err(e) = create_dir_all(dir) {
            eprintln!("创建目录 {} 失败: {}", dir, e);
            // 生产环境中可能需要更严格的处理
        }
    }
    info!("图片服务器已准备！");


    // 1. 初始化数据库连接池
    // let database_url = env::var("database_url").expect("database_url not set");
    // 创建 mysql 异步连接池
    // let pool = mysqlpool::connect(&database_url).await.expect("连接数据库失败");

    let database_url = env::var("database_url").unwrap(); // 获取数据库连接字符串
    let pool = mysqlpool::connect(&database_url).await.unwrap();
    
    httpserver::new(move || {
        let cors = cors::default()
            .allow_any_origin()
            .allow_any_method()
            .allow_any_header(); // 允许所有来源
        app::new()
            // 添加 cors 中间件
            .wrap(cors)
            // 2. 注入数据库连接池
            .app_data(web::data::new(pool.clone()))
            // 3. 注册模块路由加前缀
            .service(
                fs::files::new("/uploads/images", "./uploads/images")
                    .prefer_utf8(true)
                    .show_files_listing() // 开发环境使用，生产环境应移除
            )
            // 可以添加其他静态文件目录
            .service(
                fs::files::new("/uploads/documents", "./uploads/documents")
            )
            .service(
                web::scope("/api") // 这里加上 /api 前缀
                    .configure(modules::user::routes::config)
                    .configure(modules::upload::routes::config)
            )
            // 3. 注册路由
            .route("/", web::get().to(welcome))
    })
    .bind("0.0.0.0:8888")?
    .run()
    .await
}

静态资源目录搭建好了以后，再次访问，我们的图片可以完美展示啦

快来跟我一起体验rust之美吧，最近几天都写的很难，所幸都攻克了简单但是可能我是小白很多问题总算踩过去了

到此这篇关于使用rust语言搞定图片上传功能的示例详解的文章就介绍到这了,更多相关rust图片上传内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！