在前端上传文件到后端后，后端需要进行处理并存储。处理方式取决于上传文件的大小、数量和需求，常见的场景包括单文件上传、多文件上传、大文件分片上传等。以下详细总结了几种文件处理方式，包括必要的参数说明、重要的 API 及其作用，并给出代码示例。

一、后端文件上传的常见处理方式

1. 单文件上传

实现原理：

单文件上传是最常见的场景，前端通过表单或异步请求上传文件，后端通过接收 MultipartFile 对象处理文件，并将其保存到指定位置。

方案1

@RestController
@RequestMapping("/api")
public class FileUploadController {

    /**
     * 单文件上传
     * @param file 必须传入的文件参数，参数名与前端保持一致
     * @return 上传结果信息
     */
    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
        // 检查文件是否为空
        if (file.isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("文件为空，请选择有效文件进行上传");
        }

        // 获取原始文件名并生成唯一标识（避免文件名冲突）
        String originalFileName = file.getOriginalFilename();
        assert originalFileName != null; // 防止文件名为空
        String uniqueFileName = UUID.randomUUID().toString() + "_" + originalFileName; // 生成唯一文件名

        // 定义文件保存路径
        String filePath = "C:/uploads/";
        File dest = new File(filePath + uniqueFileName);

        // 检查文件路径是否存在，不存在则创建
        if (!dest.getParentFile().exists()) {
            boolean created = dest.getParentFile().mkdirs(); // 创建目录
            if (!created) {
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("无法创建文件目录");
            }
        }

        try {
            // 将文件保存到指定路径
            file.transferTo(dest);
            return ResponseEntity.ok("文件上传成功，保存路径：" + filePath + uniqueFileName);
        } catch (IOException e) {
            // 处理文件保存失败的情况
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("文件上传失败，请重试");
        }
    }
}

关键点：

• @RequestParam("file") MultipartFile file：接收前端上传的文件，参数名称 file 必须与前端一致。
• file.getOriginalFilename()：获取文件的原始名称，通常用于保存时使用。
• file.transferTo(dest)：将文件保存到指定路径，使用了 MultipartFile 自带的方法。

方案2

我们还可以将文件上传到当前运行程序的同级目录下，你可以使用 System.getProperty("user.dir") 获取当前 Java 应用程序的运行目录。以下是修改后的代码，将文件上传到程序运行目录的同级目录下：

/**
 * 单文件上传
 * @param file 必须传入的文件参数，参数名与前端保持一致
 * @return 上传结果信息
 */
@PostMapping("/uploadAvatar")
public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
    // 检查文件是否为空
    if (file.isEmpty()) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("文件为空，请选择有效文件进行上传");
    }

    // 获取原始文件名并生成唯一标识（避免文件名冲突）
    String originalFileName = file.getOriginalFilename();
    assert originalFileName != null; // 防止文件名为空
    String uniqueFileName = UUID.randomUUID().toString() + "_" + originalFileName; // 生成唯一文件名

    // 获取当前程序运行目录的父级目录
    String currentDir = System.getProperty("user.dir");
    String filePath = currentDir + File.separator + "uploads" + File.separator; // 上传到同级目录下的 uploads 文件夹
    File dest = new File(filePath + uniqueFileName);

    // 检查文件路径是否存在，不存在则创建
    if (!dest.getParentFile().exists()) {
        boolean created = dest.getParentFile().mkdirs(); // 创建目录
        if (!created) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("无法创建文件目录");
        }
    }

    try {
        // 将文件保存到指定路径
        file.transferTo(dest);
        return ResponseEntity.ok("文件上传成功，保存路径：" + dest.getAbsolutePath());
    } catch (IOException e) {
        // 处理文件保存失败的情况
        e.printStackTrace();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("文件上传失败，请重试");
    }
}

1. 获取当前运行目录的同级目录： 使用 System.getProperty("user.dir") 获取当前程序的运行目录，然后拼接上 "uploads" 目录（你可以自定义这个目录名）。

   String currentDir = System.getProperty("user.dir");
   String filePath = currentDir + File.separator + "uploads" + File.separator;
   

2. 生成文件保存路径： 文件将会保存到程序运行目录的同级目录下的 uploads 文件夹中。如果文件夹不存在，代码会自动创建。

运行效果：

• 文件将被保存到类似 your-app-directory/uploads/uniqueFileName 的路径下。
• 你可以根据需要自定义上传的目录结构。

这样配置后，你的文件将被保存到程序运行目录的同级目录下，而不再是固定的 C:/uploads/ 路径。

优点：

• 实现简单，适用于大多数上传场景。
• Spring Boot 原生支持 MultipartFile，无需额外配置。

缺点：

• 只能处理单个文件，多个文件需要逐一处理。

适用场景：

• 常规的文件上传需求，如上传头像、文档等。

2. 多文件上传

实现原理：

多文件上传的处理方式与单文件类似，只是使用了 List<MultipartFile> 来接收多个文件，并在循环中逐一处理。

实现步骤：

@RestController
@RequestMapping("/api")
public class FileUploadController {

    /**
     * 多文件上传
     * @param files 必须传入的文件列表，与前端名称一致
     * @return 上传结果信息
     */
    @PostMapping("/uploadMultiple")
    public ResponseEntity<String> uploadMultipleFiles(@RequestParam("files") List<MultipartFile> files) {
        // 检查文件列表是否为空
        if (files.isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("文件列表为空，请选择有效文件进行上传");
        }

        String filePath = "C:/uploads/";
        StringBuilder resultMessage = new StringBuilder("文件上传结果：");

        for (MultipartFile file : files) {
            String originalFileName = file.getOriginalFilename();
            assert originalFileName != null;
            String uniqueFileName = UUID.randomUUID().toString() + "_" + originalFileName; // 生成唯一文件名
            File dest = new File(filePath + uniqueFileName);

            // 检查文件路径是否存在，不存在则创建
            if (!dest.getParentFile().exists()) {
                boolean created = dest.getParentFile().mkdirs();
                if (!created) {
                    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("无法创建文件目录");
                }
            }

            try {
                // 将文件保存到指定路径
                file.transferTo(dest);
                resultMessage.append("\n").append(uniqueFileName).append(" 上传成功");
            } catch (IOException e) {
                e.printStackTrace();
                resultMessage.append("\n").append(uniqueFileName).append(" 上传失败");
            }
        }

        return ResponseEntity.ok(resultMessage.toString());
    }
}

关键点：

• @RequestParam("files") List<MultipartFile> files：接收多个文件，前端需要通过 multiple 属性支持多文件上传。
• 循环处理文件：遍历 files 列表，依次处理每个文件，确保文件路径存在并生成唯一文件名。
• 批量处理结果：收集每个文件的上传结果，并将信息返回给前端。

优点：

• 支持批量上传，简化用户操作。
• 与单文件上传逻辑一致，代码复用性强。

缺点：

• 如果上传的文件数量较多，可能导致性能问题。

适用场景：

• 批量上传，如多张图片、多个文档。

3. 大文件分片上传

实现原理：

大文件上传可能会因网络问题或文件过大而导致失败。分片上传通过将大文件分成若干个小片段进行上传，并在后端对这些片段进行合并，从而提高上传的稳定性。分片上传还支持断点续传。

实现步骤：

1. 前端上传分片：

@RestController
@RequestMapping("/api")
public class FileUploadController {

    /**
     * 处理分片上传
     * @param chunk 必须传入的文件分片
     * @param chunkIndex 当前分片的索引，必须传入用于标识分片顺序
     * @param totalChunks 总分片数，必须传入以确保分片完整性
     * @param fileName 文件名，必须传入用于识别文件
     * @return 分片上传结果
     */
    @PostMapping("/uploadChunk")
    public ResponseEntity<String> uploadChunk(@RequestParam("file") MultipartFile chunk,
                                              @RequestParam("chunkIndex") int chunkIndex,
                                              @RequestParam("totalChunks") int totalChunks,
                                              @RequestParam("fileName") String fileName) {
        // 临时存储路径，用于存放分片
        String filePath = "C:/uploads/temp/";
        File dest = new File(filePath + fileName + "_" + chunkIndex); // 每个分片使用文件名+索引命名

        try {
            // 保存当前分片
            chunk.transferTo(dest);
            return ResponseEntity.ok("分片 " + chunkIndex + "/" + totalChunks + " 上传成功");
        } catch (IOException e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("分片上传失败");
        }
    }
}

2. 后端合并分片：

@RestController
@RequestMapping("/api")
public class FileUploadController {

    /**
     * 合并所有分片
     * @param fileName 文件名，必须传入用于合并分片
     * @param totalChunks 总分片数，必须传入以确保合并完整性
     * @return 文件合并结果
     */
    @PostMapping("/mergeChunks")
    public ResponseEntity<String> mergeChunks(@RequestParam("fileName") String fileName,
                                              @RequestParam("totalChunks") int totalChunks) {
        String filePath = "C:/uploads/temp/";
        File mergedFile = new File("C:/uploads/" + fileName);

        try (FileOutputStream fos = new FileOutputStream(mergedFile, true)) {
            // 循环读取所有分片并写入最终文件
            for (int i = 0; i < totalChunks; i++) {
                File chunkFile = new File(filePath + fileName + "_" + i);
                try (FileInputStream fis = new FileInputStream(chunkFile)) {
                    byte[] buffer = new byte[1024];
                    int bytesRead;
                    while ((bytesRead = fis.read(buffer)) != -1) {
                        fos.write(buffer, 0, bytesRead);
                    }
                }
                // 删除已合并的分片文件
                chunkFile.delete();
            }
            return ResponseEntity.ok("文件合并成功：" + mergedFile.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("文件合并失败");
        }
    }
}

关键点：

• chunkIndex 和 totalChunks：前端传递的片段索引和总片数，用于确保分片顺序和合并时的准确性。
• file.transferTo(dest)：每个分片保存到指定路径，后续合并时读取这些分片。
• 合并时循环读取每个分片并写入最终文件，确保分片顺序正确。

优点：

• 支持断点续传，网络不稳定时只需重新上传失败的部分。
• 提高上传大文件的稳定性，解决文件过大导致的上传失败问题。

缺点：

• 实现复杂，前后端需要紧密配合处理分片上传和合并逻辑。
• 对存储和处理资源要求较高。

适用场景：

• 超大文件上传，如视频、压缩包等。
• 对上传稳定性和容错性要求高的场景。

4. 使用第三方库（如 Apache Commons FileUpload）处理文件上传

实现原理：

Spring Boot 默认提供了 MultipartFile 来处理文件上传，但在复杂场景中，使用 Apache Commons FileUpload 等第三方库可以获得更多的配置选项和灵活性。

实现步骤：

import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.apache.commons.fileupload.FileItem;

@RestController
@RequestMapping("/api")
public class FileUploadController {

    /**
     * 使用 Apache Commons FileUpload 处理文件上传
     * @param request HTTP 请求对象，必须传入以处理 multipart 数据
     * @return 上传结果信息
     */
    @PostMapping("/uploadWithCommons")
    public ResponseEntity<String> uploadWithCommons(HttpServletRequest request) {
        // 检查请求是否为 multipart 类型
        if (!ServletFileUpload.isMultipartContent(request)) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("请求不是 multipart 类型");
        }

        // 配置工厂类，用于处理文件上传
        DiskFileItemFactory factory = new DiskFileItemFactory();
        factory.setSizeThreshold(1024 * 1024 * 10); // 设置缓存区大小，10MB
        factory.setRepository(new File("C:/temp/")); // 设置临时文件存储路径

        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setFileSizeMax(1024 * 1024 * 50); // 单个文件最大 50MB
        upload.setSizeMax(1024 * 1024 * 200); // 总文件最大 200MB

        try {
            List<FileItem> items = upload.parseRequest(request);
            for (FileItem item : items) {
                if (!item.isFormField()) { // 处理文件上传
                    String fileName = item.getName();
                    File uploadedFile = new File("C:/uploads/" + fileName);
                    item.write(uploadedFile);
                }
            }
            return ResponseEntity.ok("文件上传成功");
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("文件上传失败");
        }
    }
}

关键点：

• ServletFileUpload.isMultipartContent(request)：检查请求是否为 multipart/form-data 类型。
• DiskFileItemFactory：控制缓存区大小和临时文件路径。
• upload.setFileSizeMax 和 upload.setSizeMax：设置文件大小限制，防止超大文件上传。

优点：

• 提供更丰富的配置选项，如文件大小限制、临时文件处理等。
• 适用于需要对上传进行更精细控制的场景。

缺点：

• 实现复杂度较高，相比 Spring Boot 自带的 MultipartFile，配置繁琐。
• 适用范围有限，主要用于特殊需求场景。

适用场景：

• 需要精细控制上传流程和配置的场景，如自定义文件大小限制、临时文件处理等。

二、方式对比总结

方式	优点	缺点	适用场景
单文件上传	实现简单，适用范围广	只支持单个文件	普通文件上传，如图片、文档
多文件上传	支持批量上传	处理多个文件时可能有性能问题	图片批量上传、文档批量导入
大文件分片上传	支持断点续传，提高稳定性	实现复杂，资源占用较大	超大文件上传，如视频、压缩包
使用第三方库（如 Commons）	灵活性强，配置丰富	实现复杂，配置繁琐	特殊需求场景，如自定义限制和处理

三、重要 API 和参数详解

1. MultipartFile 对象

   • Spring Boot 提供的用于处理文件上传的核心对象，封装了文件内容和元数据，支持单文件和多文件上传。

2. file.transferTo(dest)

   • MultipartFile 提供的文件保存方法，将上传的文件保存到指定路径。

3. ServletFileUpload 和 DiskFileItemFactory（来自 Apache Commons FileUpload）

   • 用于处理复杂的文件上传需求，支持缓存区配置、文件大小限制、临时文件处理等。

4. file.slice()（前端）与分片合并（后端）

   • 大文件分片上传的核心，前端将文件按指定大小切片，后端逐个处理并最终合并。

总结

• 单文件上传 适用于绝大多数常见文件上传需求，简单直接，代码维护性强。
• 多文件上传 是单文件上传的扩展，适合批量上传场景，但需要注意性能问题。
• 大文件分片上传 适合处理大文件或不稳定网络下的上传需求，支持断点续传，用户体验更好，但实现复杂。
• 第三方库（如 Apache Commons FileUpload） 提供了更灵活的配置选项，适用于复杂的文件上传场景，但通常不作为首选。