文件上传下载功能是Web应用中的常见需求，从简单的用户头像上传到大型文件的传输与共享，都需要可靠的文件处理机制。

SpringBoot作为流行的Java应用开发框架，提供了多种实现文件上传下载的工具和方案。本文将介绍七种在SpringBoot中处理文件上传下载的工具。

1. MultipartFile接口 - 基础文件上传处理

SpringBoot内置的MultipartFile接口是处理文件上传的基础工具，简单易用且功能完善。

配置方式

在application.properties或application.yml中配置上传参数：

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

使用示例

@RestController
@RequestMapping("/api/files")
public class FileUploadController {
    
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return "请选择要上传的文件";
        }
        
        try {
            // 获取文件名
            String fileName = file.getOriginalFilename();
            // 获取文件类型
            String contentType = file.getContentType();
            // 获取文件内容
            byte[] bytes = file.getBytes();
            
            // 创建存储路径
            Path path = Paths.get("uploads/" + fileName);
            Files.createDirectories(path.getParent());
            
            // 保存文件
            Files.write(path, bytes);
            
            return "文件上传成功: " + fileName;
        } catch (IOException e) {
            e.printStackTrace();
            return "文件上传失败: " + e.getMessage();
        }
    }
}

优势与适用场景

优势

• SpringBoot原生支持，无需额外依赖
• 配置简单，API友好
• 支持多种文件操作方法

适用场景

• 小到中型文件的上传
• 基础的文件处理需求
• 快速开发原型

2.Apache Commons FileUpload - 灵活的文件上传库

虽然SpringBoot内部已集成文件上传功能，但在某些场景下，可能需要Apache Commons FileUpload提供的更多高级特性。

配置方式

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.5</version>
</dependency>

配置bean

@Bean
public CommonsMultipartResolver multipartResolver() {
    CommonsMultipartResolver resolver = new CommonsMultipartResolver();
    resolver.setDefaultEncoding("UTF-8");
    resolver.setMaxUploadSize(10485760); // 10MB
    resolver.setMaxUploadSizePerFile(2097152); // 2MB
    return resolver;
}

@RestController
@RequestMapping("/api/commons")
public class CommonsFileUploadController {
    
    @PostMapping("/upload")
    public String handleFileUpload(HttpServletRequest request) throws Exception {
        // 判断是否包含文件上传
        boolean isMultipart = ServletFileUpload.isMultipartContent(request);
        if (!isMultipart) {
            return "不是有效的文件上传请求";
        }
        
        // 创建上传器
        DiskFileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        
        // 解析请求
        List<FileItem> items = upload.parseRequest(request);
        
        for (FileItem item : items) {
            if (!item.isFormField()) {
                // 处理文件项
                String fileName = FilenameUtils.getName(item.getName());
                File uploadedFile = new File("uploads/" + fileName);
                item.write(uploadedFile);
                return "文件上传成功: " + fileName;
            }
        }
        
        return "未找到要上传的文件";
    }
}

优势

• 提供更细粒度的控制
• 支持文件上传进度监控
• 可自定义文件存储策略

适用场景

• 需要对上传过程进行细粒度控制
• 大文件上传并监控进度
• 遗留系统集成

3.Spring Resource抽象 - 统一资源访问

Spring的Resource抽象提供了对不同来源资源的统一访问方式，非常适合文件下载场景。

@RestController
@RequestMapping("/api/resources")
public class ResourceDownloadController {
    
    @GetMapping("/download/{fileName:.}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String fileName) {
        try {
            // 创建文件资源
            Path filePath = Paths.get("uploads/" + fileName);
            Resource resource = new UrlResource(filePath.toUri());
            
            // 检查资源是否存在
            if (resource.exists()) {
                return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename="" + resource.getFilename() + """)
                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
                    .body(resource);
            } else {
                return ResponseEntity.notFound().build();
            }
        } catch (Exception e) {
            return ResponseEntity.internalServerError().build();
        }
    }
}

优势

• 提供统一的资源抽象，易于切换资源来源
• 与Spring生态系统无缝集成
• 支持多种协议和位置的资源

适用场景

• 需要从多种来源提供下载的场景
• RESTful API文件下载
• 动态生成的资源下载

4.基于ResponseEntity的下载响应

SpringBoot中，ResponseEntity类型可以精确控制HTTP响应，为文件下载提供完善的HTTP头信息。

@RestController
@RequestMapping("/api/download")
public class FileDownloadController {
    
    @GetMapping("/file/{fileName:.+}")
    public ResponseEntity<byte[]> downloadFile(@PathVariable String fileName) {
        try {
            Path filePath = Paths.get("uploads/" + fileName);
            byte[] data = Files.readAllBytes(filePath);
            
            HttpHeaders headers = new HttpHeaders();
            headers.setContentDisposition(ContentDisposition.attachment()
                    .filename(fileName, StandardCharsets.UTF_8).build());
            headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
            headers.setContentLength(data.length);
            
            return new ResponseEntity<>(data, headers, HttpStatus.OK);
        } catch (IOException e) {
            return ResponseEntity.notFound().build();
        }
    }
    
    @GetMapping("/dynamic-pdf")
    public ResponseEntity<byte[]> generatePdf() {
        // 假设这里生成了PDF文件的字节数组
        byte[] pdfContent = generatePdfService.createPdf();
        
        HttpHeaders headers = new HttpHeaders();
        headers.setContentDisposition(ContentDisposition.attachment()
                .filename("generated-report.pdf").build());
        headers.setContentType(MediaType.APPLICATION_PDF);
        
        return new ResponseEntity<>(pdfContent, headers, HttpStatus.OK);
    }
}

5.基于Apache Tika的文件类型检测与验证

在文件上传场景中，确保文件类型安全是至关重要的。Apache Tika是一个内容分析工具包，能够准确检测文件的真实MIME类型，不仅依赖于文件扩展名，从而提高应用的安全性。

配置方式

添加Apache Tika依赖：

<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-core</artifactId>
    <version>2.8.0</version>
</dependency>
<dependency>
    <groupId>org.apache.tika</groupId>
    <artifactId>tika-parsers-standard-package</artifactId>
    <version>2.8.0</version>
</dependency>

使用示例

创建文件验证服务：

@Service
public class FileValidationService {
    
    private Tika tika = new Tika();
    
    // 验证文件类型
    public boolean isValidFileType(MultipartFile file, List<String> allowedTypes) throws IOException {
        String detectedType = detectFileType(file);
        return allowedTypes.stream().anyMatch(type -> detectedType.startsWith(type));
    }
    
    // 检测文件类型
    public String detectFileType(MultipartFile file) throws IOException {
        try (InputStream is = file.getInputStream()) {
            return tika.detect(is);
        }
    }
    
    // 提取文件内容
    public String extractContent(MultipartFile file) throws IOException, TikaException, SAXException {
        try (InputStream is = file.getInputStream()) {
            return tika.parseToString(is);
        }
    }
    
    // 提取文件元数据
    public Metadata extractMetadata(MultipartFile file) throws IOException, TikaException, SAXException {
        Metadata metadata = new Metadata();
        metadata.set(Metadata.RESOURCE_NAME_KEY, file.getOriginalFilename());
        
        try (InputStream is = file.getInputStream()) {
            Parser parser = new AutoDetectParser();
            ContentHandler handler = new DefaultHandler();
            ParseContext context = new ParseContext();
            parser.parse(is, handler, metadata, context);
            return metadata;
        }
    }
}

安全文件上传控制器：

@RestController
@RequestMapping("/api/secure-upload")
public class SecureFileUploadController {
    
    @Autowired
    private FileValidationService fileValidationService;
    
    private static final List<String> ALLOWED_DOCUMENT_TYPES = Arrays.asList(
        "application/pdf", 
        "application/msword", 
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
        "application/vnd.ms-excel",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        "text/plain"
    );
    
    private static final List<String> ALLOWED_IMAGE_TYPES = Arrays.asList(
        "image/jpeg", 
        "image/png", 
        "image/gif", 
        "image/tiff"
    );
    
    @PostMapping("/document")
    public ResponseEntity<Map<String, Object>> uploadDocument(@RequestParam("file") MultipartFile file) {
        Map<String, Object> response = new HashMap<>();
        
        try {
            // 检测文件类型
            String detectedType = fileValidationService.detectFileType(file);
            response.put("detectedType", detectedType);
            
            // 验证文件类型
            if (!fileValidationService.isValidFileType(file, ALLOWED_DOCUMENT_TYPES)) {
                response.put("success", false);
                response.put("message", "文件类型不允许: " + detectedType);
                return ResponseEntity.badRequest().body(response);
            }
            
            // 提取文件内容（视文件类型）
            String content = fileValidationService.extractContent(file);
            response.put("contentPreview", content.length() > 200 ? 
                        content.substring(0, 200) + "..." : content);
            
            // 提取元数据
            Metadata metadata = fileValidationService.extractMetadata(file);
            Map<String, String> metadataMap = new HashMap<>();
            Arrays.stream(metadata.names()).forEach(name -> 
                            metadataMap.put(name, metadata.get(name)));
            response.put("metadata", metadataMap);
            
            // 保存文件
            String fileName = UUID.randomUUID().toString() + "-" + file.getOriginalFilename();
            Path path = Paths.get("secure-uploads/" + fileName);
            Files.createDirectories(path.getParent());
            Files.write(path, file.getBytes());
            
            response.put("success", true);
            response.put("message", "文件上传成功");
            response.put("filename", fileName);
            
            return ResponseEntity.ok(response);
            
        } catch (Exception e) {
            response.put("success", false);
            response.put("message", "文件处理失败: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
    
    @PostMapping("/image")
    public ResponseEntity<Map<String, Object>> uploadImage(@RequestParam("file") MultipartFile file) {
        Map<String, Object> response = new HashMap<>();
        
        try {
            // 检测文件类型
            String detectedType = fileValidationService.detectFileType(file);
            response.put("detectedType", detectedType);
            
            // 验证文件类型
            if (!fileValidationService.isValidFileType(file, ALLOWED_IMAGE_TYPES)) {
                response.put("success", false);
                response.put("message", "图片类型不允许: " + detectedType);
                return ResponseEntity.badRequest().body(response);
            }
            
            // 提取元数据（图片信息）
            Metadata metadata = fileValidationService.extractMetadata(file);
            Map<String, String> metadataMap = new HashMap<>();
            Arrays.stream(metadata.names()).forEach(name -> 
                            metadataMap.put(name, metadata.get(name)));
            response.put("metadata", metadataMap);
            
            // 获取图片尺寸
            if (metadata.get(Metadata.IMAGE_WIDTH) != null && 
                metadata.get(Metadata.IMAGE_LENGTH) != null) {
                response.put("width", metadata.get(Metadata.IMAGE_WIDTH));
                response.put("height", metadata.get(Metadata.IMAGE_LENGTH));
            }
            
            // 保存文件
            String fileName = UUID.randomUUID().toString() + "-" + file.getOriginalFilename();
            Path path = Paths.get("secure-uploads/images/" + fileName);
            Files.createDirectories(path.getParent());
            Files.write(path, file.getBytes());
            
            response.put("success", true);
            response.put("message", "图片上传成功");
            response.put("filename", fileName);
            
            return ResponseEntity.ok(response);
     
        } catch (Exception e) {
            response.put("success", false);
            response.put("message", "图片处理失败: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }
}

优势与适用场景

优势

• 提供准确的文件类型检测，不仅依赖扩展名
• 防止恶意文件上传，增强应用安全性
• 能够提取文件内容和元数据
• 支持多种文件格式的识别和内容分析

适用场景

• 需要高安全性要求的文件上传系统
• 内容管理系统和文档管理系统
• 需要防止恶意文件上传的场景
• 需要基于文件内容自动分类或处理的应用

总结

无论选择哪种方案，都应根据应用的具体需求、预期用户数量和文件大小来设计文件处理系统。

在大多数生产环境中，建议采用专门的文件存储服务作为主要存储方案，结合其他工具提供更好的用户体验。