文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

什么年代了，你还不知道 Servlet3.0 中的文件上传方式？

2024-12-03 06:26

关注

其实文件上传这块松哥之前和大家聊过很多次了，这次因为最近正在进行 SpringMVC 的源码分析，所以又再次把这个话题拉出来“鞭尸”，不过这次松哥想从源码角度来聊聊这个话题。

理解源码的前提是先会用，所以我们还是先来看看用法，然后再来分析源码。

1.两种文件解析方案

对于上传文件的请求，SpringMVC 中目前共有两种不同的解析方案：

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。

配置方式如下：

  1.  
  2.     name>springmvcname> 
  3.     org.springframework.web.servlet.DispatcherServlet
  4.      
  5.         name>contextConfigLocationname> 
  6.         classpath:spring-servlet.xml 
  7.      
  8.      
  9.         /tmp 
  10.         <max-file-size>1024max-file-size> 
  11.         <max-request-size>10240max-request-size> 
  12.      
  13.  
  14.  
  15.     name>springmvcname> 
  16.     / 
  17.  

然后在 SpringMVC 的配置文件中提供一个 StandardServletMultipartResolver 实例，注意该实例的 id 必须为 multipartResolver(具体原因参见：SpringMVC 初始化流程分析一文)。

  1. "org.springframework.web.multipart.support.StandardServletMultipartResolver" id="multipartResolver"> 
  2.  

配置完成后，我们就可以开发一个文件上传接口了，如下：

  1. @RestController 
  2. public class FileUploadController { 
  3.     SimpleDateFormat sdf = new SimpleDateFormat("/yyyy/MM/dd/"); 
  4.  
  5.     @PostMapping("/upload") 
  6.     public String fileUpload(MultipartFile file, HttpServletRequest req) { 
  7.         String format = sdf.format(new Date()); 
  8.         String realPath = req.getServletContext().getRealPath("/img") + format; 
  9.         File folder = new File(realPath); 
  10.         if (!folder.exists()) { 
  11.             folder.mkdirs(); 
  12.         } 
  13.         String oldName = file.getOriginalFilename(); 
  14.         String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf(".")); 
  15.         try { 
  16.             file.transferTo(new File(folder, newName)); 
  17.             return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName; 
  18.         } catch (IOException e) { 
  19.             e.printStackTrace(); 
  20.         } 
  21.         return "error"; 
  22.     } 
  23.  
  24.     @PostMapping("/upload2") 
  25.     public String fileUpload2(HttpServletRequest req) throws IOException, ServletException { 
  26.         StandardServletMultipartResolver resolver = new StandardServletMultipartResolver(); 
  27.         MultipartFile file = resolver.resolveMultipart(req).getFile("file"); 
  28.         String format = sdf.format(new Date()); 
  29.         String realPath = req.getServletContext().getRealPath("/img") + format; 
  30.         File folder = new File(realPath); 
  31.         if (!folder.exists()) { 
  32.             folder.mkdirs(); 
  33.         } 
  34.         String oldName = file.getOriginalFilename(); 
  35.         String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf(".")); 
  36.         try { 
  37.             file.transferTo(new File(folder, newName)); 
  38.             return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName; 
  39.         } catch (IOException e) { 
  40.             e.printStackTrace(); 
  41.         } 
  42.         return "error"; 
  43.     } 
  44.  
  45.     @PostMapping("/upload3") 
  46.     public String fileUpload3(HttpServletRequest req) throws IOException, ServletException { 
  47.         String other_param = req.getParameter("other_param"); 
  48.         System.out.println("other_param = " + other_param); 
  49.         String format = sdf.format(new Date()); 
  50.         String realPath = req.getServletContext().getRealPath("/img") + format; 
  51.         File folder = new File(realPath); 
  52.         if (!folder.exists()) { 
  53.             folder.mkdirs(); 
  54.         } 
  55.         Part filePart = req.getPart("file"); 
  56.         String oldName = filePart.getSubmittedFileName(); 
  57.         String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf(".")); 
  58.         try { 
  59.             filePart.write(realPath + newName); 
  60.             return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName; 
  61.         } catch (IOException e) { 
  62.             e.printStackTrace(); 
  63.         } 
  64.         return "error"; 
  65.     } 
  66. } 

我这里一共提供了三个文件上传接口，其实最终都是通过 StandardServletMultipartResolver 进行处理的。

  1. 第一个接口是我们在 SpringMVC 框架中常见的一种文件上传处理方式，直接在参数中写上 MultipartFile，这个 MultipartFile 其实就是从当前请求中解析出来的，具体负责参数解析工作的就是 RequestParamMethodArgumentResolver。
  2. 第二个接口其实是一种古老的文件上传实现方案，参数就是普通的 HttpServletRequest，然后在参数里边，我们再手动利用 StandardServletMultipartResolver 实例进行解析(这种情况可以不用自己 new 一个 StandardServletMultipartResolver 实例，直接将 Spring 容器中的注入进来即可)。
  3. 第三个接口我们就利用了 Servlet3.0 的 API，调用 getPart 获取文件，然后再调用对象的 write 方法将文件写出去即可。

大致上一看，感觉办法还挺多，其实仔细看，万变不离其宗，一会我们看完源码，相信小伙伴们还能变化出更多写法。

CommonsMultipartResolver

CommonsMultipartResolver 估计很多人都比较熟悉，这个兼容性很好，就是有点过时了。使用 CommonsMultipartResolver 需要我们首先引入 commons-fileupload 依赖：

  1.  
  2.     commons-fileupload 
  3.     commons-fileupload 
  4.     1.4 
  5.  

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

  1. "org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">--> 
  2.  

接下来开发文件上传接口就行了：

  1. @PostMapping("/upload") 
  2. public String fileUpload(MultipartFile file, HttpServletRequest req) { 
  3.     String format = sdf.format(new Date()); 
  4.     String realPath = req.getServletContext().getRealPath("/img") + format; 
  5.     File folder = new File(realPath); 
  6.     if (!folder.exists()) { 
  7.         folder.mkdirs(); 
  8.     } 
  9.     String oldName = file.getOriginalFilename(); 
  10.     String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf(".")); 
  11.     try { 
  12.         file.transferTo(new File(folder, newName)); 
  13.         return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName; 
  14.     } catch (IOException e) { 
  15.         e.printStackTrace(); 
  16.     } 
  17.     return "error"; 
  18. } 

这个就没啥好说，比较容易。

文件上传这块松哥之前在视频中也和大家分享过，公号后台回复 ssm 可以查看视频详情。

用法掌握了，接下来我们来看原理。

2.StandardServletMultipartResolver

不废话，直接来看看源码：

  1. public class StandardServletMultipartResolver implements MultipartResolver { 
  2.  private boolean resolveLazily = false; 
  3.  public void setResolveLazily(boolean resolveLazily) { 
  4.   this.resolveLazily = resolveLazily; 
  5.  } 
  6.  @Override 
  7.  public boolean isMultipart(HttpServletRequest request) { 
  8.   return StringUtils.startsWithIgnoreCase(request.getContentType(), "multipart/"); 
  9.  } 
  10.  @Override 
  11.  public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException { 
  12.   return new StandardMultipartHttpServletRequest(request, this.resolveLazily); 
  13.  } 
  14.  @Override 
  15.  public void cleanupMultipart(MultipartHttpServletRequest request) { 
  16.   if (!(request instanceof AbstractMultipartHttpServletRequest) || 
  17.     ((AbstractMultipartHttpServletRequest) request).isResolved()) { 
  18.    try { 
  19.     for (Part part : request.getParts()) { 
  20.      if (request.getFile(part.getName()) != null) { 
  21.       part.delete(); 
  22.      } 
  23.     } 
  24.    } 
  25.    catch (Throwable ex) { 
  26.    } 
  27.   } 
  28.  } 
  29.  
  30. } 

这里满打满算就四个方法，其中一个还是 set 方法，我们来看另外三个功能性方法：

isMultipart：这个方法主要是用来判断当前请求是不是文件上传请求，这里的判断思路很简单，就看请求的 content-type 是不是以 multipart/ 开头，如果是，则这就是一个文件上传请求，否则就不是文件上传请求。

resolveMultipart：这个方法负责将当前请求封装一个 StandardMultipartHttpServletRequest 对象然后返回。

cleanupMultipart：这个方法负责善后，主要完成了缓存的清理工作。

在这个过程中涉及到 StandardMultipartHttpServletRequest 对象，我们也来稍微说一下：

  1. public StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing) 
  2.   throws MultipartException { 
  3.  super(request); 
  4.  if (!lazyParsing) { 
  5.   parseRequest(request); 
  6.  } 
  7. } 
  8. private void parseRequest(HttpServletRequest request) { 
  9.  try { 
  10.   Collection parts = request.getParts(); 
  11.   this.multipartParameterNames = new LinkedHashSet<>(parts.size()); 
  12.   MultiValueMap files = new LinkedMultiValueMap<>(parts.size()); 
  13.   for (Part part : parts) { 
  14.    String headerValue = part.getHeader(HttpHeaders.CONTENT_DISPOSITION); 
  15.    ContentDisposition disposition = ContentDisposition.parse(headerValue); 
  16.    String filename = disposition.getFilename(); 
  17.    if (filename != null) { 
  18.     if (filename.startsWith("=?") && filename.endsWith("?=")) { 
  19.      filename = MimeDelegate.decode(filename); 
  20.     } 
  21.     files.add(part.getName(), new StandardMultipartFile(part, filename)); 
  22.    } 
  23.    else { 
  24.     this.multipartParameterNames.add(part.getName()); 
  25.    } 
  26.   } 
  27.   setMultipartFiles(files); 
  28.  } 
  29.  catch (Throwable ex) { 
  30.   handleParseFailure(ex); 
  31.  } 
  32. } 

StandardMultipartHttpServletRequest 对象在构建的过程中，会自动进行请求解析，调用 getParts 方法获取所有的项，然后进行判断，将文件和普通参数分别保存下来备用。

这块的逻辑比较简单。

3.CommonsMultipartResolver

再来看 CommonsMultipartResolver。

先来看它的 isMultipart 方法：

  1. @Override 
  2. public boolean isMultipart(HttpServletRequest request) { 
  3.  return ServletFileUpload.isMultipartContent(request); 
  4. } 
  5. public static final boolean isMultipartContent( 
  6.         HttpServletRequest request) { 
  7.     if (!POST_METHOD.equalsIgnoreCase(request.getMethod())) { 
  8.         return false; 
  9.     } 
  10.     return FileUploadBase.isMultipartContent(new ServletRequestContext(request)); 
  11. } 

ServletFileUpload.isMultipartContent 方法其实就在我们引入的 commons-fileupload 包中。它的判断逻辑分两步：首先检查是不是 POST 请求，然后检查 content-type 是不是以 multipart/ 开始。

再来看它的 resolveMultipart 方法：

  1. @Override 
  2. public MultipartHttpServletRequest resolveMultipart(final HttpServletRequest request) throws MultipartException { 
  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.     setMultipartParameterContentTypes(parsingResult.getMultipartParameterContentTypes()); 
  11.    } 
  12.   }; 
  13.  } 
  14.  else { 
  15.   MultipartParsingResult parsingResult = parseRequest(request); 
  16.   return new DefaultMultipartHttpServletRequest(request, parsingResult.getMultipartFiles(), 
  17.     parsingResult.getMultipartParameters(), parsingResult.getMultipartParameterContentTypes()); 
  18.  } 
  19. } 

根据 resolveLazily 属性值，选择两种不同的策略将当前对象重新构建成一个 DefaultMultipartHttpServletRequest 对象。如果 resolveLazily 为 true，则在 initializeMultipart 方法中进行请求解析，否则先解析，再构建 DefaultMultipartHttpServletRequest 对象。

具体的解析方法如下：

  1. protected MultipartParsingResult parseRequest(HttpServletRequest request) throws MultipartException { 
  2.  String encoding = determineEncoding(request); 
  3.  FileUpload fileUpload = prepareFileUpload(encoding); 
  4.  try { 
  5.   List fileItems = ((ServletFileUpload) fileUpload).parseRequest(request); 
  6.   return parseFileItems(fileItems, encoding); 
  7.  } 
  8.  catch (FileUploadBase.SizeLimitExceededException ex) { 
  9.   //... 
  10.  } 
  11. } 
  12. protected MultipartParsingResult parseFileItems(List fileItems, String encoding) { 
  13.  MultiValueMap multipartFiles = new LinkedMultiValueMap<>(); 
  14.  Map multipartParameters = new HashMap<>(); 
  15.  Map multipartParameterContentTypes = new HashMap<>(); 
  16.  for (FileItem fileItem : fileItems) { 
  17.   if (fileItem.isFormField()) { 
  18.    String value; 
  19.    String partEncoding = determineEncoding(fileItem.getContentType(), encoding); 
  20.    try { 
  21.     value = fileItem.getString(partEncoding); 
  22.    } 
  23.    catch (UnsupportedEncodingException ex) { 
  24.     value = fileItem.getString(); 
  25.    } 
  26.    String[] curParam = multipartParameters.get(fileItem.getFieldName()); 
  27.    if (curParam == null) { 
  28.     multipartParameters.put(fileItem.getFieldName(), new String[] {value}); 
  29.    } 
  30.    else { 
  31.     String[] newParam = StringUtils.addStringToArray(curParam, value); 
  32.     multipartParameters.put(fileItem.getFieldName(), newParam); 
  33.    } 
  34.    multipartParameterContentTypes.put(fileItem.getFieldName(), fileItem.getContentType()); 
  35.   } 
  36.   else { 
  37.    CommonsMultipartFile file = createMultipartFile(fileItem); 
  38.    multipartFiles.add(file.getName(), file); 
  39.   } 
  40.  } 
  41.  return new MultipartParsingResult(multipartFiles, multipartParameters, multipartParameterContentTypes); 
  42. } 

这里的解析就是首先获取到 FileItem 集合，然后调用 parseFileItems 方法进行进一步的解析。在进一步的解析中，会首先判断这是文件还是普通参数，如果是普通参数，则保存到 multipartParameters 中，具体保存过程中还会判断是否为数组，然后再将参数的 ContentType 保存到 multipartParameterContentTypes 中，文件则保存到 multipartFiles 中，最后由三个 Map 构成一个 MultipartParsingResult 对象并返回。

至此，StandardServletMultipartResolver 和 CommonsMultipartResolver 源码就和大家说完了，可以看到，还是比较容易的。

4.解析流程

最后，我们再来梳理一下解析流程。

以如下接口为例(因为在实际开发中一般都是通过如下方式上传文件)：

  1. @PostMapping("/upload") 
  2. public String fileUpload(MultipartFile file, HttpServletRequest req) { 
  3.     String format = sdf.format(new Date()); 
  4.     String realPath = req.getServletContext().getRealPath("/img") + format; 
  5.     File folder = new File(realPath); 
  6.     if (!folder.exists()) { 
  7.         folder.mkdirs(); 
  8.     } 
  9.     String oldName = file.getOriginalFilename(); 
  10.     String newName = UUID.randomUUID().toString() + oldName.substring(oldName.lastIndexOf(".")); 
  11.     try { 
  12.         file.transferTo(new File(folder, newName)); 
  13.         return req.getScheme() + "://" + req.getRemoteHost() + ":" + req.getServerPort() + "/img" + format + newName; 
  14.     } catch (IOException e) { 
  15.         e.printStackTrace(); 
  16.     } 
  17.     return "error"; 
  18. } 

这里 MultipartFile 对象主要就是在参数解析器中获取的，关于参数解析器，大家可以参考：深入分析 SpringMVC 参数解析器 一文，这里涉及到的参数解析器是 RequestParamMethodArgumentResolver。

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

  1. if (servletRequest != null) { 
  2.  Object mpArg = MultipartResolutionDelegate.resolveMultipartArgument(name, parameter, servletRequest); 
  3.  if (mpArg != MultipartResolutionDelegate.UNRESOLVABLE) { 
  4.   return mpArg; 
  5.  } 
  6. } 

这个方法会进行请求解析，返回 MultipartFile 对象或者 MultipartFile 数组。

  1. @Nullable 
  2. public static Object resolveMultipartArgument(String name, MethodParameter parameter, HttpServletRequest request) 
  3.   throws Exception { 
  4.  MultipartHttpServletRequest multipartRequest = 
  5.    WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class); 
  6.  boolean isMultipart = (multipartRequest != null || isMultipartContent(request)); 
  7.  if (MultipartFile.class == parameter.getNestedParameterType()) { 
  8.   if (!isMultipart) { 
  9.    return null; 
  10.   } 
  11.   if (multipartRequest == null) { 
  12.    multipartRequest = new StandardMultipartHttpServletRequest(request); 
  13.   } 
  14.   return multipartRequest.getFile(name); 
  15.  } 
  16.  else if (isMultipartFileCollection(parameter)) { 
  17.   if (!isMultipart) { 
  18.    return null; 
  19.   } 
  20.   if (multipartRequest == null) { 
  21.    multipartRequest = new StandardMultipartHttpServletRequest(request); 
  22.   } 
  23.   List files = multipartRequest.getFiles(name); 
  24.   return (!files.isEmpty() ? files : null); 
  25.  } 
  26.  else if (isMultipartFileArray(parameter)) { 
  27.   if (!isMultipart) { 
  28.    return null; 
  29.   } 
  30.   if (multipartRequest == null) { 
  31.    multipartRequest = new StandardMultipartHttpServletRequest(request); 
  32.   } 
  33.   List files = multipartRequest.getFiles(name); 
  34.   return (!files.isEmpty() ? files.toArray(new MultipartFile[0]) : null); 
  35.  } 
  36.  else if (Part.class == parameter.getNestedParameterType()) { 
  37.   if (!isMultipart) { 
  38.    return null; 
  39.   } 
  40.   return request.getPart(name); 
  41.  } 
  42.  else if (isPartCollection(parameter)) { 
  43.   if (!isMultipart) { 
  44.    return null; 
  45.   } 
  46.   List parts = resolvePartList(request, name); 
  47.   return (!parts.isEmpty() ? parts : null); 
  48.  } 
  49.  else if (isPartArray(parameter)) { 
  50.   if (!isMultipart) { 
  51.    return null; 
  52.   } 
  53.   List parts = resolvePartList(request, name); 
  54.   return (!parts.isEmpty() ? parts.toArray(new Part[0]) : null); 
  55.  } 
  56.  else { 
  57.   return UNRESOLVABLE; 
  58.  } 
  59. } 

首先获取 multipartRequest 对象，然后再从中获取文件或者文件数组。如果我们使用 StandardServletMultipartResolver 做文件上传，这里获取到的 multipartRequest 就是 StandardMultipartHttpServletRequest;如果我们使用 CommonsMultipartResolver 做文件上传，这里获取到的 multipartRequest 就是 DefaultMultipartHttpServletRequest。

 

来源： 江南一点雨内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

什么年代了，你还不知道 Servlet3.0 中的文件上传方式？

后端开发ServletSpringMVC2024-12-03
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯