• SpringMVC入门宝典（六）SpringMVC文件上传（上）

    目录

    一.原生方式上传

    二.SpringMVC方式上传

    三.上传多文件

    一.原生方式上传

    上传是 Web 工程中很常见的功能， SpringMVC 框架简化了文件上传的代码，我们首先使用 JAVAEE
    原生方式上传文件：
    创建一个子模块
    1
    （1）创建新的 SpringMVC 项目（即上面的子模块），在 web.xml 中将项目从 2.3 改为 3.1 ， 即可默
    认开启 el 表达式 ，修改web.xml内容如下： 
    1. <web-app
    2.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    4.         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5.         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    6.         id="WebApp_ID" version="3.1">
    7.   <display-name>Archetype Created Web Application</display-name>
    8. </web-app>

    并把上个子模块的pom.xml里的依赖和插件复制到这个子模块中。

    pom.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.   <modelVersion>4.0.0</modelVersion>
    6.  
    7.   <groupId>com.first</groupId>
    8.   <artifactId>mvc_demo2</artifactId>
    9.   <version>1.0-SNAPSHOT</version>
    10.   <packaging>war</packaging>
    11.  
    12.   <name>mvc_demo2 Maven Webapp</name>
    13.   <!-- FIXME change it to the project's website -->
    14.   <url>http://www.example.com</url>
    15.  
    16.   <dependencies>
    17.     <!-- Spring核心模块 -->
    18.     <dependency>
    19.       <groupId>org.springframework</groupId>
    20.       <artifactId>spring-context</artifactId>
    21.       <version>5.2.12.RELEASE</version>
    22.     </dependency>
    23.     <!-- SpringWeb模块 -->
    24.     <dependency>
    25.       <groupId>org.springframework</groupId>
    26.       <artifactId>spring-web</artifactId>
    27.       <version>5.2.12.RELEASE</version>
    28.     </dependency>
    29.     <!-- SpringMVC模块 -->
    30.     <dependency>
    31.       <groupId>org.springframework</groupId>
    32.       <artifactId>spring-webmvc</artifactId>
    33.       <version>5.2.12.RELEASE</version>
    34.     </dependency>
    35.     <!-- Servlet -->
    36.     <dependency>
    37.       <groupId>javax.servlet</groupId>
    38.       <artifactId>servlet-api</artifactId>
    39.       <version>2.5</version>
    40.       <!--设为provided使运行时使用tomcat自带的servlet，下面的jsp也是一样-->
    41.       <scope>provided</scope>
    42.     </dependency>
    43.     <!-- JSP -->
    44.     <dependency>
    45.       <groupId>javax.servlet.jsp</groupId>
    46.       <artifactId>jsp-api</artifactId>
    47.       <version>2.0</version>
    48.       <scope>provided</scope>
    49.     </dependency>
    50.     <!-- jackson -->
    51.     <dependency>
    52.       <groupId>com.fasterxml.jackson.core</groupId>
    53.       <artifactId>jackson-core</artifactId>
    54.       <version>2.9.0</version>
    55.     </dependency>
    56.     <dependency>
    57.       <groupId>com.fasterxml.jackson.core</groupId>
    58.       <artifactId>jackson-databind</artifactId>
    59.       <version>2.9.0</version>
    60.     </dependency>
    61.     <dependency>
    62.       <groupId>com.fasterxml.jackson.core</groupId>
    63.       <artifactId>jackson-annotations</artifactId>
    64.       <version>2.9.0</version>
    65.     </dependency>
    66.   </dependencies>
    67.   <build>
    68.     <plugins>
    69.       <!-- tomcat插件 -->
    70.       <plugin>
    71.         <groupId>org.apache.tomcat.maven</groupId>
    72.         <artifactId>tomcat7-maven-plugin</artifactId>
    73.         <version>2.1</version>
    74.         <configuration>
    75.           <port>8080</port>
    76.           <path>/</path>
    77.           <uriEncoding>UTF-8</uriEncoding>
    78.           <server>tomcat7</server>
    79.           <systemProperties>
    80.             <java.util.logging.SimpleFormatter.format>%1$tH:%1$tM:%1$tS %2$s%n%4$s: %5$s%6$s%n
    81.             </java.util.logging.SimpleFormatter.format>
    82.           </systemProperties>
    83.         </configuration>
    84.       </plugin>
    85.     </plugins>
    86.   </build>
    87. </project>

    springmvc.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans
    3.         xmlns="http://www.springframework.org/schema/beans"
    4.         xmlns:mvc="http://www.springframework.org/schema/mvc"
    5.         xmlns:context="http://www.springframework.org/schema/context"
    6.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    7.         xsi:schemaLocation="http://www.springframework.org/schema/beans
    8.         http://www.springframework.org/schema/beans/spring-beans.xsd
    9.         http://www.springframework.org/schema/mvc
    10.         http://www.springframework.org/schema/mvc/spring-mvc.xsd
    11.         http://www.springframework.org/schema/context
    12.         http://www.springframework.org/schema/context/spring-context.xsd">
    13.  
    14.         <!-- 扫描包 -->
    15.         <context:component-scan base-package="com.first"/>
    16.     <!-- 开启SpringMVC注解的支持 -->
    17.     <mvc:annotation-driven ></mvc:annotation-driven>
    18.  
    19.     <!-- 视图解析器 -->
    20.     <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    21.         <!-- 视图前缀 ，因为我放在webapp下，所以前缀是/，如果放在WEB-INF下，value就是/WEB-INF-->
    22.         <property name="prefix" value="/" />
    23.         <!-- 视图后缀 -->
    24.         <property name="suffix" value=".jsp" />
    25.     </bean>
    26.  
    27.     <!-- 放行静态资源 -->
    28.     <mvc:default-servlet-handler />
    29.  
    30. </beans>

    然后web.xml再添加一些上个子工程的一些配置 ，

    1. <web-app
    2.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    4.         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5.         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    6.         id="WebApp_ID" version="3.1">
    7.   <display-name>Archetype Created Web Application</display-name>
    8.  
    9.   <!--SpringMVC中提供的字符编码过滤器，放在所有过滤器的最上方-->
    10.   <filter>
    11.     <filter-name>encFilter</filter-name>
    12.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    13.     <init-param>
    14.       <param-name>encoding</param-name>
    15.       <param-value>utf-8</param-value>
    16.     </init-param>
    17.   </filter>
    18.   <filter-mapping>
    19.     <filter-name>encFilter</filter-name>
    20.     <url-pattern>/*</url-pattern>
    21.   </filter-mapping>
    22.  
    23.   <!-- 请求方式过滤器 -->
    24.   <filter>
    25.     <filter-name>httpMethodFilter</filter-name>
    26.     <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    27.   </filter>
    28.   <filter-mapping>
    29.     <filter-name>httpMethodFilter</filter-name>
    30.     <!--所有路径都过滤-->
    31.     <url-pattern>/*</url-pattern>
    32.   </filter-mapping>
    33.  
    34.   <!--SpringMVC前端控制器，本质是一个Servlet，接收所有请求，再分发到相应路径中，在容器启动时就会加载-->
    35.   <servlet>
    36.     <servlet-name>dispatcherServlet</servlet-name>
    37.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    38.     <init-param>
    39.       <param-name>contextConfigLocation</param-name>
    40.       <!--springMVC配置文件的位置-->
    41.       <param-value>classpath:springmvc.xml</param-value>
    42.     </init-param>
    43.     <!--在web容器创建时，servlet就会被创建好-->
    44.     <load-on-startup>1</load-on-startup>
    45.   </servlet>
    46.   <servlet-mapping>
    47.     <servlet-name>dispatcherServlet</servlet-name>
    48.     <!--接收所有的请求-->
    49.     <url-pattern>/</url-pattern>
    50.   </servlet-mapping>
    51. </web-app>

    （2）编写上传表单

    upload.jsp：

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head>
    4.     <title>上传</title>
    5. </head>
    6. <body>
    7. <h3>文件上传</h3>
    8. <form action="/fileUpload" method="post" enctype="multipart/form-data">
    9.     <%-- 文件上传控件，类型是file --%>
    10.     选择文件:<input type="file" name="upload">
    11.     <input type="submit" value="上传">
    12. </form>
    13. </body>
    14. </html>

    然后如下创建：

    1. package com.first.controller;
    2.  
    3. import org.springframework.stereotype.Controller;
    4. import org.springframework.web.bind.annotation.RequestMapping;
    5.  
    6. import javax.servlet.ServletInputStream;
    7. import javax.servlet.http.HttpServletRequest;
    8.  
    9. @Controller
    10. public class UploadController {
    11.     @RequestMapping("/fileUpload")
    12.     public String upload(HttpServletRequest request) throws Exception {
    13.         // 获取输入流
    14.         ServletInputStream is = request.getInputStream();
    15.         // 从输入流获取请求体数据
    16.         int i = 0;
    17.         while ((i=is.read())!=-1){
    18.             System.out.print((char)i);
    19.         }
    20.         return "index";
    21.     }
    22. }

    访问 http://localhost:8080/upload.jsp

     控制台部分输出如下：

    （3）接收请求体数据：

    接下来需要分析请求体中的文件项，并将数据写入磁盘，此时需要借助文件上传工具
    （1）引入文件上传依赖： 
    1. <!-- 文件上传 -->
    2. <dependency>
    3.     <groupId>commons-fileupload</groupId>
    4.     <artifactId>commonsfileupload</artifactId>
    5.     <version>1.3.1</version>
    6. </dependency> <dependency>
    7.     <groupId>commons-io</groupId>
    8.     <artifactId>commons-io</artifactId>
    9.     <version>2.4</version>
    10. </dependency>
    （2）编写控制器接收上传请求，控制器进行三步操作：
    1. 创建文件夹，存放上传文件。
    2. 分析请求体，找到上传文件数据。
    3. 将文件数据写入文件夹。 
    1. package com.first.controller;
    2.  
    3. import org.apache.commons.fileupload.FileItem;
    4. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    5. import org.apache.commons.fileupload.servlet.ServletFileUpload;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8.  
    9. import javax.servlet.http.HttpServletRequest;
    10. import java.io.File;
    11. import java.util.List;
    12.  
    13. @Controller
    14. public class UploadController {
    15.     //原生上传方式
    16.     @RequestMapping("/fileUpload")
    17.     public String upload(HttpServletRequest request) throws Exception {
    18.         // 创建文件夹，存放上传文件
    19.         // 1.设置上传文件夹的真实路径
    20.         String realPath = request.getSession().getServletContext().getRealPath("/upload");
    21.  
    22.         // 2.判断该目录是否存在，如果不存在，创建该目录
    23.         File file = new File(realPath);
    24.         if(!file.exists()){
    25.             file.mkdirs();
    26.         }
    27.  
    28.         // 分析请求体，找到上传文件数据
    29.         // 1.创建磁盘文件工厂
    30.         DiskFileItemFactory factory = new DiskFileItemFactory();
    31.         // 2.创建上传数据分析器对象
    32.         ServletFileUpload servletFileUpload = new ServletFileUpload(factory);
    33.         // 3.利用分析器对象解析请求体，返回所有数据项
    34.         List<FileItem> fileItems = servletFileUpload.parseRequest(request);
    35.         // 4.遍历所有数据，找到文件项（非表单项）
    36.         for (FileItem fileItem:fileItems){
    37.             if(!fileItem.isFormField()){
    38.                 // 将文件数据写入文件夹
    39.                 // 1.获取文件名
    40.                 String name = fileItem.getName();
    41.                 // 2.将文件写入磁盘
    42.                 fileItem.write(new File(file,name));
    43.                 // 3.删除内存中的临时文件
    44.                 fileItem.delete();
    45.             }
    46.         }
    47.         return "index";
    48.     }
    49. }

    访问http://localhost:8080/upload.jsp

    二.SpringMVC方式上传

    SpringMVC 使用框架提供的文件解析器对象，可以直接将请求体中的文件数据转为 MultipartFile 对象，从而省略原生上传中分析请求 体的步骤。
    1
    1.在 SpringMVC 核心配置文件配置文件解析器 
    1. <!-- 文件解析器对象，id名称必须是multipartResolver -->
    2. <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    3.     <!-- 支持一次上传文件的总容量。单位：字节 100M = 100*1024*1024-->
    4.     <property name="maxUploadSize" value="104857600"/>
    5.     <!-- 文件名的编码方式-->
    6.     <property name="defaultEncoding" value="utf-8"/>
    7. </bean>

    2.创建JSP表单upload2.jsp

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2.  
    3. <html>
    4. <head>
    5.     <title>上传</title>
    6. </head>
    7. <body>
    8. <h3>文件上传</h3>
    9. <form action="/fileUpload2" method="post" enctype="multipart/form-data">
    10.     <%-- 文件上传控件，类型是file --%>
    11.     选择文件:<input type="file" name="file">
    12.     <input type="submit" value="上传">
    13. </form>
    14. </body>
    15. </html>

    3.编写控制器接收上传请求 

    1. // MultipartFile参数名必须和JSP文件空间的name属性一致
    2.     @RequestMapping("/fileUpload2")
    3.     public String upload2(MultipartFile file, HttpServletRequest request) throws IOException {
    4.         // 创建文件夹，存放上传文件
    5.         String realPath = request.getSession().getServletContext().getRealPath("/upload");
    6.         File dir = new File(realPath);
    7.         if(!dir.exists()){
    8.             dir.mkdirs();
    9.         }
    10.  
    11.         // 将上传的数据写到文件夹的文件中
    12.         // 1.拿到上传的文件名
    13.         String filename = file.getOriginalFilename();
    14.         filename = UUID.randomUUID()+"_"+filename;
    15.         // 2.创建空文件
    16.         File newFile = new File(dir,filename);
    17.         // 3.将数据写入空文件中
    18.         file.transferTo(newFile);
    19.         //视图解析器，跳转到index.jsp页面
    20.         return "index";
    21.     }

    访问http://localhost:8080/upload2.jsp

     选择一个文件上传，比如一张图片，然后自动跳转到index.jsp页面中

     然后查看webapp目录下，自动创建了upload文件夹，且此文件夹下有上传的图片。

    三.上传多文件

    SpringMVC 支持一次性上传多个文件，写法如下：
    1 up
    1.创建 JSP 表单 upload3.jsp 
    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2.  
    3. <html>
    4. <head>
    5.     <title>上传</title>
    6. </head>
    7. <body>
    8. <h3>文件上传</h3>
    9. <form action="/fileUpload3" method="post" enctype="multipart/form-data">
    10.     <%-- 文件上传控件，类型是file --%>
    11.     用户名：<input name="username">
    12.     选择文件:<input type="file" name="files">
    13.     选择文件:<input type="file" name="files">
    14.     <input type="submit" value="上传">
    15. </form>
    16. </body>
    17. </html>

    2.编写控制器接收上传请求

    1. @RequestMapping("/fileUpload3")
    2.     public String upload3(String username,MultipartFile[] files,HttpServletRequest request) throws IOException {
    3.         System.out.println(username);
    4.  
    5.         // 创建文件夹，存放上传文件
    6.         String realPath = request.getSession().getServletContext().getRealPath("/upload");
    7.         File dir = new File(realPath);
    8.         if(!dir.exists()){
    9.             dir.mkdirs();
    10.         }
    11.         // 遍历数组，将上传的文件保存到文件夹
    12.         for (MultipartFile file : files) {
    13.             String filename = file.getOriginalFilename();
    14.             filename = UUID.randomUUID()+"_"+filename;
    15.             File newFile = new File(dir, filename);
    16.             file.transferTo(newFile);
    17.         }
    18.         return "index";
    19.     }

    访问：http://localhost:8080/upload3.jsp

     点击上传

     控制台输出：

     查看webapp下upload文件夹

  • 相关阅读:
    ADC噪声全面分析 -03- 利用噪声分析进行实际设计
    ShanDong Multi-University Training #3
    Hadoop第五章：序列化
    K8S常用kubectl命令汇总（持续更新中）
    回溯算法01-组合(Java)
    实战案例（MDL语句）
    基于Ray的分布式版本的决策树与随机森林
    mysql根据多字段分组——group by带两个或多个参数
    Matplotlib绘图-快速上手可视化工具
    双十一最值得入手什么，盘点几款最实用的数码好物
  • 原文地址：https://blog.csdn.net/weixin_44593822/article/details/125444219