Spring MVC 文件上传与下载完整实现指南

概述

文件上传和下载是Web应用中的常见功能。Spring MVC通过MultipartResolver接口提供了完善的文件上传支持，结合ResponseEntity可以实现灵活的文件下载功能。

核心技术栈

• Spring MVC 4.3.6: 提供文件处理的核心支持
• Commons FileUpload: Apache的文件上传组件
• Commons IO: 提供文件操作的工具类
• MultipartFile: Spring的文件上传抽象接口

应用场景

• 用户头像上传
• 文档资料管理
• 图片/视频分享
• 批量数据导入导出
• 在线文件存储服务

环境准备

Maven依赖配置

在pom.xml中添加以下依赖：

<!-- Spring Web MVC -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>4.3.6.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>4.3.6.RELEASE</version>
</dependency>

<!-- 文件上传组件 -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.2</version>
</dependency>
<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.5</version>
</dependency>

<!-- Servlet API -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
</dependency>

<!-- 可选：JSON处理 -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.8</version>
</dependency>

Web配置文件

在web.xml中配置Spring MVC的DispatcherServlet：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
         
    <!-- 配置字符编码过滤器 -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <!-- 配置Spring MVC DispatcherServlet -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

Spring MVC配置

在springmvc-config.xml中配置文件上传解析器：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 开启组件扫描 -->
    <context:component-scan base-package="com.owlbay.controller" />
    
    <!-- 开启注解驱动 -->
    <mvc:annotation-driven />
    
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" 
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
    
    <!-- 配置文件上传解析器 -->
    <bean id="multipartResolver" 
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设置请求编码格式 -->
        <property name="defaultEncoding" value="UTF-8" />
        <!-- 设置允许上传的最大文件大小（10MB） -->
        <property name="maxUploadSize" value="10485760" />
        <!-- 设置允许上传的单个文件最大大小（5MB） -->
        <property name="maxUploadSizePerFile" value="5242880" />
        <!-- 设置上传文件的临时目录 -->
        <property name="uploadTempDir" value="/temp" />
        <!-- 设置内存中的最大缓存大小 -->
        <property name="maxInMemorySize" value="4096" />
    </bean>
    
    <!-- 静态资源处理 -->
    <mvc:resources mapping="/static/**" location="/static/" />
    <mvc:resources mapping="/upload/**" location="/upload/" />
</beans>

文件上传实现

基本原理

文件上传的基本原理：

1. 客户端：使用multipart/form-data编码类型提交表单
2. 服务端：通过MultipartResolver解析请求，提取文件数据
3. 存储：将文件保存到服务器指定位置
4. 响应：返回上传结果给客户端

单文件上传

创建上传页面

创建fileUpload.jsp页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8"/>
    <title>文件上传示例</title>
    <style>
        .upload-container {
            width: 600px;
            margin: 50px auto;
            padding: 20px;
            border: 1px solid #ddd;
            border-radius: 5px;
        }
        .form-group {
            margin-bottom: 15px;
        }
        label {
            display: inline-block;
            width: 100px;
            text-align: right;
            margin-right: 10px;
        }
        input[type="text"], input[type="file"] {
            width: 300px;
            padding: 5px;
        }
        .btn {
            margin-left: 110px;
            padding: 8px 20px;
            background-color: #4CAF50;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        .btn:hover {
            background-color: #45a049;
        }
        #progressBar {
            width: 100%;
            height: 20px;
            border: 1px solid #ddd;
            display: none;
            margin-top: 10px;
        }
        #progress {
            width: 0%;
            height: 100%;
            background-color: #4CAF50;
            text-align: center;
            line-height: 20px;
            color: white;
        }
    </style>
    <script>
        function validateForm() {
            var name = document.getElementById("name").value;
            var file = document.getElementById("file").value;
            
            if(name.trim() === ""){
                alert("请填写上传人姓名");
                return false;
            }
            
            if(file.length === 0 || file === ""){
                alert("请选择要上传的文件");
                return false;
            }
            
            // 获取文件扩展名
            var ext = file.substring(file.lastIndexOf('.') + 1).toLowerCase();
            var allowedExts = ['jpg', 'jpeg', 'png', 'gif', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'txt'];
            
            if(allowedExts.indexOf(ext) === -1){
                alert("不支持的文件类型！\n支持的类型：" + allowedExts.join(', '));
                return false;
            }
            
            return true;
        }
        
        // 显示文件信息
        function showFileInfo() {
            var fileInput = document.getElementById("file");
            var files = fileInput.files;
            
            if(files.length > 0) {
                var fileInfo = "选中文件：\n";
                for(var i = 0; i < files.length; i++) {
                    fileInfo += "- " + files[i].name + " (" + formatFileSize(files[i].size) + ")\n";
                }
                document.getElementById("fileInfo").innerText = fileInfo;
            }
        }
        
        // 格式化文件大小
        function formatFileSize(bytes) {
            if(bytes === 0) return '0 Bytes';
            var k = 1024;
            var sizes = ['Bytes', 'KB', 'MB', 'GB'];
            var i = Math.floor(Math.log(bytes) / Math.log(k));
            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
        }
    </script>
</head>
<body>
    <div class="upload-container">
        <h2>文件上传</h2>
        <form action="${pageContext.request.contextPath}/fileUpload" 
              method="post" 
              enctype="multipart/form-data" 
              onsubmit="return validateForm()">
            
            <div class="form-group">
                <label for="name">上传人：</label>
                <input type="text" id="name" name="name" placeholder="请输入您的姓名"/>
            </div>
            
            <div class="form-group">
                <label for="file">选择文件：</label>
                <input type="file" id="file" name="uploadfile" 
                       multiple="multiple" onchange="showFileInfo()"/>
            </div>
            
            <div class="form-group">
                <pre id="fileInfo"></pre>
            </div>
            
            <div class="form-group">
                <input type="submit" value="开始上传" class="btn"/>
            </div>
            
            <div id="progressBar">
                <div id="progress">0%</div>
            </div>
        </form>
    </div>
</body>
</html>

创建结果页面

创建上传成功页面success.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
    <title>上传成功</title>
    <style>
        .success-container {
            width: 500px;
            margin: 100px auto;
            text-align: center;
            padding: 20px;
            border: 2px solid #4CAF50;
            border-radius: 5px;
            background-color: #f0f8f0;
        }
        .success-icon {
            color: #4CAF50;
            font-size: 48px;
        }
        a {
            color: #4CAF50;
            text-decoration: none;
        }
    </style>
</head>
<body>
    <div class="success-container">
        <div class="success-icon">✓</div>
        <h2>文件上传成功！</h2>
        <p>您的文件已成功上传到服务器。</p>
        <p><a href="${pageContext.request.contextPath}/fileUpload.jsp">继续上传</a> | 
           <a href="${pageContext.request.contextPath}/download.jsp">文件下载</a></p>
    </div>
</body>
</html>

创建上传失败页面error.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
    <title>上传失败</title>
    <style>
        .error-container {
            width: 500px;
            margin: 100px auto;
            text-align: center;
            padding: 20px;
            border: 2px solid #f44336;
            border-radius: 5px;
            background-color: #fef0f0;
        }
        .error-icon {
            color: #f44336;
            font-size: 48px;
        }
        a {
            color: #f44336;
            text-decoration: none;
        }
    </style>
</head>
<body>
    <div class="error-container">
        <div class="error-icon">✗</div>
        <h2>文件上传失败！</h2>
        <p>错误信息：${errorMsg}</p>
        <p><a href="javascript:history.back()">返回重试</a></p>
    </div>
</body>
</html>

创建文件上传控制器

创建FileUploadController.java：

package com.owlbay.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.apache.commons.io.FileUtils;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 文件上传控制器
 * @author Owlbay
 * @date 2022/05/17
 */
@Controller
public class FileUploadController {
    
    // 允许上传的文件类型
    private static final List<String> ALLOWED_EXTENSIONS = Arrays.asList(
        "jpg", "jpeg", "png", "gif", "bmp", 
        "pdf", "doc", "docx", "xls", "xlsx", 
        "ppt", "pptx", "txt", "zip", "rar"
    );
    
    // 最大文件大小（5MB）
    private static final long MAX_FILE_SIZE = 5 * 1024 * 1024;
    
    /**
     * 显示文件上传页面
     */
    @RequestMapping(value = "/upload", method = RequestMethod.GET)
    public String showUploadForm() {
        return "fileUpload";
    }
    
    /**
     * 处理单文件上传
     */
    @RequestMapping(value = "/fileUpload", method = RequestMethod.POST)
    public String handleFileUpload(
            @RequestParam("name") String name,
            @RequestParam("uploadfile") MultipartFile file,
            HttpServletRequest request,
            Model model) {
        
        // 验证文件是否为空
        if (file.isEmpty()) {
            model.addAttribute("errorMsg", "请选择要上传的文件");
            return "error";
        }
        
        try {
            // 验证文件大小
            if (file.getSize() > MAX_FILE_SIZE) {
                model.addAttribute("errorMsg", "文件大小超过限制（最大5MB）");
                return "error";
            }
            
            // 获取文件扩展名
            String originalFilename = file.getOriginalFilename();
            String extension = getFileExtension(originalFilename);
            
            // 验证文件类型
            if (!isAllowedExtension(extension)) {
                model.addAttribute("errorMsg", "不支持的文件类型");
                return "error";
            }
            
            // 生成唯一文件名
            String newFilename = generateUniqueFilename(name, originalFilename);
            
            // 获取上传目录
            String uploadDir = getUploadDirectory(request);
            File uploadPath = new File(uploadDir);
            
            // 创建目录
            if (!uploadPath.exists()) {
                uploadPath.mkdirs();
            }
            
            // 保存文件
            File destFile = new File(uploadPath, newFilename);
            file.transferTo(destFile);
            
            // 记录上传信息
            logUploadInfo(name, originalFilename, newFilename, file.getSize());
            
            model.addAttribute("filename", newFilename);
            model.addAttribute("filesize", formatFileSize(file.getSize()));
            
            return "success";
            
        } catch (IOException e) {
            e.printStackTrace();
            model.addAttribute("errorMsg", "文件上传失败：" + e.getMessage());
            return "error";
        }
    }
    
    /**
     * 处理多文件上传
     */
    @RequestMapping(value = "/multiFileUpload", method = RequestMethod.POST)
    @ResponseBody
    public Map<String, Object> handleMultiFileUpload(
            @RequestParam("name") String name,
            @RequestParam("uploadfiles") List<MultipartFile> files,
            HttpServletRequest request) {
        
        Map<String, Object> result = new HashMap<>();
        List<Map<String, String>> uploadedFiles = new ArrayList<>();
        int successCount = 0;
        int failCount = 0;
        
        for (MultipartFile file : files) {
            Map<String, String> fileInfo = new HashMap<>();
            
            try {
                if (!file.isEmpty()) {
                    // 处理单个文件上传
                    String originalFilename = file.getOriginalFilename();
                    String extension = getFileExtension(originalFilename);
                    
                    // 验证文件
                    if (!isAllowedExtension(extension)) {
                        fileInfo.put("name", originalFilename);
                        fileInfo.put("status", "failed");
                        fileInfo.put("message", "不支持的文件类型");
                        failCount++;
                        continue;
                    }
                    
                    if (file.getSize() > MAX_FILE_SIZE) {
                        fileInfo.put("name", originalFilename);
                        fileInfo.put("status", "failed");
                        fileInfo.put("message", "文件大小超过限制");
                        failCount++;
                        continue;
                    }
                    
                    // 生成文件名并保存
                    String newFilename = generateUniqueFilename(name, originalFilename);
                    String uploadDir = getUploadDirectory(request);
                    File uploadPath = new File(uploadDir);
                    
                    if (!uploadPath.exists()) {
                        uploadPath.mkdirs();
                    }
                    
                    File destFile = new File(uploadPath, newFilename);
                    file.transferTo(destFile);
                    
                    fileInfo.put("name", originalFilename);
                    fileInfo.put("newName", newFilename);
                    fileInfo.put("size", formatFileSize(file.getSize()));
                    fileInfo.put("status", "success");
                    successCount++;
                }
                
            } catch (Exception e) {
                fileInfo.put("name", file.getOriginalFilename());
                fileInfo.put("status", "failed");
                fileInfo.put("message", e.getMessage());
                failCount++;
            }
            
            uploadedFiles.add(fileInfo);
        }
        
        result.put("files", uploadedFiles);
        result.put("successCount", successCount);
        result.put("failCount", failCount);
        result.put("total", files.size());
        
        return result;
    }
    
    /**
     * 获取文件扩展名
     */
    private String getFileExtension(String filename) {
        if (filename == null || filename.isEmpty()) {
            return "";
        }
        int dotIndex = filename.lastIndexOf('.');
        return (dotIndex == -1) ? "" : filename.substring(dotIndex + 1).toLowerCase();
    }
    
    /**
     * 检查文件扩展名是否允许
     */
    private boolean isAllowedExtension(String extension) {
        return ALLOWED_EXTENSIONS.contains(extension.toLowerCase());
    }
    
    /**
     * 生成唯一的文件名
     */
    private String generateUniqueFilename(String uploaderName, String originalFilename) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        String dateFolder = sdf.format(new Date());
        String uuid = UUID.randomUUID().toString().replace("-", "");
        String extension = getFileExtension(originalFilename);
        
        // 格式：日期/上传人_时间戳_UUID.扩展名
        return dateFolder + "/" + uploaderName + "_" + 
               System.currentTimeMillis() + "_" + 
               uuid + "." + extension;
    }
    
    /**
     * 获取上传目录路径
     */
    private String getUploadDirectory(HttpServletRequest request) {
        String realPath = request.getSession().getServletContext().getRealPath("/");
        return realPath + "upload" + File.separator;
    }
    
    /**
     * 格式化文件大小
     */
    private String formatFileSize(long size) {
        if (size <= 0) return "0 B";
        final String[] units = {"B", "KB", "MB", "GB", "TB"};
        int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
        return String.format("%.2f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
    }
    
    /**
     * 记录上传日志
     */
    private void logUploadInfo(String uploader, String originalName, String savedName, long size) {
        // 这里可以将上传信息保存到数据库或日志文件
        System.out.println(String.format(
            "文件上传 - 上传人: %s, 原始文件名: %s, 保存文件名: %s, 大小: %s",
            uploader, originalName, savedName, formatFileSize(size)
        ));
    }
}

多文件上传

多文件上传页面

创建multiFileUpload.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head>
    <title>多文件上传</title>
    <style>
        .file-item {
            margin: 5px 0;
            padding: 5px;
            border: 1px solid #ddd;
            border-radius: 3px;
        }
        .remove-btn {
            color: red;
            cursor: pointer;
            float: right;
        }
    </style>
    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</head>
<body>
    <div class="upload-container">
        <h2>多文件上传</h2>
        <form id="multiUploadForm" enctype="multipart/form-data">
            <div class="form-group">
                <label>上传人：</label>
                <input type="text" name="name" required/>
            </div>
            <div class="form-group">
                <label>选择文件：</label>
                <input type="file" id="fileInput" multiple/>
            </div>
            <div id="fileList"></div>
            <button type="button" onclick="uploadFiles()">开始上传</button>
        </form>
        <div id="result"></div>
    </div>
    
    <script>
        var selectedFiles = [];
        
        $('#fileInput').change(function() {
            var files = this.files;
            var fileList = $('#fileList');
            fileList.empty();
            selectedFiles = [];
            
            for(var i = 0; i < files.length; i++) {
                selectedFiles.push(files[i]);
                var item = $('<div class="file-item">' + 
                    files[i].name + ' (' + formatFileSize(files[i].size) + ')' +
                    '<span class="remove-btn" onclick="removeFile(' + i + ')">×</span>' +
                    '</div>');
                fileList.append(item);
            }
        });
        
        function removeFile(index) {
            selectedFiles.splice(index, 1);
            updateFileList();
        }
        
        function updateFileList() {
            var fileList = $('#fileList');
            fileList.empty();
            
            selectedFiles.forEach(function(file, index) {
                var item = $('<div class="file-item">' + 
                    file.name + ' (' + formatFileSize(file.size) + ')' +
                    '<span class="remove-btn" onclick="removeFile(' + index + ')">×</span>' +
                    '</div>');
                fileList.append(item);
            });
        }
        
        function uploadFiles() {
            var formData = new FormData();
            formData.append('name', $('input[name="name"]').val());
            
            selectedFiles.forEach(function(file) {
                formData.append('uploadfiles', file);
            });
            
            $.ajax({
                url: '${pageContext.request.contextPath}/multiFileUpload',
                type: 'POST',
                data: formData,
                processData: false,
                contentType: false,
                success: function(result) {
                    showResult(result);
                },
                error: function() {
                    alert('上传失败！');
                }
            });
        }
        
        function showResult(result) {
            var html = '<h3>上传结果</h3>';
            html += '<p>总计：' + result.total + ' 个文件</p>';
            html += '<p>成功：' + result.successCount + ' 个</p>';
            html += '<p>失败：' + result.failCount + ' 个</p>';
            html += '<ul>';
            
            result.files.forEach(function(file) {
                html += '<li>' + file.name + ' - ' + 
                    (file.status === 'success' ? '成功' : '失败：' + file.message) + 
                    '</li>';
            });
            
            html += '</ul>';
            $('#result').html(html);
        }
        
        function formatFileSize(bytes) {
            if(bytes === 0) return '0 Bytes';
            var k = 1024;
            var sizes = ['Bytes', 'KB', 'MB', 'GB'];
            var i = Math.floor(Math.log(bytes) / Math.log(k));
            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
        }
    </script>
</body>
</html>

大文件上传

对于大文件上传，需要实现分片上传功能：

/**
 * 大文件分片上传控制器
 */
@RestController
@RequestMapping("/chunk")
public class ChunkUploadController {
    
    // 存储上传进度
    private Map<String, ChunkUploadInfo> uploadProgressMap = new ConcurrentHashMap<>();
    
    /**
     * 接收文件分片
     */
    @PostMapping("/upload")
    public Map<String, Object> uploadChunk(
            @RequestParam("file") MultipartFile file,
            @RequestParam("chunkNumber") int chunkNumber,
            @RequestParam("totalChunks") int totalChunks,
            @RequestParam("identifier") String identifier,
            @RequestParam("filename") String filename) {
        
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 创建临时目录存储分片
            String tempDir = "temp/" + identifier;
            File tempDirFile = new File(tempDir);
            if (!tempDirFile.exists()) {
                tempDirFile.mkdirs();
            }
            
            // 保存分片
            String chunkFilename = filename + ".part" + chunkNumber;
            File chunkFile = new File(tempDir, chunkFilename);
            file.transferTo(chunkFile);
            
            // 更新上传进度
            ChunkUploadInfo uploadInfo = uploadProgressMap.computeIfAbsent(
                identifier, k -> new ChunkUploadInfo(filename, totalChunks)
            );
            uploadInfo.addUploadedChunk(chunkNumber);
            
            // 检查是否所有分片都已上传
            if (uploadInfo.isComplete()) {
                // 合并分片
                mergeChunks(identifier, filename, totalChunks);
                uploadProgressMap.remove(identifier);
                
                result.put("status", "complete");
                result.put("message", "文件上传完成");
            } else {
                result.put("status", "uploading");
                result.put("progress", uploadInfo.getProgress());
            }
            
        } catch (Exception e) {
            result.put("status", "error");
            result.put("message", e.getMessage());
        }
        
        return result;
    }
    
    /**
     * 合并分片
     */
    private void mergeChunks(String identifier, String filename, int totalChunks) 
            throws IOException {
        String tempDir = "temp/" + identifier;
        String uploadDir = "upload/";
        File uploadDirFile = new File(uploadDir);
        if (!uploadDirFile.exists()) {
            uploadDirFile.mkdirs();
        }
        
        // 创建目标文件
        File mergedFile = new File(uploadDir, filename);
        try (FileOutputStream fos = new FileOutputStream(mergedFile)) {
            // 按顺序合并分片
            for (int i = 1; i <= totalChunks; i++) {
                File chunkFile = new File(tempDir, filename + ".part" + i);
                Files.copy(chunkFile.toPath(), fos);
                chunkFile.delete(); // 删除分片
            }
        }
        
        // 删除临时目录
        new File(tempDir).delete();
    }
    
    /**
     * 获取上传进度
     */
    @GetMapping("/progress/{identifier}")
    public Map<String, Object> getProgress(@PathVariable String identifier) {
        Map<String, Object> result = new HashMap<>();
        ChunkUploadInfo uploadInfo = uploadProgressMap.get(identifier);
        
        if (uploadInfo != null) {
            result.put("progress", uploadInfo.getProgress());
            result.put("uploadedChunks", uploadInfo.getUploadedChunks());
            result.put("totalChunks", uploadInfo.getTotalChunks());
        } else {
            result.put("progress", 0);
        }
        
        return result;
    }
    
    /**
     * 分片上传信息类
     */
    private static class ChunkUploadInfo {
        private String filename;
        private int totalChunks;
        private Set<Integer> uploadedChunks = new HashSet<>();
        
        public ChunkUploadInfo(String filename, int totalChunks) {
            this.filename = filename;
            this.totalChunks = totalChunks;
        }
        
        public void addUploadedChunk(int chunkNumber) {
            uploadedChunks.add(chunkNumber);
        }
        
        public boolean isComplete() {
            return uploadedChunks.size() == totalChunks;
        }
        
        public int getProgress() {
            return (int) ((uploadedChunks.size() * 100.0) / totalChunks);
        }
        
        // getters...
    }
}

上传进度显示

使用Ajax实现文件上传进度显示：

function uploadWithProgress() {
    var formData = new FormData();
    var fileInput = document.getElementById('file');
    var file = fileInput.files[0];
    
    formData.append('file', file);
    formData.append('name', document.getElementById('name').value);
    
    $.ajax({
        url: '/fileUpload',
        type: 'POST',
        data: formData,
        processData: false,
        contentType: false,
        xhr: function() {
            var xhr = new window.XMLHttpRequest();
            // 监听上传进度
            xhr.upload.addEventListener('progress', function(evt) {
                if (evt.lengthComputable) {
                    var percentComplete = evt.loaded / evt.total * 100;
                    $('#progress').css('width', percentComplete + '%');
                    $('#progress').text(Math.round(percentComplete) + '%');
                }
            }, false);
            return xhr;
        },
        success: function(response) {
            alert('上传成功！');
        },
        error: function() {
            alert('上传失败！');
        }
    });
}

文件下载实现

基本下载

文件下载的实现方式有多种，最常用的是通过ResponseEntity返回文件流。

创建下载页面

创建download.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.net.URLEncoder" %>
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>文件下载中心</title>
    <style>
        .download-container {
            width: 800px;
            margin: 50px auto;
            padding: 20px;
        }
        .file-list {
            border: 1px solid #ddd;
            border-radius: 5px;
            padding: 20px;
        }
        .file-item {
            display: flex;
            justify-content: space-between;
            align-items: center;
            padding: 10px;
            border-bottom: 1px solid #eee;
        }
        .file-item:last-child {
            border-bottom: none;
        }
        .file-info {
            flex: 1;
        }
        .file-name {
            font-weight: bold;
            margin-bottom: 5px;
        }
        .file-meta {
            color: #666;
            font-size: 14px;
        }
        .download-btn {
            background-color: #4CAF50;
            color: white;
            padding: 8px 16px;
            text-decoration: none;
            border-radius: 4px;
        }
        .download-btn:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <div class="download-container">
        <h2>文件下载中心</h2>
        
        <div class="file-list">
            <h3>可下载文件列表</h3>
            
            <!-- 示例文件列表 -->
            <div class="file-item">
                <div class="file-info">
                    <div class="file-name">示例文档.pdf</div>
                    <div class="file-meta">大小: 2.5 MB | 上传时间: 2025-09-12</div>
                </div>
                <a href="${pageContext.request.contextPath}/download?filename=示例文档.pdf" 
                   class="download-btn">下载</a>
            </div>
            
            <div class="file-item">
                <div class="file-info">
                    <div class="file-name">项目报告.docx</div>
                    <div class="file-meta">大小: 1.2 MB | 上传时间: 2025-09-11</div>
                </div>
                <a href="${pageContext.request.contextPath}/download?filename=<%=URLEncoder.encode("项目报告.docx", "UTF-8")%>" 
                   class="download-btn">下载</a>
            </div>
            
            <div class="file-item">
                <div class="file-info">
                    <div class="file-name">数据分析.xlsx</div>
                    <div class="file-meta">大小: 856 KB | 上传时间: 2025-09-10</div>
                </div>
                <a href="${pageContext.request.contextPath}/download?filename=<%=URLEncoder.encode("数据分析.xlsx", "UTF-8")%>" 
                   class="download-btn">下载</a>
            </div>
        </div>
        
        <!-- 批量下载 -->
        <div style="margin-top: 20px;">
            <h3>批量下载</h3>
            <form id="batchDownloadForm">
                <label><input type="checkbox" name="files" value="示例文档.pdf"> 示例文档.pdf</label><br>
                <label><input type="checkbox" name="files" value="项目报告.docx"> 项目报告.docx</label><br>
                <label><input type="checkbox" name="files" value="数据分析.xlsx"> 数据分析.xlsx</label><br>
                <button type="button" onclick="batchDownload()" style="margin-top: 10px;">批量下载</button>
            </form>
        </div>
    </div>
    
    <script>
        function batchDownload() {
            var checkboxes = document.getElementsByName('files');
            var selectedFiles = [];
            
            for(var i = 0; i < checkboxes.length; i++) {
                if(checkboxes[i].checked) {
                    selectedFiles.push(checkboxes[i].value);
                }
            }
            
            if(selectedFiles.length === 0) {
                alert('请选择要下载的文件');
                return;
            }
            
            // 发送批量下载请求
            var form = document.createElement('form');
            form.method = 'POST';
            form.action = '${pageContext.request.contextPath}/batchDownload';
            
            selectedFiles.forEach(function(file) {
                var input = document.createElement('input');
                input.type = 'hidden';
                input.name = 'files';
                input.value = file;
                form.appendChild(input);
            });
            
            document.body.appendChild(form);
            form.submit();
            document.body.removeChild(form);
        }
    </script>
</body>
</html>

中文文件名处理

创建文件下载控制器FileDownloadController.java：

package com.owlbay.controller;

import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.*;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.apache.commons.io.FileUtils;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * 文件下载控制器
 * @author Owlbay
 * @date 2022/05/17
 */
@Controller
public class FileDownloadController {
    
    /**
     * 基本文件下载（处理中文文件名）
     */
    @RequestMapping("/download")
    public ResponseEntity<byte[]> fileDownload(
            HttpServletRequest request,
            @RequestParam("filename") String filename) throws Exception {
            
        // 安全性检查：防止目录遍历攻击
        if (filename.contains("..") || filename.contains("/") || filename.contains("\\")) {
            return ResponseEntity.badRequest().build();
        }
        
        // 获取文件路径
        String uploadDir = request.getSession().getServletContext().getRealPath("/upload/");
        File file = new File(uploadDir, filename);
        
        // 检查文件是否存在
        if (!file.exists() || !file.isFile()) {
            return ResponseEntity.notFound().build();
        }
        
        // 检查文件是否可读
        if (!file.canRead()) {
            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
        }
        
        // 对文件名进行编码处理
        String encodedFilename = encodeFilename(request, filename);
        
        // 设置响应头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentDispositionFormData("attachment", encodedFilename);
        headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        headers.setContentLength(file.length());
        
        // 添加缓存控制
        headers.setCacheControl(CacheControl.noCache());
        headers.setPragma("no-cache");
        headers.setExpires(0);
        
        // 读取文件内容并返回
        byte[] fileContent = FileUtils.readFileToByteArray(file);
        
        return new ResponseEntity<>(fileContent, headers, HttpStatus.OK);
    }
    
    /**
     * 使用流式下载（适合大文件）
     */
    @GetMapping("/streamDownload")
    public void streamDownload(
            HttpServletRequest request,
            HttpServletResponse response,
            @RequestParam("filename") String filename) throws Exception {
            
        // 安全性检查
        if (filename.contains("..") || filename.contains("/") || filename.contains("\\")) {
            response.sendError(HttpServletResponse.SC_BAD_REQUEST);
            return;
        }
        
        String uploadDir = request.getSession().getServletContext().getRealPath("/upload/");
        File file = new File(uploadDir, filename);
        
        if (!file.exists() || !file.isFile()) {
            response.sendError(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        
        // 设置响应头
        response.setContentType("application/octet-stream");
        response.setContentLengthLong(file.length());
        
        String encodedFilename = encodeFilename(request, filename);
        response.setHeader("Content-Disposition", "attachment; filename=\"" + encodedFilename + "\"");
        
        // 使用缓冲流进行文件传输
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
             BufferedOutputStream bos = new BufferedOutputStream(response.getOutputStream())) {
            
            byte[] buffer = new byte[4096];
            int bytesRead;
            
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
            
            bos.flush();
        }
    }
    
    /**
     * 根据浏览器类型对文件名进行编码
     */
    private String encodeFilename(HttpServletRequest request, String filename) 
            throws UnsupportedEncodingException {
        
        String userAgent = request.getHeader("User-Agent");
        
        // 针对IE浏览器的处理
        if (userAgent != null && (userAgent.contains("MSIE") || 
            userAgent.contains("Trident") || userAgent.contains("Edge"))) {
            // IE浏览器，使用URLEncoder编码
            return URLEncoder.encode(filename, "UTF-8").replace("+", "%20");
        } 
        // 其他现代浏览器
        else {
            // 使用ISO-8859-1编码
            return new String(filename.getBytes("UTF-8"), "ISO-8859-1");
        }
    }
    
    /**
     * 批量下载（打包成zip）
     */
    @PostMapping("/batchDownload")
    public void batchDownload(
            HttpServletRequest request,
            HttpServletResponse response,
            @RequestParam("files") List<String> filenames) throws Exception {
            
        // 设置响应头
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", 
            "attachment; filename=\"batch_download.zip\"");
        
        String uploadDir = request.getSession().getServletContext().getRealPath("/upload/");
        
        // 创建ZIP输出流
        try (ZipOutputStream zos = new ZipOutputStream(response.getOutputStream())) {
            
            for (String filename : filenames) {
                // 安全性检查
                if (filename.contains("..") || filename.contains("/") || filename.contains("\\")) {
                    continue;
                }
                
                File file = new File(uploadDir, filename);
                if (file.exists() && file.isFile()) {
                    // 添加文件到ZIP
                    ZipEntry entry = new ZipEntry(filename);
                    zos.putNextEntry(entry);
                    
                    // 写入文件内容
                    try (FileInputStream fis = new FileInputStream(file)) {
                        byte[] buffer = new byte[4096];
                        int bytesRead;
                        while ((bytesRead = fis.read(buffer)) != -1) {
                            zos.write(buffer, 0, bytesRead);
                        }
                    }
                    
                    zos.closeEntry();
                }
            }
        }
    }
    
    /**
     * 获取文件信息（用于下载前预览）
     */
    @GetMapping("/fileInfo")
    @ResponseBody
    public Map<String, Object> getFileInfo(
            HttpServletRequest request,
            @RequestParam("filename") String filename) {
            
        Map<String, Object> info = new HashMap<>();
        
        try {
            String uploadDir = request.getSession().getServletContext().getRealPath("/upload/");
            File file = new File(uploadDir, filename);
            
            if (file.exists() && file.isFile()) {
                info.put("name", filename);
                info.put("size", formatFileSize(file.length()));
                info.put("lastModified", new Date(file.lastModified()));
                info.put("type", getFileType(filename));
                info.put("exists", true);
            } else {
                info.put("exists", false);
            }
        } catch (Exception e) {
            info.put("error", e.getMessage());
        }
        
        return info;
    }
    
    /**
     * 获取文件类型
     */
    private String getFileType(String filename) {
        String extension = filename.substring(filename.lastIndexOf('.') + 1).toLowerCase();
        
        Map<String, String> mimeTypes = new HashMap<>();
        mimeTypes.put("pdf", "application/pdf");
        mimeTypes.put("doc", "application/msword");
        mimeTypes.put("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
        mimeTypes.put("xls", "application/vnd.ms-excel");
        mimeTypes.put("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        mimeTypes.put("jpg", "image/jpeg");
        mimeTypes.put("jpeg", "image/jpeg");
        mimeTypes.put("png", "image/png");
        mimeTypes.put("gif", "image/gif");
        mimeTypes.put("txt", "text/plain");
        mimeTypes.put("zip", "application/zip");
        mimeTypes.put("rar", "application/x-rar-compressed");
        
        return mimeTypes.getOrDefault(extension, "application/octet-stream");
    }
    
    /**
     * 格式化文件大小
     */
    private String formatFileSize(long size) {
        if (size <= 0) return "0 B";
        final String[] units = {"B", "KB", "MB", "GB", "TB"};
        int digitGroups = (int) (Math.log10(size) / Math.log10(1024));
        return String.format("%.2f %s", size / Math.pow(1024, digitGroups), units[digitGroups]);
    }
}