天我們從源碼角度來聊聊這個話題。

理解源碼的前提是先會用，所以我們還是先來看看用法，然后再來分析源碼。

1.兩種文件解析方案

對于上傳文件的請求，SpringMVC 中目前共有兩種不同的解析方案：

• StandardServletMultipartResolver
• CommonsMultipartResolver

StandardServletMultipartResolver 支持 Servlet3.0 中標準的文件上傳方案，使用非常簡單；CommonsMultipartResolver 則需要結合 Apache Commons fileupload 組件一起使用，這種方式兼容低版本的 Servlet。

StandardServletMultipartResolver

先來回顧下 StandardServletMultipartResolver 的用法。

使用 StandardServletMultipartResolver，可以直接通過 HttpServletRequest 自帶的 getPart 方法獲取上傳文件并保存，這是一種標準的操作方式，這種方式也不用添加任何額外的依賴，只需要確保 Servlet 的版本在 3.0 之上即可。

首先我們需要為 Servlet 配置 multipart-config，哪個 Servlet 負責處理上傳文件，就為哪個 Servlet 配置 multipart-config。在 SpringMVC 中，我們的請求都是通過 DispatcherServlet 進行分發的，所以我們就為 DispatcherServlet 配置 multipart-config。

配置方式如下：

<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</serv
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-servlet.xml</param-value>
    </init-param>
    <multipart-config>
        <location>/tmp</location>
        <max-file-size>1024</max-file-size>
        <max-request-size>10240</max-request-size>
    </multipart-config>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

然后在 SpringMVC 的配置文件中提供一個 StandardServletMultipartResolver 實例，注意該實例的 id 必須為 multipartResolver

<bean class="org.springframework.web.multipart.support.StandardServletMultipartResolver" id="multipartResolver">
</bean>

配置完成后，我們就可以開發一個文件上傳接口了，如下：

@RestController
public class FileUploadController {
    SimpleDateFormat sdf = new SimpleDateFormat("/yyyy/MM/dd/");

    @PostMapping("/upload")
    public String fileUpload(MultipartFile file, HttpServletRequest req) {
        String format = sdf.format(new Date());
        String realPath = req.getServletContext().getRealPath("/img") + format;
        File folder = new File(realPath);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        String oldName = file.getOriginalFilename();
        String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf("."));
        try {
            file.transferTo(new File(folder, newName));
            return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }

    @PostMapping("/upload2")
    public String fileUpload2(HttpServletRequest req) throws IOException, ServletException {
        StandardServletMultipartResolver resolver = new StandardServletMultipartResolver();
        MultipartFile file = resolver.resolveMultipart(req).getFile("file");
        String format = sdf.format(new Date());
        String realPath = req.getServletContext().getRealPath("/img") + format;
        File folder = new File(realPath);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        String oldName = file.getOriginalFilename();
        String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf("."));
        try {
            file.transferTo(new File(folder, newName));
            return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }

    @PostMapping("/upload3")
    public String fileUpload3(HttpServletRequest req) throws IOException, ServletException {
        String other_param = req.getParameter("other_param");
        System.out.println("other_param = " + other_param);
        String format = sdf.format(new Date());
        String realPath = req.getServletContext().getRealPath("/img") + format;
        File folder = new File(realPath);
        if (!folder.exists()) {
            folder.mkdirs();
        }
        Part filePart = req.getPart("file");
        String oldName = filePart.getSubmittedFileName();
        String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf("."));
        try {
            filePart.write(realPath + newName);
            return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "error";
    }
}

我這里一共提供了三個文件上傳接口，其實最終都是通過 StandardServletMultipartResolver 進行處理的。

1. 第一個接口是我們在 SpringMVC 框架中常見的一種文件上傳處理方式，直接在參數中寫上 MultipartFile，這個 MultipartFile 其實就是從當前請求中解析出來的，具體負責參數解析工作的就是 RequestParamMethodArgumentResolver。
2. 第二個接口其實是一種古老的文件上傳實現方案，參數就是普通的 HttpServletRequest，然后在參數里邊，我們再手動利用 StandardServletMultipartResolver 實例進行解析（這種情況可以不用自己 new 一個 StandardServletMultipartResolver 實例，直接將 Spring 容器中的注入進來即可）。
3. 第三個接口我們就利用了 Servlet3.0 的 API，調用 getPart 獲取文件，然后再調用對象的 write 方法將文件寫出去即可。

大致上一看，感覺辦法還挺多，其實仔細看，萬變不離其宗，一會我們看完源碼，相信小伙伴們還能變化出更多寫法。

CommonsMultipartResolver

CommonsMultipartResolver 估計很多人都比較熟悉，這個兼容性很好，就是有點過時了。使用 CommonsMultipartResolver 需要我們首先引入 commons-fileupload 依賴：

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

然后在 SpringMVC 的配置文件中提供 CommonsMultipartResolver 實例，如下：

<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">-->
</bean>

接下來開發文件上傳接口就行了：

@PostMapping("/upload")
public String fileUpload(MultipartFile file, HttpServletRequest req) {
    String format = sdf.format(new Date());
    String realPath = req.getServletContext().getRealPath("/img") + format;
    File folder = new File(realPath);
    if (!folder.exists()) {
        folder.mkdirs();
    }
    String oldName = file.getOriginalFilename();
    String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf("."));
    try {
        file.transferTo(new File(folder, newName));
        return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "error";
}

這個就沒啥好說，比較容易。

用法掌握了，接下來我們來看原理。

2.StandardServletMultipartResolver

不廢話，直接來看看源碼：

public class StandardServletMultipartResolver implements MultipartResolver {
	private boolean resolveLazily = false;
	public void setResolveLazily(boolean resolveLazily) {
		this.resolveLazily = resolveLazily;
	}
	@Override
	public boolean isMultipart(HttpServletRequest request) {
		return StringUtils.startsWithIgnoreCase(request.getContentType(), "multipart/");
	}
	@Override
	public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
		return new StandardMultipartHttpServletRequest(request, this.resolveLazily);
	}
	@Override
	public void cleanupMultipart(MultipartHttpServletRequest request) {
		if (!(request instanceof AbstractMultipartHttpServletRequest) ||
				((AbstractMultipartHttpServletRequest) request).isResolved()) {
			try {
				for (Part part : request.getParts()) {
					if (request.getFile(part.getName()) != null) {
						part.delete();
					}
				}
			}
			catch (Throwable ex) {
			}
		}
	}

}

這里滿打滿算就四個方法，其中一個還是 set 方法，我們來看另外三個功能性方法：

1. isMultipart：這個方法主要是用來判斷當前請求是不是文件上傳請求，這里的判斷思路很簡單，就看請求的 content-type 是不是以 multipart/ 開頭，如果是，則這就是一個文件上傳請求，否則就不是文件上傳請求。
2. resolveMultipart：這個方法負責將當前請求封裝一個 StandardMultipartHttpServletRequest 對象然后返回。
3. cleanupMultipart：這個方法負責善后，主要完成了緩存的清理工作。

在這個過程中涉及到 StandardMultipartHttpServletRequest 對象，我們也來稍微說一下：

public StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing)
		throws MultipartException {
	super(request);
	if (!lazyParsing) {
		parseRequest(request);
	}
}
private void parseRequest(HttpServletRequest request) {
	try {
		Collection<Part> parts = request.getParts();
		this.multipartParameterNames = new LinkedHashSet<>(parts.size());
		MultiValueMap<String, MultipartFile> files = new LinkedMultiValueMap<>(parts.size());
		for (Part part : parts) {
			String headerValue = part.getHeader(HttpHeaders.CONTENT_DISPOSITION);
			ContentDisposition disposition = ContentDisposition.parse(headerValue);
			String filename = disposition.getFilename();
			if (filename != null) {
				if (filename.startsWith("=?") && filename.endsWith("?=")) {
					filename = MimeDelegate.decode(filename);
				}
				files.add(part.getName(), new StandardMultipartFile(part, filename));
			}
			else {
				this.multipartParameterNames.add(part.getName());
			}
		}
		setMultipartFiles(files);
	}
	catch (Throwable ex) {
		handleParseFailure(ex);
	}
}

StandardMultipartHttpServletRequest 對象在構建的過程中，會自動進行請求解析，調用 getParts 方法獲取所有的項，然后進行判斷，將文件和普通參數分別保存下來備用。

這塊的邏輯比較簡單。

3.CommonsMultipartResolver

再來看 CommonsMultipartResolver。

先來看它的 isMultipart 方法：

@Override
public boolean isMultipart(HttpServletRequest request) {
	return ServletFileUpload.isMultipartContent(request);
}
public static final boolean isMultipartContent(
        HttpServletRequest request) {
    if (!POST_METHOD.equalsIgnoreCase(request.getMethod())) {
        return false;
    }
    return FileUploadBase.isMultipartContent(new ServletRequestContext(request));
}

ServletFileUpload.isMultipartContent 方法其實就在我們引入的 commons-fileupload 包中。它的判斷邏輯分兩步：首先檢查是不是 POST 請求，然后檢查 content-type 是不是以 multipart/ 開始。

再來看它的 resolveMultipart 方法：

@Override
public MultipartHttpServletRequest resolveMultipart(final HttpServletRequest request) throws MultipartException {
	if (this.resolveLazily) {
		return new DefaultMultipartHttpServletRequest(request) {
			@Override
			protected void initializeMultipart() {
				MultipartParsingResult parsingResult = parseRequest(request);
				setMultipartFiles(parsingResult.getMultipartFiles());
				setMultipartParameters(parsingResult.getMultipartParameters());
				setMultipartParameterContentTypes(parsingResult.getMultipartParameterContentTypes());
			}
		};
	}
	else {
		MultipartParsingResult parsingResult = parseRequest(request);
		return new DefaultMultipartHttpServletRequest(request, parsingResult.getMultipartFiles(),
				parsingResult.getMultipartParameters(), parsingResult.getMultipartParameterContentTypes());
	}
}

根據 resolveLazily 屬性值，選擇兩種不同的策略將當前對象重新構建成一個 DefaultMultipartHttpServletRequest 對象。如果 resolveLazily 為 true，則在 initializeMultipart 方法中進行請求解析，否則先解析，再構建 DefaultMultipartHttpServletRequest 對象。

具體的解析方法如下：

protected MultipartParsingResult parseRequest(HttpServletRequest request) throws MultipartException {
	String encoding = determineEncoding(request);
	FileUpload fileUpload = prepareFileUpload(encoding);
	try {
		List<FileItem> fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);
		return parseFileItems(fileItems, encoding);
	}
	catch (FileUploadBase.SizeLimitExceededException ex) {
		//...
	}
}
protected MultipartParsingResult parseFileItems(List<FileItem> fileItems, String encoding) {
	MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<>();
	Map<String, String[]> multipartParameters = new HashMap<>();
	Map<String, String> multipartParameterContentTypes = new HashMap<>();
	for (FileItem fileItem : fileItems) {
		if (fileItem.isFormField()) {
			String value;
			String partEncoding = determineEncoding(fileItem.getContentType(), encoding);
			try {
				value = fileItem.getString(partEncoding);
			}
			catch (UnsupportedEncodingException ex) {
				value = fileItem.getString();
			}
			String[] curParam = multipartParameters.get(fileItem.getFieldName());
			if (curParam == null) {
				multipartParameters.put(fileItem.getFieldName(), new String[] {value});
			}
			else {
				String[] newParam = StringUtils.addStringToArray(curParam, value);
				multipartParameters.put(fileItem.getFieldName(), newParam);
			}
			multipartParameterContentTypes.put(fileItem.getFieldName(), fileItem.getContentType());
		}
		else {
			CommonsMultipartFile file = createMultipartFile(fileItem);
			multipartFiles.add(file.getName(), file);
		}
	}
	return new MultipartParsingResult(multipartFiles, multipartParameters, multipartParameterContentTypes);
}

這里的解析就是首先獲取到 FileItem 集合，然后調用 parseFileItems 方法進行進一步的解析。在進一步的解析中，會首先判斷這是文件還是普通參數，如果是普通參數，則保存到 multipartParameters 中，具體保存過程中還會判斷是否為數組，然后再將參數的 ContentType 保存到 multipartParameterContentTypes 中，文件則保存到 multipartFiles 中，最后由三個 Map 構成一個 MultipartParsingResult 對象并返回。

至此，StandardServletMultipartResolver 和 CommonsMultipartResolver 源碼就和大家說完了，可以看到，還是比較容易的。

4.解析流程

最后，我們再來梳理一下解析流程。

以如下接口為例（因為在實際開發中一般都是通過如下方式上傳文件）：

@PostMapping("/upload")
public String fileUpload(MultipartFile file, HttpServletRequest req) {
    String format = sdf.format(new Date());
    String realPath = req.getServletContext().getRealPath("/img") + format;
    File folder = new File(realPath);
    if (!folder.exists()) {
        folder.mkdirs();
    }
    String oldName = file.getOriginalFilename();
    String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf("."));
    try {
        file.transferTo(new File(folder, newName));
        return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return "error";
}

這里 MultipartFile 對象主要就是在參數解析器中獲取的，這里涉及到的參數解析器是 RequestParamMethodArgumentResolver。

在 RequestParamMethodArgumentResolver#resolveName 方法中有如下一行代碼：

if (servletRequest != null) {
	Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest);
	if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) {
		return mpArg;
	}
}

這個方法會進行請求解析，返回 MultipartFile 對象或者 MultipartFile 數組。

@Nullable
public static Object resolveMultipartArgument(String name, MethodParameter parameter, HttpServletRequest request)
		throws Exception {
	MultipartHttpServletRequest multipartRequest =
			WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
	boolean isMultipart = (multipartRequest != null || isMultipartContent(request));
	if (MultipartFile.class == parameter.getNestedParameterType()) {
		if (!isMultipart) {
			return null;
		}
		if (multipartRequest == null) {
			multipartRequest = new StandardMultipartHttpServletRequest(request);
		}
		return multipartRequest.getFile(name);
	}
	else if (isMultipartFileCollection(parameter)) {
		if (!isMultipart) {
			return null;
		}
		if (multipartRequest == null) {
			multipartRequest = new StandardMultipartHttpServletRequest(request);
		}
		List<MultipartFile> files = multipartRequest.getFiles(name);
		return (!files.isEmpty() ? files : null);
	}
	else if (isMultipartFileArray(parameter)) {
		if (!isMultipart) {
			return null;
		}
		if (multipartRequest == null) {
			multipartRequest = new StandardMultipartHttpServletRequest(request);
		}
		List<MultipartFile> files = multipartRequest.getFiles(name);
		return (!files.isEmpty() ? files.toArray(new MultipartFile[0]) : null);
	}
	else if (Part.class == parameter.getNestedParameterType()) {
		if (!isMultipart) {
			return null;
		}
		return request.getPart(name);
	}
	else if (isPartCollection(parameter)) {
		if (!isMultipart) {
			return null;
		}
		List<Part> parts = resolvePartList(request, name);
		return (!parts.isEmpty() ? parts : null);
	}
	else if (isPartArray(parameter)) {
		if (!isMultipart) {
			return null;
		}
		List<Part> parts = resolvePartList(request, name);
		return (!parts.isEmpty() ? parts.toArray(new Part[0]) : null);
	}
	else {
		return UNRESOLVABLE;
	}
}

首先獲取 multipartRequest 對象，然后再從中獲取文件或者文件數組。如果我們使用 StandardServletMultipartResolver 做文件上傳，這里獲取到的 multipartRequest 就是 StandardMultipartHttpServletRequest；如果我們使用 CommonsMultipartResolver 做文件上傳，這里獲取到的 multipartRequest 就是 DefaultMultipartHttpServletRequest。

2021最新完整面試題及答案（都整理成文檔），有很多干貨，包含mysql，netty，spring，線程，spring cloud、JVM、源碼、算法等詳細講解，詳細的學習規劃圖等學習資料，私信我：Java 獲取