### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

### 本篇概覽
- 本章我們來一起閱讀和分析SpringMVC的部分原始碼，看看收到POST請求中的二進位制檔案後，SpingMVC框架是如何處理的；

- 使用了SpringMVC框架的web應用中，接收上傳檔案時，一般分以下三步完成：
- 在spring配置檔案中配置一個bean：
```xml
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 <property name="defaultEncoding" value="utf-8"></property>
 <property name="maxUploadSize" value="10485760000"></property>
 <property name="maxInMemorySize" value="40960"></property>
</bean>
```
- pom.xml中新增apache的commons-fileupload庫的依賴：
```xml
<dependency>
	<groupid>commons-fileupload</groupid>
 <artifactid>commons-fileupload</artifactid>
 <version>1.3.1</version>
</dependency>
```
- 開發業務Controller的響應方法，以下程式碼是將POST的檔案儲存到應用所在的電腦上：
```java
@RequestMapping(value="/upload",method= RequestMethod.POST)
 public void upload(HttpServletRequest request,
 HttpServletResponse response,
 @RequestParam("comment") String comment,
 @RequestParam("file") MultipartFile file) throws Exception {

logger.info("start upload, comment [{}]", comment);

if(null==file || file.isEmpty()){
            logger.error("file item is empty!");
            responseAndClose(response, "檔案資料為空");
            return;
        }

//上傳檔案路徑
        String savePath = request.getServletContext().getRealPath("/WEB-INF/upload");

//上傳檔名
        String fileName = file.getOriginalFilename();

logger.info("base save path [{}], original file name [{}]", savePath, fileName);

//得到檔案儲存的名稱
        fileName = mkFileName(fileName);

//得到檔案儲存的路徑
        String savePathStr = mkFilePath(savePath, fileName);

logger.info("real save path [{}], real file name [{}]", savePathStr, fileName);

File filepath = new File(savePathStr, fileName);

//確保路徑存在
        if(!filepath.getParentFile().exists()){
            logger.info("real save path is not exists, create now");
            filepath.getParentFile().mkdirs();
        }

String fullSavePath = savePathStr + File.separator + fileName;

//存本地
        file.transferTo(new File(fullSavePath));

logger.info("save file success [{}]", fullSavePath);

responseAndClose(response, "Spring MVC環境下，上傳檔案成功");
    }
```
- 如上所示，方法入參中的MultipartFile就是POST的檔案對應的物件，呼叫file.transferTo方法即可將上傳的檔案建立到業務所需的位置；

### 三個疑問
- 雖然業務程式碼簡單，以上幾步即可完成對上傳檔案的接收和處理，但是有幾個疑問想要弄清楚：
1. 為什麼要配置名為multipartResolver的bean；
2. 為什麼要依賴apache的commons-fileupload庫；
3. 從客戶端的POST到Controller中的file.transferTo方法呼叫，具體做了哪些檔案相關的操作？

- 接下來我們就一起來看看SpringMVC的原始碼，尋找這幾個問題的答案；

### Spring版本
- 本文涉及的Spring相關庫，例如spring-core、spring-web、spring-webmvc等，都是4.0.2.RELEASE版本；

### SpringMVC原始碼
- 先來看下入口類DispatcherServlet的原始碼，在應用初始化的時候會呼叫initMultipartResolver方法：
```java
this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
...
```
- 所以，如果配置了名為multipartResolver的bean，就會DispatcherServlet的multipartResolver儲存下來；
- 再來看一下處理POST請求時候的呼叫鏈：
```java
FrameworkServlet.doPost
->
FrameworkServlet.processRequest
->
DispatcherServlet.doService
->
DispatcherServlet.doDispatch
->
DispatcherServlet.checkMultipart
->
multipartResolver.resolveMultipart(request)
```
- 因此，應用收到上傳檔案的請求時，最終會呼叫multipartResolver.resolveMultipart；

第一個疑問已經解開：SpringMVC框架在處理POST請求時，會使用名為multipartResolver的bean來處理檔案；
- CommonsMultipartResolver.resolveMultipart方法中會呼叫parseRequest方法，我們看parseRequest方法的原始碼：
```java
String encoding = this.determineEncoding(request);
FileUpload fileUpload = this.prepareFileUpload(encoding);

try {
	List<fileitem> fileItems = ((ServletFileUpload)fileUpload).parseRequest(request);
 return this.parseFileItems(fileItems, encoding);
} catch (SizeLimitExceededException var5) {
	throw new MaxUploadSizeExceededException(fileUpload.getSizeMax(), var5);
} catch (FileUploadException var6) {
	throw new MultipartException("Could not parse multipart servlet request", var6);
}
```
- 從以上程式碼可以發現，在呼叫prepareFileUpload方法的時候，相關的fileItemFactory和fileUpload物件都已經是commons-fileupload庫中定義的型別了，並且最終還是呼叫由commons-fileupload庫中的ServletFileUpload.parseRequest方法負責解析工作，構建FileItem物件；
第二個疑問已經解開：SpringMVC框架在處理POST請求時，本質是呼叫commons-fileupload庫中的API來處理的；
- 繼續關注CommonsMultipartResolver.parseRequest方法，裡面呼叫了ServletFileUpload.parseRequest方法，最終由FileUploadBase.parseRequest方法來處理：
```java
public List<fileitem> parseRequest(RequestContext ctx)
 throws FileUploadException {
 List<fileitem> items = new ArrayList<fileitem>();
 boolean successful = false;
 try {
 FileItemIterator iter = getItemIterator(ctx);
 FileItemFactory fac = getFileItemFactory();
 if (fac == null) {
 throw new NullPointerException("No FileItemFactory has been set.");
 }
 while (iter.hasNext()) {
 final FileItemStream item = iter.next();
 // Don't use getName() here to prevent an InvalidFileNameException.
 final String fileName = ((FileItemIteratorImpl.FileItemStreamImpl) item).name;
 FileItem fileItem = fac.createItem(item.getFieldName(), item.getContentType(),
 item.isFormField(), fileName);
 items.add(fileItem);
 try {
 Streams.copy(item.openStream(), fileItem.getOutputStream(), true);
 } catch (FileUploadIOException e) {
 throw (FileUploadException) e.getCause();
 } catch (IOException e) {
 throw new IOFileUploadException(format("Processing of %s request failed. %s",
 MULTIPART_FORM_DATA, e.getMessage()), e);
 }
 final FileItemHeaders fih = item.getHeaders();
 fileItem.setHeaders(fih);
 }
 successful = true;
 return items;
 } catch (FileUploadIOException e) {
 throw (FileUploadException) e.getCause();
 } catch (IOException e) {
 throw new FileUploadException(e.getMessage(), e);
 } finally {
 if (!successful) {
 for (FileItem fileItem : items) {
 try {
 fileItem.delete();
 } catch (Throwable e) {
 // ignore it
 }
 }
 }
 }
 }
```
- 重點關注這一段：Streams.copy(item.openStream(), fileItem.getOutputStream(), true);，這是一次流的複製，將提交檔案的inputstrem寫入到一個outputstream，我們再看看getOutputStream方法的原始碼：
```java
public OutputStream getOutputStream()
 throws IOException {
 if (dfos == null) {
 File outputFile = getTempFile();
 dfos = new DeferredFileOutputStream(sizeThreshold, outputFile);
 }
 return dfos;
 }
```
- 原來如此，會準備一個臨時檔案，上傳的檔案透過流複製寫入到臨時檔案中了；
等一下，事情沒那麼簡單！！！
- 上面的程式碼中並沒有直接返回檔案物件outputFile，而是建立了一個DeferredFileOutputStream物件，這是個什麼東西？另外sizeThreshold這個引數是幹啥用的？

- 為了搞清楚上面兩個問題，我們從Streams.copy方法開始看吧：
a. Streams.copy方法的關鍵程式碼如下：
```java
for (;;) {
                int res = in.read(buffer);
                if (res == -1) {
                    break;
                }
                if (res > 0) {
                    total += res;
                    if (out != null) {
                        out.write(buffer, 0, res);
                    }
                }
            }
```
- 上述程式碼表明，steam的copy過程中會呼叫OutputStream的write方法；

b. DeferredFileOutputStream類沒有write方法，去看它的父類DeferredFileOutputStream的write方法：
```java
public void write(byte b[]) throws IOException
 {
 checkThreshold(b.length);
 getStream().write(b);
 written += b.length;
 }
```
- 先呼叫checkThreshold方法，檢查***已寫入長度***加上***即將寫入的長度***是否達到threshold值，如果達到就會將thresholdExceeded設定為true，並呼叫thresholdReached方法；

c. thresholdReached方法原始碼如下：
```java
protected void thresholdReached() throws IOException
 {
 if (prefix != null) {
 outputFile = File.createTempFile(prefix, suffix, directory);
 }
 FileOutputStream fos = new FileOutputStream(outputFile);
 memoryOutputStream.writeTo(fos);
 currentOutputStream = fos;
 memoryOutputStream = null;
 }
```
- 真相大白：threshold是一個閾值，如果檔案比threshold小，就將檔案存入記憶體，如果檔案比threshold大就寫入到磁碟中去，這顯然是個處理檔案時的最佳化手段；
- 注意這一行程式碼：currentOutputStream = fos;，原本currentOutputStream是基於記憶體的ByteArrayOutputStream，如果超過了threshold，就改為基於檔案的FileOutputStream物件，後續再執行getStream().write(b)的時候，就不再寫入到記憶體，而是寫入到檔案了；

- 我們再回到主線：CommonsMultipartResolver，這裡FileItem物件在parseFileItems方法中經過處理，被放入了CommonsMultipartFile物件中，再被放入MultipartParsingResult物件中，最後被放入DefaultMultipartHttpServletRequest物件中，返回到DispatcherServlet.doDispatch方法中，然後傳遞到業務的controller中處理；

- 業務Controller的響應方法中，呼叫了file.transferTo方法將臨時檔案寫入到業務指定的檔案中，transferTo方法中有一行關鍵程式碼：this.fileItem.write(dest);，我們開啟DiskFileItem類，看看這個write方法的原始碼：
```java
public void write(File file) throws Exception {
 if (isInMemory()) {
 FileOutputStream fout = null;
 try {
 fout = new FileOutputStream(file);
 fout.write(get());
 } finally {
 if (fout != null) {
 fout.close();
 }
 }
 } else {
 File outputFile = getStoreLocation();
 if (outputFile != null) {
 // Save the length of the file
 size = outputFile.length();
 /*
 * The uploaded file is being stored on disk
 * in a temporary location so move it to the
 * desired file.
 */
 if (!outputFile.renameTo(file)) {
 BufferedInputStream in = null;
 BufferedOutputStream out = null;
 try {
 in = new BufferedInputStream(
 new FileInputStream(outputFile));
 out = new BufferedOutputStream(
 new FileOutputStream(file));
 IOUtils.copy(in, out);
 } finally {
 if (in != null) {
 try {
 in.close();
 } catch (IOException e) {
 // ignore
 }
 }
 if (out != null) {
 try {
 out.close();
 } catch (IOException e) {
 // ignore
 }
 }
 }
 }
 } else {
 /*
 * For whatever reason we cannot write the
 * file to disk.
 */
 throw new FileUploadException(
 "Cannot write uploaded file to disk!");
 }
 }
 }
```
- 如上所示，依然是對DeferredFileOutputStream物件的操作，如果資料在記憶體中，就寫入到指定檔案，否則就嘗試將臨時檔案rename為指定檔案，如果rename失敗，就會讀取臨時檔案的二進位制流，再寫到指定檔案上去；

- 另外，DiskFileItem中出現的cachedContent物件，其本身也就是DeferredFileOutputStream的記憶體資料；

- 至此，第三個疑問也解開了：- 上傳的檔案如果小於指定的閾值，就會被儲存在記憶體中，否則就存在磁碟上，留給業務程式碼用，業務程式碼在使用時透過CommonsMultipartFile物件來操作；

- 似乎又有一個疑問了：這些臨時檔案存在記憶體或者磁碟上，什麼時候清理呢，不清理豈不是越來越多？

- 在DispatcherServlet.doDispatch方法中，有這麼一段：
```java
finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				return;
			}
			// Clean up any resources used by a multipart request.
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
```
- 關鍵程式碼是cleanupMultipart(processedRequest);，進去跟蹤發現會呼叫CommonsFileUploadSupport.cleanupFileItems方法，最終呼叫DiskFileItem.delete方法，將臨時檔案清理掉；

- 至此SpringMVC原始碼分析就結束了，接下來列出一些web應用的原始碼，作為可能用到的參考資訊；

### demo原始碼下載
- 文中提到的demo工程，您可以在GitHub下載，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個目錄，本次所需的資源放在springmvcfileserver，如下圖紅框所示：
![這裡寫圖片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTgwMjI2MTcwOTQ1Nzcx?x-oss-process=image/format,png)

- 如果您想了解如何POST二進位制檔案到服務端，請下載uploadfileclient這個資料夾下的客戶端demo工程，如下圖紅框所示：
![這裡寫圖片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTgwMjI2MTcxMjE5NDI4?x-oss-process=image/format,png)
- 如果您不想讓SpringMVC處理上傳的檔案，而是自己去呼叫apache的commons-fileupload庫來做些更復雜的操作，您可以參考fileserverdemo這個資料夾下的demo工程，如下圖紅框所示：
![這裡寫圖片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTgwMjI2MTcxNTI3OTY0?x-oss-process=image/format,png)
- 如果您的應用是基於springboot的，實現檔案服務可以參考springbootfileserver這個資料夾下的demo工程，如下圖紅框所示：
![這裡寫圖片描述](https://imgconvert.csdnimg.cn/aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTgwMjI2MTcxODE0NDU3?x-oss-process=image/format,png)

- 至此，本次閱讀和分析實戰已全部完成，在您學習和理解SpringMVC框架的過程中，希望本文能對您有所幫助，如果發現文中有錯誤，也真誠的期待您能留下意見；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)</fileitem></fileitem></fileitem></fileitem>

SpringMVC原始碼分析：POST請求中的檔案處理

相關文章