SpringMVC 之文件上传 MultipartResolver

基于前面文章的基础上。

一、准备

需要的jar


 二、配置

1、  spmvc-servlet.xml

Xml代码  

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:mvc="http://www.springframework.org/schema/mvc"
  6. xmlns:util="http://www.springframework.org/schema/util"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans
  9. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  10. http://www.springframework.org/schema/context
  11. http://www.springframework.org/schema/context/spring-context-3.0.xsd
  12. http://www.springframework.org/schema/mvc
  13. http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
  14. http://www.springframework.org/schema/util
  15. http://www.springframework.org/schema/util/spring-util-3.0.xsd">
  16. <!-- 默认的注解映射的支持 ,它会自动注册DefaultAnnotationHandlerMapping 与AnnotationMethodHandlerAdapter-->
  17. <mvc:annotation-driven />
  18. <!-- 自动扫描注解的Controller -->
  19. <context:component-scan base-package="com.wy.controller" />
  20. <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />
  21. <!-- 映射处理器 -->
  22. <bean id="simpleUrlMapping"
  23. class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  24. <property name="mappings">
  25. <props>
  26. <prop key="/fileUploadController.do">fileUploadController</prop>
  27. </props>
  28. </property>
  29. </bean>
  30. <!-- ParameterMethodNameResolver 解析请求参数，并将它匹配Controller中的方法名 -->
  31. <bean id="parameterMethodNameResolver"
  32. class="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolver">
  33. <property name="paramName" value="action" />
  34. </bean>
  35. <bean id="fileUploadController"
  36. class="com.wy.controller.FileUploadController">
  37. <property name="methodNameResolver"
  38. ref="parameterMethodNameResolver">
  39. </property>
  40. </bean>
  41. <!-- 文件上传表单的视图解析器 -->
  42. <bean id="multipartResolver"
  43. class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  44. <!-- one of the properties available; the maximum file size in bytes -->
  45. <property name="maxUploadSize" value="204800" />
  46. </bean>
  47. </beans>

2、Controller

使用两种方式：

一种是基于注解的，另一种传统的方式HttpServletRequest

使用第二种方式时要注意：操作方法中对应的方法参数前两位必须是request,response对象并且都要加上，否则会出现 No request handling method with name ‘insert‘ in class  "ClassName"，页面显示为404错误
这个问题出现在使用多操作控制器情况下，相关的操作方法中对应的方法参数前两位必须是request,response对象，必须要有，否则会报如上异常。

Java代码  

  1. package com.wy.controller;
  2. import java.util.List;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5. import javax.servlet.http.HttpSession;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.util.MultiValueMap;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RequestMethod;
  10. import org.springframework.web.bind.annotation.RequestParam;
  11. import org.springframework.web.multipart.MultipartFile;
  12. import org.springframework.web.multipart.MultipartHttpServletRequest;
  13. import org.springframework.web.servlet.ModelAndView;
  14. import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
  15. @Controller
  16. @RequestMapping("/fileUploadController")
  17. public class FileUploadController extends MultiActionController {
  18. /**
  19. * 1、文件上传
  20. * @param request
  21. * @param response
  22. * @return
  23. */
  24. public ModelAndView uploadFiles(HttpServletRequest request, HttpServletResponse response) {
  25. ModelAndView mav = new ModelAndView();
  26. // 转型为MultipartHttpRequest
  27. MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
  28. // 获得上传的文件（根据前台的name名称得到上传的文件）
  29. MultiValueMap<String, MultipartFile> multiValueMap = multipartRequest.getMultiFileMap();
  30. List<MultipartFile> file = multiValueMap.get("clientFile");
  31. //MultipartFile file = multipartRequest.getFile("clientFile");
  32. if(!file.isEmpty()){
  33. //在这里就可以对file进行处理了，可以根据自己的需求把它存到数据库或者服务器的某个文件夹
  34. System.out.println("================="+file.get(0).getName() + file.get(0).getSize());
  35. }
  36. return mav;
  37. }
  38. /**
  39. *
  40. * @param name
  41. * @param file
  42. * @param session
  43. * @return
  44. */
  45. @RequestMapping(value="/uploadFile", method=RequestMethod.POST)
  46. public String uploadFile(@RequestParam("fileName") String fileName,
  47. @RequestParam("clientFile") MultipartFile clientFile, HttpSession session){
  48. if (!clientFile.isEmpty()) {
  49. //在这里就可以对file进行处理了，可以根据自己的需求把它存到数据库或者服务器的某个文件夹
  50. System.out.println("================="+clientFile.getSize());
  51. }
  52. return "";
  53. }
  54. }

3、视图

upload.jsp

Html代码  

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme() + "://"
  5. + request.getServerName() + ":" + request.getServerPort()
  6. + path + "/";
  7. %>
  8. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  9. <html>
  10. <head>
  11. <title>file upload test</title>
  12. </head>
  13. <body>
  14. <form method="post" action="<%=path %>/fileUploadController/uploadFile" enctype="multipart/form-data">
  15. 文件名: <input type="text" name="fileName" /><br/>
  16. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
  17. <input type="file" name="clientFile" /><br/>
  18. <input type="submit" value="上传文件 "/>
  19. </form>
  20. </body>
  21. </html>

HTML 页面中的表单最初所采用 application/x-www-form-urlencode 编码方式，并不满足文件上传的需要，所以，RFC 1867 在此基础上增加了新的 multipart/form-data 编码方式以支持基于表单的文件上传。通常情况下，按照如下形式声明表单以及表单中的元素：

Html代码  

  1. <form action="..." method="post" enctype="multipart/form-data">
  2. <input type="file" name="tile2upload" />
  3. <input type="submit" value="Upload" />
  4. </form>

客户端浏览器将按照 RFC 1867 所规定的格式，对提交表单内容进行编码，服务器端只需要根据 RFC 1867 规定的格式对请求中的信息进行解码，就可以获得客户端表单提交的数据，包括上传的文件。

既然 RFC 1867 所规定的规则是一定的，所以，我们没有必要每次都根据这一规则分析每一次请求中的信息。既然是通用的逻辑，当然也就有通用的类库，比如早期的 jsp smart upload 和 Oreilly 的 COS 类库，以及现在使用最多的 Commons FileUpload 类库。实际开发中，我们只需要使用这些专门针对表单的文件上传处理类库即可。

在实际基于表单的文件上传功能的时候，Spring MVC 框架底层实际上也是使用了以上几种类库。只不过，通过 org.springframework.web.multipart.MultipartResolver 接口的抽象，Spring MVC 将具体选用哪一种类库的权利留给了我们。

MultipartResolver 位于 HandlerMapping 之前，请求一来就交由它来处理。当 Web 请求到达 DispatcherServlet 并等待处理的时候，DispatcherServlet 首先会检查能否从自的 WebApplicationContext 中找到一个名称为 multipartResolver(由 DispatcherServlet 的常量 MULTIPART_RESOLVER_BEAN_NAME 所决定)的 MultipartResolver 实例。如果能够获得一个 MultipartResolver 的实例，DispatcherServlet 将调用 MultipartResolver 的 isMultipart(request) 方法检查当前 Web 请求是否为 multipart类型。如果是，DispatcherServlet 将调用 MultipartResolver 的 resolveMultipart(request) 方法，对原始 request 进行装饰，并返回一个 MultipartHttpServletRequest 供后继处理流程使用(最初的 HttpServletRequest 被偷梁换柱成了 MultipartHttpServletRequest)，否则，直接返回最初的 HttpServletRequest。来看看 UML 类图： 

        MultipartRequest 毕竟是接口，接口就是接口，总得有人实现。AbstractMultipartHttpServletRequest 这个抽象类持有 MultiValueMap<String, MultipartFile> multipartFiles 这样一个实例变量，有了这个 map，把 MultipartRequest 接口里的方法逐一实现就不是难事了。现在的问题是，multipartFiles 从哪来的？不可能像孙悟空似的从石缝里蹦出来吧。。。。。

再回到 MultipartResolver。MultipartResolver 的 isMultipart(request) 方法好实现，当判断出当前的 request 是 multipart 类型的请求，它将调用 MultipartResolve 的 resolveMultipart(request)。这里的 request 就是原始的 HttpServletRequest 对象，奇迹就出现在这里。以 CommonsMultipartResolver 为例，当调用 resolveMultipart(request) 时，看看它是如何创建 MultipartRequest 的：

Java代码  

  1. public MultipartHttpServletRequest resolveMultipart(final HttpServletRequest request) throws MultipartException {
  2. Assert.notNull(request, "Request must not be null");
  3. if (this.resolveLazily) {
  4. return new DefaultMultipartHttpServletRequest(request) {
  5. @Override
  6. protected void initializeMultipart() {
  7. MultipartParsingResult parsingResult = parseRequest(request);
  8. setMultipartFiles(parsingResult.getMultipartFiles());
  9. setMultipartParameters(parsingResult.getMultipartParameters());
  10. }
  11. };
  12. }
  13. else {
  14. MultipartParsingResult parsingResult = parseRequest(request);
  15. return new DefaultMultipartHttpServletRequest(
  16. request, parsingResult.getMultipartFiles(), parsingResult.getMultipartParameters());
  17. }
  18. }

暂且不管 resolveLazily 为何意。假设 resolveLazily 为 false，我们看 else 的片段。由于是 CommonsMultipartResolver，它的 parseRequest 方法将从原始的 HttpServletRequest 中解析出文件，得到基于 Commons FileUpload API 的 FileItem 对象。Spring 在这里封装了一下，对于 MultipartResolver 而言，它看到的就是 MultipartFile。注意最后的 return，它将构建一个 DefaultMultipartHttpServletRequest，也就是 MultipartRequest。它将 MultipartFile 和 MultipartParameter 作为构造函数的参数传入，在这个构造函数里，有 setMultipartFiles 这句话。这个方法正是 AbstractMultipartHttpServletRequest 里的方法，这样，AbstractMultipartHttpServletRequest 的实例变量 multipartFiles 就有正规来源了吧，即解决了上面我们提到的疑问。然去实现 MultipartRequest 接口里的方法就是轻而易举的事了。

再来看看 resolveLazily。request 被装饰了一下，后续处理上传的文件，通过 multipartRequest.getFile(name) 就可以拿到文件。MultipartRequest 接口里定义的方法全在 AbstractMultipartHttpServletRequest 类里给实现了，而它之所以能实现，因为它持有了 multipartFiles。虽说是实例变量，但拿到该变量，还是要通过方法得到的。我们来看看 AbstractMultipartHttpServletRequest 里是如何得到 multipartFiles 的：

Java代码  

  1. /**
  2. * Obtain the MultipartFile Map for retrieval,
  3. * lazily initializing it if necessary.
  4. * @see #initializeMultipart()
  5. */
  6. protected MultiValueMap<String, MultipartFile> getMultipartFiles() {
  7. if (this.multipartFiles == null) {
  8. initializeMultipart();
  9. }
  10. return this.multipartFiles;
  11. }
  12. /**
  13. * Lazily initialize the multipart request, if possible.
  14. * Only called if not already eagerly initialized.
  15. */
  16. protected void initializeMultipart() {
  17. throw new IllegalStateException("Multipart request not initialized");
  18. }

我们来分析一下以上代码。multipartFiles 会为 null 吗？为什么要做这样的判断？不是之前通过 DefaultMultipartHttpServletRequest 的构造函数传入了吗？这里就是 resolveLazily 的作用了。如果非延迟解析，则的确会通过 DefaultMultipartHttpServletRequest 的构造函数传入 multipartFiles。如果为延迟解析，则不会传入 multipartFiles，那么它当然就有可能为 null 了。multipartFiles 为 null 就会调用 initializeMultipart 来初始化(谁让它延迟呢)。resolveLazily 为 true 时，构造的 DefaultMultipartHttpServletRequest 的对象覆写了 AbstractMultipartHttpServletRequest 的 initializeMultipart 方法，它从原始请求中解析文件。思考一个问题：resolveLazily 为 true，直接构造 DefaultMultipartHttpServletRequest 而不覆写 initializeMultipart 会有什么后果？

我认为，resolveLazily 为 false 时，请求一旦被 MultipartResolver 接手，它就会解析请求中的文件，而不必等待后续 controoler 主动从 MultipartRequest 中 getFile。 resolveLazily 为 true 时，只有等后续的 controller 主动调用 MultipartRequest.getFile 才会从原始请求中解析文件。Spring 这样处理，可能是考虑效率问题吧。也许是 multipart 类型的请求，但后续又不操作文件，就没有在请求一来就做文件解析操作吧。

时间： 2024-08-29 23:54:03

SpringMVC 之文件上传 MultipartResolver的相关文章

springMVC之文件上传id固定multipartResolver

我们先来简单说下springMVC的文件上传原理: 说到文件上传我们第一时间想到的就是MultipartResolver , 当收到请求时 DispatcherServlet 的 checkMultipart() 方法会调用 MultipartResolver 的 isMultipart() 方法判断请求中是否包含文件. 如果请求数据中包含文件,则调用 MultipartResolver 的 resolveMultipart() 方法对请求的数据进行解析, 然后将文件数据解析成 Multipar

SpringMVC单文件上传

最近在看SpringMVC的文件上传部分,其实大多数系统都要涉及到文件上传,以前对于Struts的文件上传功能也做过总结了,今天主要说明一下如何使用SpringMVC进行表单上的文件上传以及多个文件同时上传的步骤. 一.设置配置文件: SpringMVC 用的是 的MultipartFile来进行文件上传 所以我们首先要配置MultipartResolver:用于处理表单中的file [html] view plaincopyprint? <!-- 配置MultipartResolver 用于文

Spring Framework源码（十）：SpringMVC之文件上传

我们这一章讲SpringMVC中文件上传的应用,首先我们还是从DispatcherServlet这个核心分发器开始讲起: processedRequest = checkMultipart(request); 还记得上一章讲doDispatch这个方法时见过的方法吧?现在我们来分析下这个方法的具体解析过程: protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartExcepti

关于SpringMVC的文件上传

关于文件的上传,之前写过2篇文章,基于Struts2框架,下面给出文章链接: <关于Struts2的文件上传>:http://www.cnblogs.com/lichenwei/p/3927964.html <关于Struts2的多文件上传>:http://www.cnblogs.com/lichenwei/p/3928200.html 其实文件上传的原理都是一样的,基于SpringMVC的文件上传实现要比Struts2要来得简单许多. 好了,废话不多说,直接切入主题吧,关于上传原

SpringMVC经典系列-12基于SpringMVC的文件上传---【LinusZhu】

注意:此文章是个人原创,希望有转载需要的朋友们标明文章出处,如果各位朋友们觉得写的还好,就给个赞哈,你的鼓励是我创作的最大动力,LinusZhu在此表示十分感谢,当然文章中如有纰漏,请联系[email protected],敬请朋友们斧正,谢谢. 不知不觉已经把Spring的基础部分讲解完了,所讲述的都是在项目中经常用到的东西,是经得住考验的,接下来的部分主要是要讲述使用SpringMVC进行的文件上传.处理Ajax请求.自定义拦截器功能的实现,不多说了,首先讲解文件上传部分,开始--     

SpringMVC学习--文件上传

简介 文件上传是web开发中常见的需求之一,springMVC将文件上传进行了集成,可以方便快捷的进行开发. springmvc中对多部件类型解析 在 页面form中提交enctype="multipart/form-data"的数据时,需要springmvc对multipart类型的数据进行解析.在springmvc.xml中配置multipart类型解析器. 1 <!-- 文件上传 --> 2 <bean id="multipartResolver&qu

SpringMVC多文件上传实例

后台Conroller import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintWriter; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.util.Date;

Extjs4 + springMVC的文件上传

用springMVC来做项目,如果遇到文件上传,那么一定要用spring自带的文件处理类来处理上传的文件,因为效率实在高过其他的. 从界面传过来的参数,如果设置了值对象,那么可以从值对象里面取出字符串类型的普通参数,如果不这样做,也可以直接从request里面获得,两种方法都可以. 问题是如果值对象里面写了其他类型的变量,妄想像Struts2那样处理,springMVC就会报出400 Bad Request的错误. 在Struts2里面,我们可以定义一个值对象为 public class Ima

SSM框架-SpringMVC 实例文件上传下载

SSM框架-SpringMVC 实例文件上传下载 2017-04-17 09:38 4497人阅读 评论(6) 收藏 举报  分类: java基础(3)  目录(?)[+] 目录(?)[+] 林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 本文详细讲解了SpringMVC实例单文件上传.多文件上传.文件列表显示.文件下载. 本文工程免费下载 一.新建一个Web工程,导入相关的包 springmvc的包+commons-fileupload