一、文件上传 OOM 的痛点

上个月，我的一个电商系统客户遇到了严重的生产事故：系统在处理用户上传的商品图片时，突然出现了 OOM（内存溢出）崩溃。

"我们的系统每天都要处理大量的图片上传，"客户焦急地说，"昨天有用户上传了几个 100MB 以上的大文件，直接导致服务器内存溢出，整个服务都崩溃了。"

我查看了他们的代码，发现问题确实很严重：

• 使用了 Spring Boot 默认的文件上传配置
• 上传的文件直接存储在内存中
• 没有对文件大小进行合理限制
• 没有使用流式处理，而是一次性读取整个文件
• 系统内存只有 4GB，根本无法处理大文件

更关键的是，他们根本不知道有多少用户正在上传大文件，也无法及时发现和处理这种内存风险。

二、传统方案的局限性

1. 默认配置上传

使用 Spring Boot 默认的文件上传配置。

@PostMapping("/upload")
public String upload(@RequestParam("file") MultipartFile file) throws IOException {
    byte[] bytes = file.getBytes(); // 直接读取到内存
    // 处理文件...
    return "Uploaded successfully";
}

这种方案的问题：

• 内存溢出风险：大文件直接读取到内存，容易导致 OOM
• 性能瓶颈：一次性读取整个文件，占用大量内存
• 扩展性差：无法处理超大型文件
• 稳定性低：系统容易因内存不足而崩溃

2. 简单配置限制

通过配置文件限制文件大小。

spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB

这种方案的问题：

• 用户体验差：直接拒绝大文件，用户无法上传
• 业务限制：无法满足需要上传大文件的业务场景
• 配置僵化：硬编码的大小限制不够灵活
• 无法处理：对于合法的大文件需求无能为力

3. 临时文件存储

使用临时文件存储上传的文件。

@PostMapping("/upload")
public String upload(@RequestParam("file") MultipartFile file) throws IOException {
    File tempFile = File.createTempFile("upload", ".tmp");
    file.transferTo(tempFile); // 存储到临时文件
    // 处理文件...
    return "Uploaded successfully";
}

这种方案的问题：

• 磁盘 I/O 瓶颈：频繁的磁盘读写影响性能
• 临时文件管理：需要手动清理临时文件
• 资源泄漏：临时文件未及时清理会占用磁盘空间
• 跨系统问题：临时文件路径在不同系统下可能不同

三、终极方案：基于流式处理的文件上传 OOM 防护

今天，我要和大家分享一个在实战中验证过的解决方案：基于流式处理的文件上传 OOM 防护。

这套方案的核心思想是：

1. 流式处理：使用 InputStream 逐块读取文件，避免一次性加载到内存
2. 内存控制：严格控制内存使用，设置合理的缓冲区大小
3. 文件大小限制：根据业务需求设置合理的文件大小限制
4. 异常处理：对大文件上传进行优雅处理，避免系统崩溃
5. 监控告警：实时监控文件上传状态，及时发现异常

四、方案详解

1. 核心原理

基于流式处理的文件上传 OOM 防护工作流程如下：

用户发起文件上传请求
    ↓
Spring MVC 接收文件上传请求
    ↓
MultipartResolver 解析请求
    ↓
获取文件的 InputStream
    ↓
逐块读取文件内容（使用缓冲区）
    ↓
处理每块数据（如存储、分析等）
    ↓
关闭 InputStream，释放资源
    ↓
返回上传结果

2. SpringBoot 实现

（1）文件上传配置

spring:
  servlet:
    multipart:
      enabled: true
      max-file-size: 100MB  # 最大文件大小
      max-request-size: 100MB  # 最大请求大小
      file-size-threshold: 1MB  # 超过此大小使用临时文件
      location: /tmp/upload  # 临时文件存储位置

（2）流式文件上传控制器

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

    @Autowired
    private FileUploadService fileUploadService;

    @PostMapping("/stream")
    public ResponseEntity<UploadResponse> uploadFile(
            @RequestParam("file") MultipartFile file) {
        try {
            // 验证文件大小
            if (file.getSize() > 100 * 1024 * 1024) { // 100MB
                return ResponseEntity.badRequest()
                        .body(new UploadResponse(false, "File too large"));
            }

            // 使用流式处理
            String fileUrl = fileUploadService.uploadFile(file);
            return ResponseEntity.ok()
                    .body(new UploadResponse(true, "Upload successful", fileUrl));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new UploadResponse(false, "Upload failed: " + e.getMessage()));
        }
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class UploadResponse {
        private boolean success;
        private String message;
        private String fileUrl;

        public UploadResponse(boolean success, String message) {
            this.success = success;
            this.message = message;
        }
    }
}

（3）流式文件上传服务

@Service
public class FileUploadService {

    private static final int BUFFER_SIZE = 8192; // 8KB 缓冲区

    @Value("${file.upload.dir}")
    private String uploadDir;

    public String uploadFile(MultipartFile file) throws IOException {
        // 确保上传目录存在
        File directory = new File(uploadDir);
        if (!directory.exists()) {
            directory.mkdirs();
        }

        // 生成唯一文件名
        String fileName = generateUniqueFileName(file.getOriginalFilename());
        String filePath = uploadDir + File.separator + fileName;

        // 使用流式处理上传文件
        try (InputStream inputStream = file.getInputStream();
             OutputStream outputStream = new FileOutputStream(filePath)) {

            byte[] buffer = new byte[BUFFER_SIZE];
            int bytesRead;

            // 逐块读取文件
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
        }

        // 返回文件访问 URL
        return "/uploads/" + fileName;
    }

    private String generateUniqueFileName(String originalFilename) {
        String extension = "";
        if (originalFilename != null && originalFilename.contains(".")) {
            extension = originalFilename.substring(originalFilename.lastIndexOf("."));
        }
        return UUID.randomUUID().toString() + extension;
    }
}

（4）大文件处理服务

@Service
public class LargeFileService {

    private static final int BUFFER_SIZE = 16384; // 16KB 缓冲区
    private static final long MAX_FILE_SIZE = 500 * 1024 * 1024; // 500MB

    @Autowired
    private FileUploadService fileUploadService;

    public String processLargeFile(MultipartFile file) throws IOException {
        // 验证文件大小
        if (file.getSize() > MAX_FILE_SIZE) {
            throw new FileSizeLimitExceededException("File size exceeds the limit of 500MB");
        }

        // 检查文件类型
        String contentType = file.getContentType();
        if (!isAllowedContentType(contentType)) {
            throw new IllegalArgumentException("File type not allowed");
        }

        // 流式处理大文件
        try (InputStream inputStream = file.getInputStream()) {
            // 可以在这里添加文件处理逻辑
            // 例如：文件内容分析、格式转换等
            processFileContent(inputStream);
        }

        // 上传文件
        return fileUploadService.uploadFile(file);
    }

    private void processFileContent(InputStream inputStream) throws IOException {
        byte[] buffer = new byte[BUFFER_SIZE];
        int bytesRead;

        while ((bytesRead = inputStream.read(buffer)) != -1) {
            // 处理每块数据
            // 例如：计算文件哈希值、提取元数据等
            processBuffer(buffer, bytesRead);
        }
    }

    private void processBuffer(byte[] buffer, int length) {
        // 处理缓冲区数据
        // 这里可以添加具体的处理逻辑
    }

    private boolean isAllowedContentType(String contentType) {
        // 允许的文件类型
        Set<String> allowedTypes = new HashSet<>(Arrays.asList(
                "image/jpeg", "image/png", "image/gif",
                "application/pdf", "application/msword",
                "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
        ));
        return allowedTypes.contains(contentType);
    }
}

（5）文件上传异常处理

@RestControllerAdvice
public class FileUploadExceptionHandler {

    @ExceptionHandler(FileSizeLimitExceededException.class)
    public ResponseEntity<ErrorResponse> handleFileSizeLimitExceededException(
            FileSizeLimitExceededException e) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.PAYLOAD_TOO_LARGE.value(),
                "File Too Large",
                e.getMessage()
        );
        return ResponseEntity.status(HttpStatus.PAYLOAD_TOO_LARGE).body(error);
    }

    @ExceptionHandler(MaxUploadSizeExceededException.class)
    public ResponseEntity<ErrorResponse> handleMaxUploadSizeExceededException(
            MaxUploadSizeExceededException e) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.PAYLOAD_TOO_LARGE.value(),
                "Upload Size Exceeded",
                "File size exceeds the maximum allowed size"
        );
        return ResponseEntity.status(HttpStatus.PAYLOAD_TOO_LARGE).body(error);
    }

    @ExceptionHandler(IOException.class)
    public ResponseEntity<ErrorResponse> handleIOException(IOException e) {
        ErrorResponse error = new ErrorResponse(
                HttpStatus.INTERNAL_SERVER_ERROR.value(),
                "IO Error",
                "File upload failed: " + e.getMessage()
        );
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
    }

    @Data
    @AllArgsConstructor
    public static class ErrorResponse {
        private int status;
        private String error;
        private String message;
    }
}

（6）文件上传监控

@Service
@Slf4j
public class UploadMonitorService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String UPLOAD_COUNTER_KEY = "upload:counter";
    private static final String LARGE_FILE_KEY = "upload:large_file";

    public void recordUpload(String fileName, long fileSize, String contentType) {
        // 记录上传次数
        redisTemplate.opsForValue().increment(UPLOAD_COUNTER_KEY);

        // 记录大文件上传
        if (fileSize > 10 * 1024 * 1024) { // 10MB
            Map<String, Object> fileInfo = new HashMap<>();
            fileInfo.put("fileName", fileName);
            fileInfo.put("fileSize", fileSize);
            fileInfo.put("contentType", contentType);
            fileInfo.put("timestamp", System.currentTimeMillis());
            fileInfo.put("ip", getClientIP());

            redisTemplate.opsForList().leftPush(LARGE_FILE_KEY, fileInfo);
            // 只保留最近 100 条记录
            redisTemplate.opsForList().trim(LARGE_FILE_KEY, 0, 99);

            log.info("Large file uploaded: {} ({} bytes)", fileName, fileSize);
        }

        // 检查上传频率
        checkUploadFrequency();
    }

    private void checkUploadFrequency() {
        String ip = getClientIP();
        String key = "upload:frequency:" + ip;

        // 记录当前时间
        redisTemplate.opsForList().leftPush(key, System.currentTimeMillis());
        // 只保留最近 10 分钟的记录
        redisTemplate.expire(key, 10, TimeUnit.MINUTES);

        // 检查最近 1 分钟的上传次数
        long count = redisTemplate.opsForList().size(key);
        if (count > 10) { // 1 分钟内超过 10 次上传
            log.warn("High upload frequency detected from IP: {}", ip);
            // 可以在这里添加告警逻辑
        }
    }

    private String getClientIP() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty()) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

3. 集成示例

（1）文件上传控制器增强

@RestController
@RequestMapping("/api/upload")
public class EnhancedFileUploadController {

    @Autowired
    private FileUploadService fileUploadService;

    @Autowired
    private LargeFileService largeFileService;

    @Autowired
    private UploadMonitorService uploadMonitorService;

    @PostMapping("/single")
    public ResponseEntity<UploadResponse> uploadSingleFile(
            @RequestParam("file") MultipartFile file) {
        try {
            // 记录上传信息
            uploadMonitorService.recordUpload(
                    file.getOriginalFilename(),
                    file.getSize(),
                    file.getContentType()
            );

            // 根据文件大小选择处理方式
            String fileUrl;
            if (file.getSize() > 50 * 1024 * 1024) { // 50MB
                fileUrl = largeFileService.processLargeFile(file);
            } else {
                fileUrl = fileUploadService.uploadFile(file);
            }

            return ResponseEntity.ok()
                    .body(new UploadResponse(true, "Upload successful", fileUrl));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(new UploadResponse(false, "Upload failed: " + e.getMessage()));
        }
    }

    @PostMapping("/multiple")
    public ResponseEntity<MultiUploadResponse> uploadMultipleFiles(
            @RequestParam("files") MultipartFile[] files) {
        List<UploadResult> results = new ArrayList<>();
        int successCount = 0;

        for (MultipartFile file : files) {
            try {
                uploadMonitorService.recordUpload(
                        file.getOriginalFilename(),
                        file.getSize(),
                        file.getContentType()
                );

                String fileUrl = fileUploadService.uploadFile(file);
                results.add(new UploadResult(
                        file.getOriginalFilename(),
                        true,
                        "Upload successful",
                        fileUrl
                ));
                successCount++;
            } catch (Exception e) {
                results.add(new UploadResult(
                        file.getOriginalFilename(),
                        false,
                        "Upload failed: " + e.getMessage(),
                        null
                ));
            }
        }

        return ResponseEntity.ok()
                .body(new MultiUploadResponse(
                        successCount == files.length,
                        "Uploaded " + successCount + " of " + files.length + " files",
                        results
                ));
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class UploadResponse {
        private boolean success;
        private String message;
        private String fileUrl;

        public UploadResponse(boolean success, String message) {
            this.success = success;
            this.message = message;
        }
    }

    @Data
    @AllArgsConstructor
    public static class UploadResult {
        private String fileName;
        private boolean success;
        private String message;
        private String fileUrl;
    }

    @Data
    @AllArgsConstructor
    public static class MultiUploadResponse {
        private boolean success;
        private String message;
        private List<UploadResult> results;
    }
}

（2）配置类

@Configuration
public class FileUploadConfig {

    @Bean
    public MultipartConfigElement multipartConfigElement() {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        // 设置文件大小限制
        factory.setMaxFileSize(DataSize.ofMegabytes(100));
        factory.setMaxRequestSize(DataSize.ofMegabytes(100));
        // 设置临时文件存储位置
        factory.setLocation("/tmp/upload");
        return factory.createMultipartConfig();
    }

    @Bean
    public CommonsMultipartResolver multipartResolver() {
        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
        resolver.setDefaultEncoding("UTF-8");
        resolver.setMaxUploadSizePerFile(100 * 1024 * 1024); // 100MB
        return resolver;
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Value("${file.upload.dir}")
    private String uploadDir;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 配置静态资源访问路径
        registry.addResourceHandler("/uploads/**")
                .addResourceLocations("file:" + uploadDir + "/");
    }
}

五、性能对比

1. 测试场景

• 测试文件大小：1MB、10MB、50MB、100MB、200MB
• 并发用户数：100
• 请求速率：50次/秒
• 测试时间：10分钟
• 服务器配置：4核8GB内存

2. 测试结果

六、最佳实践

1. 配置优化

• 合理设置文件大小限制：根据业务需求设置最大文件大小
• 调整缓冲区大小：根据服务器内存情况调整缓冲区大小
• 配置临时文件路径：设置合适的临时文件存储位置
• 启用异步上传：对于大文件使用异步上传方式

2. 代码优化

• 使用 try-with-resources：确保 InputStream 和 OutputStream 正确关闭
• 设置合理的缓冲区：根据文件大小和内存情况设置缓冲区大小
• 批量处理：对于多个文件上传使用批量处理
• 异常处理：对上传过程中的异常进行合理处理

3. 安全策略

• 文件类型验证：验证文件类型，防止恶意文件上传
• 文件内容检测：对上传的文件内容进行安全检测
• 上传频率限制：限制单个 IP 的上传频率
• 文件路径安全：防止路径遍历攻击

4. 监控告警

• 实时监控：监控文件上传状态和内存使用情况
• 异常告警：对 OOM 风险和大文件上传进行告警
• 趋势分析：分析文件上传趋势，及时发现异常
• 性能监控：监控文件上传的响应时间和成功率

5. 架构优化

• 分布式存储：对于大文件使用分布式存储系统
• CDN 加速：使用 CDN 加速文件下载
• 断点续传：支持大文件断点续传
• 分片上传：对于超大文件使用分片上传

七、总结与展望

方案总结

1. 流式处理：使用 InputStream 逐块读取文件，避免一次性加载到内存
2. 内存控制：严格控制内存使用，设置合理的缓冲区大小
3. 文件大小限制：根据业务需求设置合理的文件大小限制
4. 异常处理：对大文件上传进行优雅处理，避免系统崩溃
5. 监控告警：实时监控文件上传状态，及时发现异常
6. 可扩展性：支持处理不同大小的文件，适应各种业务场景

未来优化方向

1. 分片上传：实现大文件分片上传，提高上传速度和可靠性
2. 断点续传：支持上传中断后的断点续传功能
3. 进度监控：实时监控文件上传进度
4. 分布式处理：支持分布式环境下的文件上传处理
5. 智能限流：根据系统负载智能调整上传限制

技术价值

1. 防止 OOM：有效防止大文件上传导致的内存溢出
2. 提高性能：流式处理减少内存使用，提高系统性能
3. 增强可靠性：系统更加稳定，能够处理更大的文件
4. 改善用户体验：支持上传更大的文件，提高用户满意度
5. 降低运维成本：减少因 OOM 导致的系统崩溃和运维成本

八、写在最后

文件上传 OOM 是一个常见但严重的问题，但通过基于流式处理的文件上传 OOM 防护方案，我们可以有效防止大文件上传导致的系统崩溃。

当然，这套方案也不是银弹，它有以下局限性：

• 响应时间：流式处理可能会增加文件上传的响应时间
• 复杂度：相比直接读取文件，流式处理的代码复杂度更高
• 依赖网络：大文件上传对网络稳定性要求较高
• 存储成本：存储大文件需要更多的磁盘空间

但对于需要处理大文件上传的系统，这套方案已经足够解决问题，而且稳定可靠。

希望这篇文章能给你带来一些启发，帮助你在实际项目中更好地处理文件上传 OOM 的问题。

如果你在使用这套方案的过程中有其他经验或困惑，欢迎在评论区留言交流！

服务端技术精选，专注分享后端开发实战经验，让技术落地更简单。

如果你觉得这篇文章有用，欢迎点赞、在看、分享三连！