目录
快速入门
需求：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转。
步骤
①导入SpringMVC相关坐标：要是SpringMVC起作用要使用DispathcerServlet，而DispathcerServlet是在SpringMVC相关坐标中。
②配置SpringMVC核心控制器DispathcerServlet：DispathcerServlet的内部配置了一些共有的行为，配置使用。
③创建Controller类和视图页面
④使用注解配置Controller类中业务方法的映射地址。
⑤配置SpringMVC核心文件spring-mvc.xml：扫描Controller中配置的组件。
⑥客户端发起请求测试
导入SpringMVC相关坐标
在配置文件中新增一下代maven依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>
导入了该依赖就有了前端控制器DispathcerServlet，有了之后就要在web.xml中配置springMVC的前端控制器
配置SpringMVC核心控制器DispathcerServlet
在web.xml文件中新增如下配置段：
<!-- 配置SpringMVC的前端控制器-->
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup><!--表示服务器启动时就加载该对象，不配置时表示第一次访问时再创建对象-->
</servlet>
<!-- 配置映射地址-->
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>/</url-pattern><!--这个/表示缺省的servlet，表示每次访问该请求时，任何请求都要走这个servlet-->
<!-- <url-pattern>*.xxx</url-pattern>--><!--意味着资源的扩展名是xxx时走这个servlet-->
</servlet-mapping>
创建Controller类和视图页面
目录结构：
在webapp文件夹下新建一个success.jsp：
<%--
Created by IntelliJ IDEA.
User: Lcy
Date: 2021/10/20
Time: 9:46
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>Success</h1>
</body>
</html>
创建controller文件夹。
使用注解配置Controller类中业务方法的映射地址
新建类UserController.java：
package com.stu.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @version:
* @author: 零乘一
* @description: 类的简介
* @date: 2021/10/20 9:45
**/
@Controller//将这个类配置到spring容器中
public class UserController {
@RequestMapping("/quick")//当你访问quick时就映射到save方法，执行其中的逻辑然后返回到success.jsp视图中
public String save(){
System.out.println("Control save running...");
return "success.jsp";//return的是要跳转的视图
}
}
已经写好了配置，但是需要让spring直到有这些东西的存在，因此需要进行组件的扫描操作。
配置SpringMVC核心文件spring-mvc.xml
在resources文件夹下新建一个spring-mvc.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- Controller的组件扫描-->
<context:component-scan base-package="com.stu.controller"/>
</beans>
为什么不能放在applicationContext.xml配置文件中，因为规范习惯将dao层与MVC层的组件分开扫描，放在一起扫描是没有问题的。
配置好了spring-mvc.xml文件，但此时它还没有被加载。
要在web.xml文件中进行配置，使该文件在servlet时被加载。
在param-name标签中的参数就是contextConfigLocation
在para-value标签中的参数为classpath:被加载的配置文件路径
运行
运行之后会自动打开该页面
在地址栏中输入quick后会打开以下页面：
在控制台中会打印以下文字：
运行解析
打开网页时找到Tomcat服务器
Tomcat服务器找到你内部工程的配置，由于在url-pattern中配置”/“缺省表示全局的，每次都会找到这个地方。
这个服务由框架提供，它会根据你的请求去解析找到对应的资源。因为我们在Controller配置了请求的映射，所以它就会找到方法save()，并且跳转到success.jsp页面。
web应用中包含如下：
Service表示前端控制器
由于配置的路径是缺省的，因此每一次请求都会经过前端控制器
前端根据你的请求解析你所需要的资源
controller会将视图返回回去
Tomcat会组装一个http响应。
组件解析
SpringMVC注解解析
@RequestMapping("")
作用：用于建立请求URL和处理请求方法之间的对应关系
可以写在类上或方法上
写在类上再在方法上写一个地址，访问时就要将写在类上的地址加上写在方法上的地址。
示例：
在类userController.java进行以下修改：
@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/quick")
public String save(){
System.out.println("Control save running...");
return "/success.jsp";
}
}
在重新运行Tomcat服务器后，在浏览器中输入：http://localhost:8080/user/quick
运行的结果与之前一般，在此就不截图了。
参数
value：用于指定请求的URL（当参数中只有一个时可以省略不写，如果有多个参数就必须要写上）
method：指定请求方式。
params：限制请求参数。支持简单的表达式、设定要访问该页面时必须输入的参数。
参数填写格式
@RequestMapping(value = "/xxx", method = RequestMethod.方法, params = {"xxx"})
示例：
将UserController.java中的代码修改如下：
@RequestMapping(value = "/quick", method = RequestMethod.GET, params = {"a","aa=123"})
在网页中的访问地址为：http://localhost:8080/user/quick?a=123&aa=123
结果与之前的一致。
注解扫描
这个了解就行
SpringMVC.xml配置文件
配置视图资源解析器
作用：配置好前缀和后缀，在转发时我们就只要写文件名，框架就会自动帮助我们加上前缀和后缀，连接成完整的路径。
以下是找到spring框架中定义的各个MVC的组件。
在spring-mvc.xml中新增如下配置：
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 拼接时首先拿上前缀，加上你在方法中的return中的值，然后加上后缀
{/jsp/}{success}{.jsp}：/jsp/success.jsp
-->
<property name="prefix" value="/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
这两个属性是InternalResourceViewResolver继承的父类中的有的两个set方法。
示例：
在wepapp文件夹下新建一个jsp文件夹，将success.jsp文件放入jsp文件夹中
UserController.java中代码改动如下：
@RequestMapping(value = "/quick")
运行后在网页地址栏中输入：http://localhost:8080/user/quick
运行结果一样，这里就不截图了。
SpringMVC的相关组件
SpringMVC的数据响应
页面跳转
1、返回字符串形式：此种方式会将返回的字符串域视图解析器的前后缀拼接后跳转。
回写数据
ModelAndView
在UserController.java文件新增以下代码段：
@RequestMapping(value = "/quick2")
public ModelAndView save2(){
/*
model模型 作用封装数据
View视图 作用展示数据
*/
ModelAndView modelAndView = new ModelAndView();
//设置模型数据
modelAndView.addObject("username","itcast");
//设置视图名称
modelAndView.setViewName("success");
return modelAndView;
}
在success.jsp代码修改如下
<h1>Success ${username}</h1>
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick2
会在页面中显示如下：
在UserController.java文件新增以下代码段：
@RequestMapping(value = "/quick3")
//springMVC会注入方法中的参数，然后就能够直接使用
public ModelAndView save3(ModelAndView modelAndView){
//设置模型数据
modelAndView.addObject("username","112223334");
//设置视图名称
modelAndView.setViewName("success");
return modelAndView;
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick3
会在页面中显示如下：
在UserController.java文件新增以下代码段：
@RequestMapping(value = "/quick4")
public String save4(Model model){
model.addAttribute("username","yuiop");
return "success";
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick4
会在页面中显示如下：
在UserController.java文件新增以下代码段（这种方式并不常用）：
@RequestMapping(value = "/quick5")
public String save5(HttpServletRequest request){
request.setAttribute("username","xodixjk");
return "success";
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick5
会在页面中显示如下：
在UserController.java文件新增以下代码段（不推荐使用）：
@RequestMapping(value = "/quick6")
public void save6(HttpServletResponse response) throws IOException {
response.getWriter().print("hello springMVC!!!");
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick6
会在页面中显示如下：
@RequestMapping(value = "/quick7")
@ResponseBody //告知SpringMVC不进行页面跳转，直接进行数据响应
public String save7(){
return "hello springMVC!!!";
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick7
会在页面中显示如下：
解析jason数据
导入依赖坐标：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
新建类User.java：
package com.stu.domain;
/**
* @version:
* @author: 零乘一
* @description: 模仿用户类
* @date: 2021/10/23 21:01
**/
public class User {
private String username;
private int age;
public void setUsername(String username) {
this.username = username;
}
public void setAge(int age) {
this.age = age;
}
public String getUsername() {
return username;
}
public int getAge() {
return age;
}
}
在UserController.java文件新增以下代码段（这段只是jason数据的测试，开发不会这么干的）：
@RequestMapping(value = "/quick8")
@ResponseBody
public String save8() throws JsonProcessingException {
return "{\"username\":\"sdsd\",\"age\":30}";
}
在UserController.java文件新增以下代码段：
@RequestMapping(value = "/quick9")
@ResponseBody
public String save9() throws JsonProcessingException {
User user = new User();
user.setUsername("sdsd");
user.setAge(30);
//使用json的转换工具将对象转换成json格式字符串再返回
ObjectMapper objectMapper = new ObjectMapper();
String json = objectMapper.writeValueAsString(user);
return json;
}
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick8或是http://localhost:8080/user/quick9
会在页面中显示如下：
解析jason数据改进
在xm文件中配置之后，就只需要返回需要返回的对象即可，springMVC会自动转成json字符串。
在spring-mvc.xml新增以下配置：
<!-- 配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
</list>
</property>
</bean>
在UserController.java文件中新增以下代码段：
@RequestMapping(value = "/quick10")
@ResponseBody
public User save10() throws JsonProcessingException {
User user = new User();
user.setUsername("lisi");
user.setAge(30);
return user;
}
能够看出这边是直接返回想要在页面中显示的数据的对象。
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick10
当然返回数组也是同样的操作
在UserController.java文件中新增以下代码段：
@RequestMapping(value = "/quick11")
@ResponseBody
public User[] save11() throws JsonProcessingException {
User[] users = new User[3];
for (int i = 0; i < users.length; i++) {
users[i] = new User();
users[i].setUsername("测试"+i);
users[i].setAge(10+i);
}
return users;
}
能够看出这边是直接返回想要在页面中显示的数据的对象。
运行tomcat服务器后，在在网址栏中输入：http://localhost:8080/user/quick11
处理json数据只学这个！！！
前面两种还是太麻烦（直接白学，23333）这个方式的最重要的！！！
使用以下这个方法才是懒人的真谛，只需要写上一个注解，springMVC就以及帮你配置好处理器的映射器。使用注解mvc:annotation-driven替换注解处理器和适配器的配置，同时mvc:annotation-driven默认底层就集成jasckson进行对象或集合的json格式字符串的转换。
将spring-mvc.xml的配置文件新增如下代码：
xmlns:mvc="http://www.springframework.org/schema/mvc"
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
<!-- 以上两个是导入mvc命名空间以及导入空间坐标-->
<!-- 使用注解配置处理器映射器-->
<mvc:annotation-driven/>
SpringMVC获得请求数据
获得简单（基本）的参数
在UserController新增以下代码段：
@RequestMapping(value = "/quick12")
@ResponseBody
//简单请求参数获取
public void save12(String username,int age){
System.out.println(username);
System.out.println(age);
}
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/user/quick12?username=adb&age=19会在控制台区域打印如下：
自动封装为POJO对象
在UserController.java新增以下代码段：
@RequestMapping(value = "/quick13")
@ResponseBody
//自动封装为POJO对象
public void save13(User user){
System.out.println(user);
}
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/user/quick13?username=adb&age=19会在控制台区域打印如下：
获得数组类型参数（不常用）
@RequestMapping(value = "/quick14")
@ResponseBody
//自动封装为数组对象
public void save14(String[] strs){
System.out.println(Arrays.toString(strs));
}
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/user/quick14?strs=1&strs=2&strs=3会在控制台区域打印如下：
获得集合类型参数
新建类Vo.java：
package com.stu.domain;
import java.util.List;
/**
* @version:
* @author: 零乘一
* @description: 用户列表类
* @date: 2021/10/24 12:01
**/
public class Vo {
private List<User> userList;
public List<User> getUserList() {
return userList;
}
public void setUserList(List<User> userList) {
this.userList = userList;
}
@Override
public String toString() {
return "VO{" +
"userList=" + userList +
'}';
}
}
<%--
Created by IntelliJ IDEA.
User: Lcy
Date: 2021/10/24
Time: 12:03
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/user/quick15">
<%-- 表明第一个User对象的username age--%>
<input type="text" name="userList[0].username"><br>
<input type="text" name="userList[0].age"><br>
<input type="text" name="userList[1].username"><br>
<input type="text" name="userList[1].age"><br>
<input type="text" name="userList[2].username"><br>
<input type="text" name="userList[2].age"><br>
<input type="submit" value="提交">
</form>
</body>
</html>
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/from.jsp显示如下：
随意输入几个数据然后提交：
ewq
123
qweq
123
ew
12
点击提交后会在idea控制台打印如下：
若打印的结果是null，那很有可能是Vo类中没有设置get方法。
ajax传输数据
将jquery-3.3.1.js放入文件夹中
新建ajax.jsp：
<%--
Created by IntelliJ IDEA.
User: Lcy
Date: 2021/10/24
Time: 16:48
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
<script>//发送jason数据，并指定context为jason格式
var userList = new Array();
userList.push({username:"zhangsan",age:18});
userList.push({username:"lisi",age:28});
//发送ajax请求
$.ajax({
type:"POST",
url:"${pageContext.request.contextPath}/user/quick16",
data:JSON.stringify(userList),
contentType:"application/json;charset=utf-8"
});
</script>
</head>
<body>
</body>
</html>
UserController.java文件新增以下代码段：
@RequestMapping(value = "/quick16")
@ResponseBody
//@RequestBody要使数据能够成功被接收，在参数前要加上这个注解
public void save16(@RequestBody List<User> userList) throws IOException {
System.out.println(userList);
}
在springMVC.xm新增如下代码段：这段配置是用于加载新增的静态资源js文件，如果不配置以下，在网页跳转时就会发现找不到我们放入的那个js文件。
<!-- 开放资源的访问-->
<mvc:resources mapping="/js/**" location="/js/"/>
<!-- mapping：表示在服务器*问的地址，location：资源存储的地址-->
也可以替换为以下的配置：
<!-- 表示的是当前的资源无法找到对应的资源时，换回默认的资源选择器，交有tomcat去找资源-->
<mvc:default-servlet-handler/>
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/ajax.jsp控制台打印如下：
若已经配置，但还是找不到文件，则可以尝试一下以下操作，也许可以。
双击clean执行一下，再尝试一下执行。
请求数据中文乱码
之前写了一个form.jsp的页面文件，之前当我们输入中文提交后，在控制台中是无法识别中文的输出一堆的问号，做完以下配置就能够识别中文了。
在web.xml文件中新增以下配置：
<!-- 配置全局过滤的filer-->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
运行tomcat服务器后，在网址栏中输入：http://localhost:8080/from.jsp输入如下数据并提交：
张三
20
李四
21
王五
22
在控制台中显示如下：
SpringMVC获得请求数据
@requestParam
它作用于当接收请求数据的方法的形参与传递的数据名不一样时，可以设置这个注解中的value属性指定请求的参数名称。
参数：
value：与请求参数名称。
required：此在指定的请求参数是否必须包括，默认是true，提交时如果没有此参数则报错。
defaultValue：当没有指定请求参数时，则使用指定的默认值赋值。
在UserController.java新增以下代码段：
@RequestMapping(value = "/quick17")
@ResponseBody
//@RequestBody，意味着把请求体的内容直接封装到形参中（必须是context-jason格式），数据能够成功被接收，在参数前要加上这个注解
public void save17(@RequestParam(value="name",required = false,defaultValue = "zhangsna") String username) throws IOException {
System.out.println(username);
}
运行tomcat服务器后，在网址栏中分别输入进行测试：
http://localhost:8080/user/quick17?name=123
http://localhost:8080/user/quick17
在控制台打印结果分别如下：
第二个请求方式之所以能够成功是因为我们在注解配置中有配置required = false，这个属性如果没有配置则默认为true，如果是true则在访问时则必须带上指定的参数。
Restful风格的参数（了解）
Restful风格的请求是使用“url+请求方式”
GET：用于获取资源
POST：用于新建资源
PUT：用于更新资源
DELETE：用于删除资源
/user/1 GET ：得到 id = 1 的 user
/user/1 DELETE： 删除 id = 1 的 user
/user/1 PUT：更新 id = 1 的 user
/user POST：新增 user
自定义类型转换器
自定义类型转换器的开发步骤：
①定义转换器类实现Converter接口
②在配置文件中声明转换器
③在annotation-driven中引用转换器
新建类DateConverter.java：实现Converter类，并实现convert方法。
package com.stu.controller;
import org.springframework.core.convert.converter.Converter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @version:
* @author: 零乘一
* @description: 日期对象转换器
* @date: 2021/10/25 20:05
**/
public class DateConverter implements Converter<String, Date> {
@Override
public Date convert(String dataStr) {
//将日期字符串转换成日期对象，返回
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
date = format.parse(dataStr);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
在UserController.java新增以下代码段：
@RequestMapping(value = "/quick19")
@ResponseBody
public void save18(Date date) throws IOException {
System.out.println(date);
}
在spring-mvc.xml新增修改以下配置：
<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>
<!-- 声明转换器-->
<bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<list>
<bean class="com.stu.controller.DateConverter"/>
</list>
</property>
</bean>
运行tomcat服务器后，在网址栏中分别输入进行测试：
http://localhost:8080/user/quick19?date=2019-01-01
在控制台打印结果如下：
这是因为在日期转换器中，我们配置了这样的日期格式，如果不配置，则它只能识别2019/'01/01的日期格式，设置了之后就只能识别2019-01-01格式i的日期了，在开发中，我们通常使用spring提供的转换为，不会自己写转换的类，但也不排除在开发时需要自己处理数据的转换，所以这个知识点要知道且记住。
获得Servlet相关API
在方法的形参中写上要获取的API类型的对象，Spring矿建就会自动的将对象注入。
在UserController.java新增以下代码段：
@RequestMapping(value = "/quick20")
@ResponseBody
public void save20(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException {
System.out.println(request);
System.out.println(request);
System.out.println(session);
}
运行tomcat服务器后，在网址栏中分别输入进行测试：
http://localhost:8080/user/quick20
在控制台打印结果如下：
打印出的结果有地址说明Spring容器已经注入了对象。
获得请求头
运行tomcat服务器后，在网址栏中输入进行测试：
http://localhost:8080/user/quick21
在控制台打印结果如下：
在网页中点击F12打开控制台，打开网络之后再输入网址点击回车可以抓到如下包，然后可以找到请求头的User-Agent的信息。
能够看出在控制台打印的结果与网页上的数据是一致的，说明在Spring框架中已经成功获得请求头的数据。
获得CookieValue
在UserController.java新增以下代码段：
@RequestMapping(value = "/quick22")
@ResponseBody
public void save22(@CookieValue(value = "JSESSIONID") String jsessionId) throws IOException {
System.out.println(jsessionId);
}
在网页中点击F12打开控制台，打开网络之后再输入网址点击回车可以抓到如下包，然后可以找到请求头的CookieValue的信息。
能够看出在控制台打印的结果与网页上的数据是一致的，说明在Spring框架中已经成功获得Cookie的数据。
文件上传
1、文件上传客户端三要素
表单项type=“file”
表单的提交方式是post
表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”
单文件上传
新建upload.jsp文件：
<%--
Created by IntelliJ IDEA.
User: Lcy
Date: 2021/10/28
Time: 12:04
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
名称<input type="text" name="username"><br>
文件<input type="file" name="uploadFile"><br>
<input type="submit" name="提交">
</form>
</body>
</html>
①在pom.xml文件中导入filerupload与io的坐标
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.3</version>
</dependency>
导入新的坐标后记得要刷新以下pom配置。
②配置文件上传解析器
在spring-mvc文件中新增以下配置：
<!-- 配置文件上传解析器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 配置文件上传的默认编码-->
<property name="defaultEncoding" value="UTF-8"/>
<property name="maxUploadSize" value="50000"/>
</bean>
③编写文件上传代码
在UserController.java文件中新增以下代码段：
@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile uploadFile) throws IOException {
System.out.println(username);
System.out.println(uploadFile);
}
运行tomcat服务器后，在网址栏中输入进行测试：
http://localhost:8080/upload.jsp
名称随意，文件选择按照在配置文件中设置的要求来（大小限制之类的）
在控制台打印结果如下：
说明文件上传已经成功。
如果打印的结果是两个NULL，那可能是在配置文件中的东西写错了（例如id没写或写错，是谁我不说）。
在该方法中加入以下语句即能够实现文件的上传。
//获得上传文件的名称
String originalFilename = uploadFile.getOriginalFilename();
uploadFile.transferTo(new File("E:\\a\\"+originalFilename));
多文件上传
在upload.jsp文件中新增以下代码段：
名称<input type="text" name="username"><br>
文件<input type="file" name="uploadFile"><br>
在UserController.java文件下新增以下代码段：两个input的name属性不同时
//获得上传文件的名称
originalFilename = uploadFile2.getOriginalFilename();
uploadFile.transferTo(new File("E:\\a\\"+originalFilename));
然后在你指定的上传文件的文件夹中就能够看到上传的两个文件了。
在UserController.java文件下新增以下代码段：两个input的name属性相同时，使用数组的方式
@RequestMapping(value = "/quick25")
@ResponseBody
public void save25(String username, MultipartFile[] uploadFile) throws IOException {
System.out.println(username);
System.out.println(uploadFile);
for (MultipartFile multipartFile : uploadFile) {
String originalFilename = multipartFile.getOriginalFilename();//获得上传文件的名称
multipartFile.transferTo(new File("E:\\a\\"+originalFilename));//将该文件转移到某个文件夹中
}
}
并将jsp文件中的调用跳转的路径修改为方法25的。