当前位置：首页 > news >正文

Spring MVC学习笔记，包含mvc架构使用，过滤器、拦截器、执行流程等等

news 2025/9/13 11:15:57

😀😀😀创作不易，各位看官点赞收藏.

文章目录

Spring MVC 习笔记
- 1、Spring MVC demo
- 2、Spring MVC 中常见注解
- 3、数据处理
- - 3.1、请求参数处理
  - 3.2、响应数据处理
- 4、RESTFul 风格
- 5、静态资源处理
- 6、HttpMessageConverter 转换器
- 7、过滤器与拦截器
- 8、异常处理
- 9、理解SpringMVC的执行原理
- 10、文件上传和下载

Spring MVC 习笔记

Spring MVC：Spring MVC是Spring Framework的一部分，是基于java实现的MVC的轻量级Web框架。

官网文档地址:https://docs.spring.io/spring-framework/docs/4.2.4.RELEASE/spring-framework-reference/html/mvc.html

轻量级，简单易学。
高效，基于请求和响应的MVC框架。
与Spring兼容性较好，无缝结合。
约定优于配置。
功能强大，简洁灵活。

MVC：是一种软件架构思想，按照软件的模型、试图、控制器进行划分。

M：model，模型层工程中的 javaBean 用于处理数据。

V：view，视图层工程中显示数据的页面，用于与用户交互使用。

C：controller，控制器层，用于接收前端请求和响应浏览器。

1、Spring MVC demo

导入依赖：

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.8</version></dependency><dependency><groupId>javax.servlet</groupId><artifactId>servlet-api</artifactId><version>2.5</version></dependency><dependency><groupId>javax.servlet.jsp</groupId><artifactId>jsp-api</artifactId><version>2.2</version></dependency><dependency><groupId>javax.servlet.jsp.jstl</groupId><artifactId>jstl</artifactId><version>1.2</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.21</version></dependency>
</dependencies>

创建 web.xml 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 		http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"version="4.0"><!-- 注册DispatcherServlet--><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><!-- 关联一个spring 容器的配置文件：springmvc-servlet.xml--><!-- 如果它不绑定一个 spring 容器配置文件，它会有一个在WEB-INF下默认名称为 springmvc-servlet.xml的配置文件--><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc-servlet.xml</param-value></init-param><!-- 设置该servlet在项目启动的时候就加载--><load-on-startup>1</load-on-startup></servlet><!-- 设置请求的访问路径--><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>/</url-pattern></servlet-mapping>
</web-app>

创建 spring 容器配置文件：springmvc-servlet.xml

<?xml version="1.0" encoding="UTF8"?>
<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"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsd"><!-- 注入映射器--><bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/><!-- 注入适配器--><bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/><!-- 注入视图解析器，在控制器返回到视图层会根据返回路劲进行拼接--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">   <!--前缀-->   <property name="prefix" value="/WEB-INF/jsp/"/>   <!--后缀-->   <property name="suffix" value=".jsp"/></bean>
</beans>

编写controller：

public class HelloController implements Controller {@Overridepublic ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {// 创建ModelAndView对象，用于返回业务的数据ModelAndView mv = new ModelAndView();// 把业务获得的数据封装到mv中mv.addObject("msg","Hello,SpringMVC!");// 把要跳转的视图封装到mv中mv.setViewName("hello"); // 在springmvc-servlet.xml中拼接为 /WEB-INF/jsp/hello.jsp// 把mv返回给DispatcherServletreturn mv;}
}

controller 注入 Spring 容器：

<bean id="/hello" class="com.xiayuan.controller.HelloController"/>

编写测试的页面，在WEB-INF文件夹下创建一个jsp文件夹，在jsp文件夹下创建hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>test</title>
</head>
<body>${msg}
</body>
</html>

配置 Tomcat并测试：

注意：在配置DisapatcherServlet时，拦截的请求是 / 表示拦截所有的请求， /* 也是拦截所有的请求，但是 / 不包括jsp文件，而 /* 会包括jsp文件，所以只能写 / 来拦截所有的请求。

2、Spring MVC 中常见注解

@RequestMapping：注解用于映射 url 到控制器类或一个特定的处理程序方法。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

@Controller
@RequestMapping("/test")
public class HelloController {// 映射的 url 地址就是 /test/helllo@RequestMapping("/hello")public String sayHello(Model model){model.addAttribute("msg","Hello,SpringMVCAnnotation!");return "hello";}
}

@RequestMapping 注解属性：

value：指定 url 地址映射的值，可以是一个数组，映射多个请求，是个必填属性，支持模糊匹配。
- ?：单个字符。
- *：表示任意一个或多个字符。
- **：表示任意一层或多层目录。
method：是一个枚举值，可以指定请求方式来映射请求，通常有POST、GET、DELETED、PUT等，也是一个数组可以映射多个请求方法。
params：根据请求参数去匹配请求 url 地址，是一个字符串数组，可以指定多个，指定多个时必须同时满足多个条件才会映射。
- params={"test","admin"}：请求中必须同时包含test、admin两个参数。
- params={“!test”}：请求中必须不包含 test 参数。
- params={“test=1”}：请求中必须包含 test 参数并且参数值必须是1。
- params={“test!=1”}：请求中必须包含 test 参数并且参数值必须不等于1。
headers：根据 http 请求中的请求头来映射 url 地址，用法和 params 类似。
consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html，是一个数组可以指定多个。
produces：指定返回的内容类型，仅当 request 请求头中的 (Accept) 类型中包含该指定类型才返回，是一个数组可以指定多个。

@RequestMapping 派生注解：

@GetMapping：请求映射 GET 方式请求到方法上，相当于在 @RequestMapping 上添加了 method 属性为 GET 方式。
@PostMapping：…
@DeleteMapping：…
@PutMapping：…

@RequestParam 注解：用于控制器的请求方法的参数上，将请求参数与方法参数两个相互映射。

@GetMapping("/test1")
// 将前端的user参数与name参数映射
public String test(@RequestParam("user") String name){return name;
}

@RequestHeader 注解：用于控制器方法上的参数，请求头信息与参数之间的关系映射。

@PostMapping("/test1")
// 将请求头中的Accept的值赋值给header
public String test(@RequestHeader("Accept") String header){return header;
}

@CookieValue 注解：用于控制器方法上的参数，将请求中的 cookie 与参数之间的关系映射起来。

@PostMapping("/test1")
public String test(@CookieValue String cookie){return cookie;
}

@Controller：用于类上，标识这个类是一个处理前端请求的类，会根据 url 地址映射到处理请求的方法上。

@Controller
public class ControllerTest {
}

@RestController：作用与 @Controller 相同，但是这个类处理请求返回的结果是 json 格式。

3、数据处理

3.1、请求参数处理

请求参数：每一次请求都会携带一些参数数据，后端可以获取这些参数数据进行一系列操作，获取请求参数的方式很多。

通过 url 中的参数来获得前端参数。

@RequestMapping("/t1")
public String test1(@RequestParam("name") String name, @RequestParam("password") String password, Model model){// @RequestParam注解中的name和password就是从前端传过来的参数名称// 必须和前端参数名称一样，后面的string的名称可以和前端参数名称不一样System.out.println("name = "+name);System.out.println("password = "+password);return "test";
}

通过封装一个实体类来接受数据。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {private String name;private String password;
}

@RequestMapping("/t2")
public String test2(User user,Model model){System.out.println(user);return "test";
}

注意：把user作为参数来接受前端数据，而且前端的参数名称必须要和接受对象的字段名称保持一致，不能不一样。如果字段不一样的字段，就会自动为默认值。

通过 Map 集合获取数据，这种方式只能从请求体中获取对象数据或则是 json 数据。

@PostMapping("/test2")
public String test(@RequestBody Map<String,String> params){System.out.println(params.get("name"));return "ok";
}

请求参数乱码问题：在前端传入的参数中有中文字符，在后端就会存在乱码问题，我们通常使用过滤器去解决乱码问题。

<!-- 向 web.xml 文件中注册一个 filer 过滤器就可以解决乱码问题--><filter><filter-name>encoding</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><!-- 设置响应编码--><init-param><param-name>forceResponseEncoding</param-name><param-value>true</param-value></init-param>
</filter>
<filter-mapping><filter-name>encoding</filter-name><url-pattern>/*</url-pattern>
</filter-mapping>

3.2、响应数据处理

request 域数据设置：

ModelAndView：这是之前的数据封装方式，使用的就是ModelAndView来给前端显示数据的。

@Override
public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {ModelAndView mv = new ModelAndView();// 数据mv.addObject("msg","封装的数据!"); // 视图的名称mv.setViewName("hello");return mv;
}

ModelMap:

@RequestMapping("/t3")
public String test3(ModelMap modelMap){modelMap.addAttribute("msg","封装的数据！");return "test";
}

Model:

@RequestMapping("/t4")
public String test4(Model model){model.addAttribute("msg","封装的数据！");return "test";
}

注意：ModelMap 它继承了 LinkedHashMap，所有他有该类的所有操作，而 Model 是 ModelMap 的简洁版本，没有继承 LinkedHashMap。

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解； ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性； ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转，它们都是把数据封装到在 request 域中的，实际上在底层返回中请求都是返回的一个 ModelAndView 对象。

session 域数据：这个数据是当前会话共享的数据。

@GetMapping("/test")
public String test(HttpServletSession session){
session.setAttribute("data","这是一个数据");
return "ok";
}

application 域数据：这个数据是应用程序共享的数据。

@GetMapping("/test")
public String test(HttpSession session){// 应用全局上下文ServletContext context = session.getServletContext();context.setAttribute("data","这是一个数据");return "ok";
}

请求转发：

@RequestMapping("/t2")
public String test2(HttpServletRequest request, HttpServletResponse response,Model model){// 请求转发：可以转发到页面，也可以转发到一个请求return "forward:/test" return "forward:/login.jsp"; 
}

重定向：

@RequestMapping("/t2")
public String test2(HttpServletRequest request, HttpServletResponse response,Model model){// 相当于重新发出一个请求return "redirect:/login.jsp" 
}

：注意重定向不能重定向到WEB-INF下的资源。

4、RESTFul 风格

Restful：是一个资源定位及资源操作的风格，是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

操作	传统方式	RESTFul风格
查询	getById?id=1	getById/1 ==== get方式
新增	insert	insert === post方式
删除	deletedByid?id=1	deletedByid/1 ==== delete方式
更新	updateByid?id=1	updateByid/1 ==== put方式

url 地址参数绑定：

@Controller
public class RestFulController {@RequestMapping("/hello/{a}/{b}")public String test(@PathVariable String a, @PathVariable String b, Model model){// 需要使用`@PathVariable`注解来注解参数，上面a和b就是参数的名称。model.addAttribute("msg","Hello,RestFul!");return "hello";}
}

5、静态资源处理

注意：在 Spring MVC 中所有的请求都会先呗被 DispatcherServlte 拦截并且映射到对应的控制器上，但是对于静态资源就会出现找不到的问题。

<!-- 解决：需要在 Spring MVC 配置文件中指定处理静态资源的 Sevlet -->
<?xml version="1.0" encoding="UTF8"?>
<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"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc.xsd"><!-- 加入处理静态资源的 servlet--><mvc:default-servlet-handler/><!-- 开启注解驱动，不开启静态资源 servlet 无效--><mvc:annotation-driven/>
</beans>

处理流程：

6、HttpMessageConverter 转换器

消息转换器，将请求信息转换成 Java 对象，或者将 Java 对象装换成响应报文给前端。HttpMessageConverter 提供了两个注解和两个实体类：@RequestBody、@ResponseBody、RequestEntity、ResponseEntity。

@RequestBody：获取请求体中的参数，与方法参数绑定在一起，一般请求方式是 POST 方法也可以是 GET 方法，但是必须有请求体。

@PostMapping("/")
public String fun1(@RequestBody User user){ // 将请求体的参数与user对象进行映射，参数名需要对应return "ok";
}

RequestEntity：封装请求报文的一种类型，其中包含请求头、请求体等信息，在控制器方法上指定这个采参数就可以直接获取请求信息。

@PostMapping("/entity")
public String fun2(RequestEntity<String> entity){System.out.println(entity.getHeaders());System.out.println(entity.getBody());return "ok";
}

@ResponseBody：标识在控制器方法上，如果项目引入了 Json 解析包，对于返回的对象会解析成 Json 字符串。

@GetMapping("/")
// 将方法返回值作为响应体，不再是视图名臣
@ResponseBody
public User fun3(){User user = new User();user.setUsername("张三");user.setPassword("123456");return user;
}

ResponseEntity：用于控制器方法的返回值，该方法的返回值就是响应到浏览器的响应报文。

@GetMapping("/entity")
public ResponseEntity<User> fun4(){User user = new User();user.setUsername("张三");user.setPassword("123456");// 构建响应报文return new ResponseEntity<>(user, HttpStatus.OK);
}

7、过滤器与拦截器

过滤器：是基于函数回调的，过滤器中都会实现一个 doFilter()方法，这个方法有一个FilterChain 参数，而实际上它是一个回调接口。ApplicationFilterChain是它的实现类，这个实现类内部也有一个 doFilter() 方法就是回调方法。

// 自定义过滤器
@Component
public class MyFilter implements Filter {// 初始化方法，这个方法必须执行成功，否则过滤器不生效@Overridepublic void init(FilterConfig filterConfig) throws ServletException {Filter.super.init(filterConfig);}@Overridepublic void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {// 进行业务处理，如果不放行就通过request重定向或转发到对应页面// 放行请求filterChain.doFilter(servletRequest,servletResponse);}// 拦截器销毁方法@Overridepublic void destroy() {Filter.super.destroy();}
}

拦截器：应用中可以同时存在多个拦截器Interceptor，一个请求也可以触发多个拦截器，而每个拦截器的调用会依据它的声明顺序依次执行，拦截器 则是基于 Java 的反射机制（动态代理）实现的，只有 Spring MVC 框架才能使用该拦截器。

// 自定义拦截器
@Component
public class MyInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {HandlerInterceptor.super.afterCompletion(request, response, handler, ex);}
}

preHandle方法：是过滤请求，相当于 servlet 中的 doFilter，如果返回 true 就放行该请求，返回 false 就不会放行请求。
postHandle方法：在控制器方法执行完成之后执行。
afterCompletion方法：在视图解析器解析之后执行。

过滤器的使用：编写配置类，将过滤器注册到 Spring 容器中并设置对应的拦截路径。

@Configuration
public class WebMvcConfig {@Bean("myFilterRegister")public FilterRegistrationBean<MyFilter> myFilter(MyFilter myFilter) {FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(myFilter);registrationBean.addUrlPatterns("/*");  //url拦截，不配置拦截所有请求registrationBean.setOrder(1); // 过滤顺序，越小越先过滤return registrationBean;}
}

拦截器的使用(方式一)：将拦截器通过 XML 方式注入到 Spring 容器中。

<mvc:interceptors><mvc:interceptor><!-- 设置拦截的路径--><!-- /** 表示该文件夹下的所有请求--><!-- /* 表示所有的请求--><mvc:mapping path="/admin/**"/> <!-- 表示拦截admin下面的所有文件夹进行拦截--><!-- 使用哪个拦截器来拦截--><bean class="com.xiayuan.interceptor.MyInterceptor"/></mvc:interceptor>
</mvc:interceptors>

拦截器的使用(方式二)：通过配置类的方式注入到 Spring 容器中。

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {// 注册拦截器@Overridepublic void addInterceptors(InterceptorRegistry registry) {// order越小越先拦截registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").order(1);}
}

执行流程：

多个拦截器执行顺序：多个拦截器主要是通过配置顺序进行执行，也可以通过配置 order 设置执行顺序。

拦截器都放行：preHandle 方法按照拦截器依次执行，postHandle、afterCompletion会按照拦截器顺序倒序执行。

存在拦截器拦截：preHandle 方法按照拦截循序执行，被拦截以及后面的拦截器对应的 preHandle 都不执行。postHandle 所有拦截器都不会执行，afterCompletion 只会执行未被拦截的拦截器并且倒序执行(有一个拦截器执行的 index 记录执行拦截器的下标)。

8、异常处理

针对异常不想显示为 Spring Mvc 默认的异常处理，可以之定义异常控制器来处理指定的异常。

// 实质就是一个 Controller 控制器
// @ControllerAdvice 方法返回结果是视图名称
@RestControllerAdvice // 方法返回结果是 json 字符串
public class GlobalExceptionHandler {private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);/*** 拦截未知的运行时异常，参数是一个指定处理异常的 Class 对象*/@ExceptionHandler(value = {RuntimeException.class,NullPointerException.class})public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request) {String requestURI = request.getRequestURI();log.error("请求地址'{}',发生未知异常.", requestURI, e);return AjaxResult.error(e.getMessage());}
}

9、理解SpringMVC的执行原理

Spring MVC 的原理图：

未命名文件

深入理解 Spring MVC 原理：

中心控制器（DispatcherServlet）

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像其他其它MVC框架一样，以请求为驱动，围绕一个中心控制器的servlet派送请求和提供功能，中心控制器实际上就是一个servlet，它是继承至HttpServlet基类。所有的请求给中心控制器来拦截，然后在派送请求。

分析执行流程

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图响应给用户。

10、文件上传和下载

导入相应的依赖：

<dependency><groupId>commons-fileupload</groupId><artifactId>commons-fileupload</artifactId><version>1.3.3</version>
</dependency>
<dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>4.0.1</version>
</dependency>

配置文件解析器：

<!--文件上传配置-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">    <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 --><property name="defaultEncoding" value="utf-8"/>    <!-- 上传文件大小上限，单位为字节（10485760=10M） --><property name="maxUploadSize" value="10485760"/><property name="maxInMemorySize" value="40960"/>
</bean>

注意：必须配置id属性，因为这个是根据id获取的，bean的id属性的名称必须是multipartResolver。

文件上传控制器(方式一)：

public String upload(@RequestParam("my_file") CommonsMultipartFile file , HttpServletRequest request) throws IOException{//获取文件名 : file.getOriginalFilename();String uploadFileName = file.getOriginalFilename();// 如果文件名为空，直接回到首页！if ("".equals(uploadFileName)){return "redirect:/index.jsp";}System.out.println("上传文件名 : "+uploadFileName);// 上传路径保存设置String path = request.getServletContext().getRealPath("/upload");// 如果路径不存在，创建一个        File realPath = new File(path);if (!realPath.exists()){realPath.mkdir();}System.out.println("上传文件保存地址："+realPath);InputStream is = file.getInputStream(); //文件输入流OutputStream os = new FileOutputStream(new File(realPath,uploadFileName));// 文件输出流// 读取写出int len=0;byte[] buffer = new byte[1024];while ((len=is.read(buffer))!=-1){os.write(buffer,0,len);os.flush();}os.close();is.close();return "redirect:/index.jsp";
}

文件上传控制器(方式二)：

/* * 采用file.Transto 来保存上传的文件 */
@RequestMapping("/upload2")
public String fileUpload2(@RequestParam("my_file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {//上传路径保存设置String path = request.getServletContext().getRealPath("/upload");File realPath = new File(path);if (!realPath.exists()){realPath.mkdir();}// 上传文件地址System.out.println("上传文件保存地址："+realPath);// 通过CommonsMultipartFile的方法直接写文件（注意这个时候）file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));return "redirect:/index.jsp";}
}

文件下载(方式一)：通过超链接来下载文件，但是存在一个弊端，超链接下载文件对于浏览器能够解析的资源就直接在页面给你展示，浏览器不能够解析的资源会让你下载。

<a href="${pageContext.request.contextPath}/upload/lab.png">通过超链接下载</a>

文件下载(方式二)：

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response , HttpServletRequest request) throws Exception {//要下载的图片地址String  path = request.getServletContext().getRealPath("/upload");String  fileName = "lab.png";// 1、设置response 响应头response.reset();// 设置页面不缓存,清空bufferresponse.setCharacterEncoding("UTF-8");// 字符编码response.setContentType("multipart/form-data");// 二进制传输数据// 设置响应头response.setHeader("Content-Disposition","attachment;fileName="+ URLEncoder.encode(fileName, "UTF-8"));File file = new File(path,fileName);// 2、 读取文件--输入流InputStream input=new FileInputStream(file);// 3、 写出文件--输出流OutputStream out = response.getOutputStream();byte[] buff =new byte[1024];int index=0;// 4、执行 写出操作while((index= input.read(buff))!= -1){out.write(buff, 0, index);out.flush();}out.close();input.close();return null;
}