在Spring MVC的基礎框架搭建起來後，我們測試了spring mvc中的返回值類型，如果你還沒有搭建好springmvc的架構請參考博文->http://www.cnblogs.com/qixiaoyizhan/p/5819392.html

今天我們來講講spring mvc中的文件上傳和下載的幾種方法。

首先附上文件目錄->我們需要配置的我做了記號->

一、文件上傳

首先為了方便後續的操作，以及精簡代碼，我們在Utils包下封裝一個文件上傳下載的幫助類： Files_Helper_DG

Files_Helper_DG 代碼

package Utils;

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;

/**
 * Author:qixiao
 * Time:2016-9-2 23:47:51
 */
public final class Files_Utils_DG {
    /**
     * private constructor method that make class can not be instantiation
     */
    private Files_Utils_DG() {
        throw new Error("The class Cannot be instance !");
    }

    /**
     * spring mvc files Upload method (transferTo method)
     * MultipartFile use TransferTo method upload
     *
     * @param request       HttpServletRequest
     * @param multipartFile MultipartFile(spring)
     * @param filePath      filePath example "/files/Upload"
     * @return
     */
    public static String FilesUpload_transferTo_spring(HttpServletRequest request, MultipartFile multipartFile, String filePath) {
        if (multipartFile != null) {
            //get files suffix
            String suffix = multipartFile.getOriginalFilename().substring(multipartFile.getOriginalFilename().lastIndexOf("."));
            //filePath+fileName the complex file Name
            String absolutePath = getAndSetAbsolutePath(request, filePath, suffix);
            //return relative Path
            String relativePath = getRelativePath(filePath, suffix);
            try {
                //save file
                multipartFile.transferTo(new File(absolutePath));
                //return relative Path
                return relativePath;
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
        } else
            return null;
    }

    /**
     * user stream type save files
     * @param request       HttpServletRequest
     * @param multipartFile MultipartFile  support CommonsMultipartFile file
     * @param filePath      filePath example "/files/Upload"
     * @return
     */
    public static String FilesUpload_stream(HttpServletRequest request,MultipartFile multipartFile,String filePath) {
        if (multipartFile != null) {
            //get files suffix
            String suffix = multipartFile.getOriginalFilename().substring(multipartFile.getOriginalFilename().lastIndexOf("."));
            //filePath+fileName the complex file Name
            String absolutePath = getAndSetAbsolutePath(request, filePath, suffix);
            //return relative Path
            String relativePath = getRelativePath(filePath, suffix);
            try{
                InputStream inputStream = multipartFile.getInputStream();
                FileOutputStream fileOutputStream = new FileOutputStream(absolutePath);
                byte buffer[] = new byte[4096]; //create a buffer
                long fileSize = multipartFile.getSize();
                if(fileSize<=buffer.length){//if fileSize < buffer
                    buffer = new byte[(int)fileSize];
                }
                int line =0;
                while((line = inputStream.read(buffer)) >0 )
                {
                    fileOutputStream.write(buffer,0,line);
                }
                fileOutputStream.close();
                inputStream.close();
                return relativePath;
            }catch (Exception e){
                e.printStackTrace();
            }
        } else
            return null;
        return null;
    }

    /**
     * @param request  HttpServletRequest
     * @param response HttpServletResponse
     * @param filePath example "/filesOut/Download/mst.txt"
     * @return
     */
    public static void FilesDownload_stream(HttpServletRequest request, HttpServletResponse response, String filePath) {
        //get server path (real path)
        String realPath = request.getSession().getServletContext().getRealPath(filePath);
        File file = new File(realPath);
        String filenames = file.getName();
        InputStream inputStream;
        try {
            inputStream = new BufferedInputStream(new FileInputStream(file));
            byte[] buffer = new byte[inputStream.available()];
            inputStream.read(buffer);
            inputStream.close();
            response.reset();
            // 先去掉文件名稱中的空格,然後轉換編碼格式為utf-8,保證不出現亂碼,這個文件名稱用於瀏覽器的下載框中自動顯示的文件名
            response.addHeader("Content-Disposition", "attachment;filename=" + new String(filenames.replaceAll(" ", "").getBytes("utf-8"), "iso8859-1"));
            response.addHeader("Content-Length", "" + file.length());
            OutputStream os = new BufferedOutputStream(response.getOutputStream());
            response.setContentType("application/octet-stream");
            os.write(buffer);// 輸出文件
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //-------------------------------------------------------------------------------
    //return server absolute path（real path）
    public static String getServerPath(HttpServletRequest request, String filePath) {
        return request.getSession().getServletContext().getRealPath(filePath);
    }

    //return a dir that named date of today ; example:20160912
    public static String getDataPath() {
        return new SimpleDateFormat("yyyyMMdd").format(new Date());
    }

    //check if the path has exist if not create it
    public static void checkDir(String savePath) {
        File dir = new File(savePath);
        if (!dir.exists() || !dir.isDirectory()) {
            dir.mkdir();
        }
    }

    //return an UUID Name parameter (suffix cover ‘.‘) example： ".jpg"、".txt"
    public static String getUUIDName(String suffix) {
        return UUID.randomUUID().toString() + suffix;// make new file name
    }

    //return server absolute path（real path） the style is  “server absolute path/DataPath/UUIDName”filePath example "/files/Upload"
    public static String getAndSetAbsolutePath(HttpServletRequest request, String filePath, String suffix) {
        String savePath = getServerPath(request, filePath) + File.separator + getDataPath() + File.separator;//example:F:/qixiao/files/Upload/20160912/
        checkDir(savePath);//check if the path has exist if not create it
        return savePath + getUUIDName(suffix);
    }

    //get the relative path of files style is “/filePath/DataPath/UUIDName”filePath example "/files/Upload"
    public static String getRelativePath(String filePath, String suffix) {
        return filePath + File.separator + getDataPath() + File.separator + getUUIDName(suffix);//example:/files/Upload/20160912/
    }
}

然後我們新建一個控制器類 FileUploadController

首先我們先展示出全部的代碼，然後我們進行分步說明--->

package HelloSpringMVC.controller;


import Utils.Files_Utils_DG;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Iterator;

/**
 * Created by qixiao on 2016/8/30.
 */
@Controller
@RequestMapping(value = "/FileUpload/*")
public class FileUploadController {

    /*
     * 方式一
     * 采用 fileUpload_multipartFile ， file.transferTo 來保存上傳的文件
     */
    @RequestMapping(value = "fileUpload_multipartFile")
    @ResponseBody
    public String fileUpload_multipartFile(HttpServletRequest request, @RequestParam("file_upload") MultipartFile multipartFile) {
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Utils_DG.FilesUpload_transferTo_spring(request, multipartFile, "/files/upload");
        return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘,‘filePath‘:‘" + filePath + "‘}";
    }

    /*
     * 方式二
     * 采用 fileUpload_multipartRequest file.transferTo 來保存上傳文件
     * 參數不寫 MultipartFile multipartFile 在request請求裏面直接轉成multipartRequest，從multipartRequest中獲取到文件流
     */
    @RequestMapping(value = "fileUpload_multipartRequest")
    @ResponseBody
    public String fileUpload_multipartRequest(HttpServletRequest request) {
        //將request轉成MultipartHttpServletRequest
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        //頁面控件的文件流，對應頁面控件 input file_upload
        MultipartFile multipartFile = multipartRequest.getFile("file_upload");
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Utils_DG.FilesUpload_transferTo_spring(request, multipartFile, "/files/upload");
        return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘,‘filePath‘:‘" + filePath + "‘}";
    }

    /*
     * 方式三
     * 采用 CommonsMultipartResolver file.transferTo 來保存上傳文件
     * 自動掃描全部的input表單
     */
    @RequestMapping(value = "fileUpload_CommonsMultipartResolver")
    @ResponseBody
    public String fileUpload_CommonsMultipartResolver(HttpServletRequest request) {
        //將當前上下文初始化給  CommonsMultipartResolver （多部分解析器）
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());
        //檢查form中是否有enctype="multipart/form-data"
        if (multipartResolver.isMultipart(request)) {
            //將request變成多部分request
            MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
            //獲取multiRequest 中所有的文件名
            Iterator iter = multipartRequest.getFileNames();
            while (iter.hasNext()) {
                //一次遍歷所有文件
                MultipartFile multipartFile = multipartRequest.getFile(iter.next().toString());
                //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
                String fileName = Files_Utils_DG.FilesUpload_transferTo_spring(request, multipartFile, "/files/upload");
                System.out.println(fileName);
            }
        }
        return "upload success ! ";
    }

    /*
     * 方式四
     * 通過流的方式上傳文件
     */
    @RequestMapping("fileUpload_stream")
    @ResponseBody
    public String upFile(HttpServletRequest request, @RequestParam("file_upload") MultipartFile multipartFile){
        String filePath= Files_Utils_DG.FilesUpload_stream(request,multipartFile,"/files/upload");
        return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘,‘filePath‘:‘" + filePath + "‘}";
    }

    /*
     * 方式五
     * 采用 fileUpload_ajax ， file.transferTo 來保存上傳的文件 異步
     */
    @RequestMapping(value = "fileUpload_ajax",method = RequestMethod.POST,produces = {"application/json;charset=UTF-8"})
    @ResponseBody
    public String fileUpload_ajax(HttpServletRequest request, @RequestParam("file_AjaxFile") MultipartFile  multipartFile) {
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Utils_DG.FilesUpload_transferTo_spring(request, multipartFile, "/files/upload");
        return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘,‘filePath‘:‘" + filePath + "‘}";
    }

    /*
     * 多文件上傳
     * 采用 MultipartFile[] multipartFile 上傳文件方法
     */
    @RequestMapping(value = "fileUpload_spring_list")
    @ResponseBody
    public String fileUpload_spring_list(HttpServletRequest request, @RequestParam("file_upload") MultipartFile[] multipartFile) {
        //判斷file數組不能為空並且長度大於0
        if (multipartFile != null && multipartFile.length > 0) {
            //循環獲取file數組中得文件
            try {
                for (int i = 0; i < multipartFile.length; i++) {
                    MultipartFile file = multipartFile[i];
                    //保存文件
                    String fileName = Files_Utils_DG.FilesUpload_transferTo_spring(request, file, "/files/upload");
                    System.out.println(fileName);
                }
                return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘}";
            } catch (Exception ee) {
                return "{‘TFMark‘:‘false‘,‘Msg‘:‘參數傳遞有誤！‘}";
            }
        }
        return "{‘TFMark‘:‘false‘,‘Msg‘:‘參數傳遞有誤！‘}";
    }

    /**
     * 文件下載
     *
     * @param response
     */
    @RequestMapping(value = "fileDownload_servlet")
    public void fileDownload_servlet(HttpServletRequest request, HttpServletResponse response) {
        Files_Utils_DG.FilesDownload_stream(request,response,"/files/download/mst.txt");
    }
}

方式一：采用 fileUpload_multipartFile ， file.transferTo 來保存上傳的文件

/*
     * 方式一
     * 采用 fileUpload_multipartFile ， file.transferTo 來保存上傳的文件
     */
    @RequestMapping(value = "fileUpload_multipartFile")
    @ResponseBody
    public String fileUpload_multipartFile(HttpServletRequest request, @RequestParam("file_upload") MultipartFile multipartFile) {
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Helper_DG.FilesUpload_transferTo_spring(request, multipartFile, "/filesOut/Upload");
        return "{\"TFMark\":\"true\",\"Msg\":\"upload success !\",\"filePath\":\"" + filePath + "\"}";
    }

方式二：采用 fileUpload_multipartRequest file.transferTo 來保存上傳文件

@RequestMapping(value = "fileUpload_multipartRequest")
    @ResponseBody
    public String fileUpload_multipartRequest(HttpServletRequest request) {
        //將request轉成MultipartHttpServletRequest
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
        //頁面控件的文件流，對應頁面控件 input file_upload
        MultipartFile multipartFile = multipartRequest.getFile("file_upload");
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Helper_DG.FilesUpload_transferTo_spring(request, multipartFile, "/filesOut/Upload");
        return "{\"TFMark\":\"true\",\"Msg\":\"upload success !\",\"filePath\":\"" + filePath + "\"}";
    }

方式三：采用 CommonsMultipartResolver file.transferTo 來保存上傳文件---自動掃描全部的input表單

@RequestMapping(value = "fileUpload_CommonsMultipartResolver")
    @ResponseBody
    public String fileUpload_CommonsMultipartResolver(HttpServletRequest request) {
        //將當前上下文初始化給  CommonsMultipartResolver （多部分解析器）
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());
        //檢查form中是否有enctype="multipart/form-data"
        if (multipartResolver.isMultipart(request)) {
            //將request變成多部分request
            MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
            //獲取multiRequest 中所有的文件名
            Iterator iter = multipartRequest.getFileNames();
            while (iter.hasNext()) {
                //一次遍歷所有文件
                MultipartFile multipartFile = multipartRequest.getFile(iter.next().toString());
                //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
                String fileName = Files_Helper_DG.FilesUpload_transferTo_spring(request, multipartFile, "/filesOut/Upload");
                System.out.println(fileName);
            }
        }
        return "upload success ! ";
    }

方式四：通過流的方式上傳文件

1 @RequestMapping("fileUpload_stream")
2     @ResponseBody
3     public String upFile(HttpServletRequest request, @RequestParam("file_upload") MultipartFile multipartFile){
4         String filePath=Files_Helper_DG.FilesUpload_stream(request,multipartFile,"/filesOut/Upload");
5         return "{\"TFMark\":\"true\",\"Msg\":\"upload success !\",\"filePath\":\"" + filePath + "\"}";
6     }

方式五：采用ajaxFileUpload.js插件與異步上傳的方式上傳文件

@RequestMapping(value = "fileUpload_ajax",method = RequestMethod.POST,produces = {"application/json;charset=UTF-8"})
    @ResponseBody
    public String fileUpload_ajax(HttpServletRequest request, @RequestParam("file_AjaxFile") MultipartFile  multipartFile) {
        //調用保存文件的幫助類進行保存文件，並返回文件的相對路徑
        String filePath = Files_Utils_DG.FilesUpload_transferTo_spring(request, multipartFile, "/files/upload");
        return "{‘TFMark‘:‘true‘,‘Msg‘:‘upload success !‘,‘filePath‘:‘" + filePath + "‘}";
    }

上述方法需要 ajaxfileupload.js 插件的支持,該插件

多文件上傳（其實是將上面的 MultipartFile 寫成數組形式）

@RequestMapping(value = "fileUpload_spring_list")
    @ResponseBody
    public String fileUpload_spring_list(HttpServletRequest request, @RequestParam("file_upload") MultipartFile[] multipartFile) {
        //判斷file數組不能為空並且長度大於0
        if (multipartFile != null && multipartFile.length > 0) {
            //循環獲取file數組中得文件
            try {
                for (int i = 0; i < multipartFile.length; i++) {
                    MultipartFile file = multipartFile[i];
                    //保存文件
                    String fileName = Files_Helper_DG.FilesUpload_transferTo_spring(request, file, "/filesOut/Upload");
                    System.out.println(fileName);
                }
                return "{\"TFMark\":\"true\",\"Msg\":\"upload success !\"}";
            } catch (Exception ee) {
                return "{\"TFMark\":\"false\",\"Msg\":\"參數傳遞有誤！\"}";
            }
        }
        return "{\"TFMark\":\"false\",\"Msg\":\"參數傳遞有誤！\"}";
    }

下面我們進行測試：

首先在webapp下新建文件夾目錄/files/download，並且新建一個/Views/FileUpload/FileUpload.jsp

註意文件目錄結構以及目錄層次！！！

FileUpload.jsp代碼如下

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String path = request.getContextPath();
    String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
%>
<html>
<head>
    <base href="<%=basePath%>">
    <title>fileUpload</title>
    <script src="<%=basePath%>scripts/jquery-1.11.1.js"></script>
    <script src="<%=basePath%>scripts/ajaxfileupload.js"></script>
</head>
<body>
<h3>文件上傳</h3><br>

<h3>采用 fileUpload_multipartFile ， file.transferTo 來保存上傳的文件</h3>
<form name="form1" action="/FileUpload/fileUpload_multipartFile" method="post" enctype="multipart/form-data">
    <input type="file" name="file_upload">
    <input type="submit" value="upload"/>
</form>
<hr>

<h3>采用 fileUpload_multipartRequest file.transferTo 來保存上傳文件</h3>
<form name="form2" action="/FileUpload/fileUpload_multipartRequest" method="post" enctype="multipart/form-data">
    <input type="file" name="file_upload">
    <input type="submit" value="upload"/>
</form>
<hr>

<h3>采用 CommonsMultipartResolver file.transferTo 來保存上傳文件</h3>
<form name="form3" action="/FileUpload/fileUpload_CommonsMultipartResolver" method="post" enctype="multipart/form-data">
    <input type="file" name="file_upload">
    <input type="submit" value="upload"/>
</form>
<hr>

<h3>通過流的方式上傳文件</h3>
<form name="form4" action="/FileUpload/fileUpload_stream" method="post" enctype="multipart/form-data">
    <input type="file" name="file_upload">
    <input type="submit" value="upload"/>
</form>
<hr>

<h3>通過ajax插件 ajaxfileupload.js 來異步上傳文件</h3>
<form name="form5" action="/" method="post" enctype="multipart/form-data">
    <input type="file" id="file_AjaxFile" name="file_AjaxFile">
    <input type="button" value="upload" onclick="fileUploadAjax()"/><span id="sp_AjaxFile"></span><br><br>
    上傳進度：<span id="sp_fileUploadProgress">0%</span>
</form>
<script type="text/javascript">
    function fileUploadAjax() {
        if ($("#file_AjaxFile").val().length > 0) {
            progressInterval=setInterval(getProgress,500);
            $.ajaxFileUpload({
                url: ‘/FileUpload/fileUpload_ajax‘, //用於文件上傳的服務器端請求地址
                type: "post",
                secureuri: false, //一般設置為false
                fileElementId: ‘file_AjaxFile‘, //文件上傳空間的id屬性  <input type="file" id="file1" name="file" />
                dataType: ‘application/json‘, //返回值類型 一般設置為json
                success: function (data)  //服務器成功響應處理函數
                {
                    var jsonObject = eval(‘(‘ + data + ‘)‘);
                    $("#sp_AjaxFile").html(" Upload Success ！ filePath:" + jsonObject.filePath);
                },
                error: function (data, status, e)//服務器響應失敗處理函數
                {
                    alert(e);
                }
            });//end ajaxfile
        }
        else {
            alert("請選擇文件!");
        }
    }
    var progressInterval = null;
    var i=0;
    var getProgress=function (){
        $.get("/FileUpload/fileUploadprogress",
                {},
        function (data) {
            $("#sp_fileUploadProgress").html(i+++data);
            if(data==100||i==100)
                clearInterval(progressInterval);
        }
    );
    }
</script>
<hr>

<h3>多文件上傳 采用 MultipartFile[] multipartFile 上傳文件方法</h3>
<form name="form5" action="/FileUpload/fileUpload_spring_list" method="post" enctype="multipart/form-data">
    <input type="file" name="file_upload">
    <input type="file" name="file_upload">
    <input type="file" name="file_upload">
    <input type="submit" value="upload"/>
</form>
<hr>

<h3>通過 a 標簽的方式進行文件下載</h3><br>
<a href="<%=basePath%>filesOut/Download/mst.txt">通過 a 標簽下載文件 mst.txt</a>
<hr>
<h3>通過 Response 文件流的方式下載文件</h3>
<a href="/FileUpload/fileDownload_servlet">通過 文件流 的方式下載文件 mst.txt</a>

</body>
</html>

這裏一定要記得在spring-servlet.xml裏面配置訪問靜態路徑方法->下面我附上spring-servlet.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-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

    <!-- 啟動註解驅動的Spring MVC功能，註冊請求url和註解POJO類方法的映射-->  
    <mvc:annotation-driven >
         
    </mvc:annotation-driven>
   
    <!-- 啟動包掃描功能，[email protected]@[email protected]@Component等註解的類成為spring的bean -->
    <context:component-scan base-package="HelloSpringMVC.controller" />
    <!-- 對模型視圖名稱的解析，在請求時模型視圖名稱添加前後綴 -->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
         <property name="prefix" value="/"/>    <!-- 前綴 -->
         <property name="suffix" value=".jsp"/>    <!-- 後綴 -->
     </bean>
    <!-- 訪問靜態文件（jpg,js,css）的方法 -->
    <mvc:resources location="/files/" mapping="/files/**" />
    <mvc:resources location="/scripts/" mapping="/scripts/**" />
    <mvc:resources location="/styles/" mapping="/styles/**" />
    <mvc:resources location="/Views/" mapping="/Views/**" />

    <!-- 多部分文件上傳 需配置MultipartResolver處理器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="104857600" />
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>
    <!-- SpringMVC在超出上傳文件限制時,會拋出org.springframework.web.multipart.MaxUploadSizeExceededException -->
    <!-- 該異常是SpringMVC在檢查上傳的文件信息時拋出來的,而且此時還沒有進入到Controller方法中 -->
    <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings">
            <props>
                <!-- 遇到MaxUploadSizeExceededException異常時,自動跳轉到/WEB-INF/jsp/error_fileupload.jsp頁面 -->
                <prop key="org.springframework.web.multipart.MaxUploadSizeExceededException">error_fileupload</prop>
            </props>
        </property>
    </bean>
</beans>

然後我們運行tomcat進入http://localhost:8080/Views/FileUpload/FileUpload.jsp

打開後，頁面如下：

我們依次選擇文件->

共八個文件！

然後依次點擊upload按鈕，進行文件的上傳->

可見，六種上傳都已經執行成功！下面我們打開文件目錄查看一下上傳的文件->

一共八個文件！證明所有文件都上傳成功了！

二、文件下載

在控制器類 FileUploadController裏面繼續添加代碼->

1 @RequestMapping(value = "fileDownload_servlet")
2     public void fileDownload_servlet(HttpServletRequest request, HttpServletResponse response) {
3         Files_Helper_DG.FilesDownload_servlet(request,response,"/filesOut/Download/mst.txt");
4     }

這裏調用了幫助類 Files_Helper_DG.FilesDownload_servlet(request,response,"/filesOut/Download/mst.txt");

然後我們進行測試->

前面我們新建的文件夾/files/download，在裏面放一個文件mst.txt,代碼訪問的就是這個文件！

然後是我們FileUpload.jsp,前面已經拷貝過了這段代碼->

1 <h3>通過 a 標簽的方式進行文件下載</h3><br>
2 <a href="<%=basePath%>filesOut/Download/mst.txt">通過 a 標簽下載文件 mst.txt</a>
3 <hr>
4 <h3>通過 Response 文件流的方式下載文件</h3>
5 <a href="/FileUpload/fileDownload_servlet">通過 文件流 的方式下載文件 mst.txt</a>

首先是第一種直接訪問文件目錄，此方式有缺陷，暴露了項目文件結構，造成安全隱患！

點擊便可下載！（如果瀏覽器可以讀取文件，則會直接瀏覽器打開，我們可以右鍵->鏈接另存為選擇路徑保存）

然後我們點擊第二種下載方式->實際項目中，我們應該優先選擇第二種方式，提高了安全性！

從服務器直接下載到瀏覽器默認的保存文件目錄！（本人在F:）

到此，我們的 spring mvc 文件上傳下載已經實現！

SpringMVC文件上傳下載