biancheng-Spring MVC

MVC设计模式简介

http://c.biancheng.net/spring_mvc/

MVC 设计模式一般指 MVC 框架，M（Model）指数据模型层，V（View）指视图层，C（Controller）指控制层。使用 MVC 的目的是将 M 和 V 的实现代码分离，使同一个程序可以有不同的表现形式。其中，View 的定义比较清晰，就是用户界面。

在 Web 项目的开发中，能够及时、正确地响应用户的请求是非常重要的。用户在网页上单击一个 URL 路径，这对 Web 服务器来说，相当于用户发送了一个请求。而获取请求后如何解析用户的输入，并执行相关处理逻辑，最终跳转至正确的页面显示反馈结果，这些工作往往是控制层（Controller）来完成的。

在请求的过程中，用户的信息被封装在 User 实体类中，该实体类在 Web 项目中属于数据模型层（Model）。

在请求显示阶段，跳转的结果网页就属于视图层（View）。

像这样，控制层负责前台与后台的交互，数据模型层封装用户的输入/输出数据，视图层选择恰当的视图来显示最终的执行结果，这样的层次分明的软件开发和处理流程被称为 MVC 模式。

在学习 Servlet 及 JSP 开发时，JavaBean 相当于 Model，Servlet 相当于 Controller，JSP 相当于 View。

总结如下：

  • 视图层（View）：负责格式化数据并把它们呈现给用户，包括数据展示、用户交互、数据验证、界面设计等功能。
  • 控制层（Controller）：负责接收并转发请求，对请求进行处理后，指定视图并将响应结果发送给客户端。
  • 数据模型层（Model）：模型对象拥有最多的处理任务，是应用程序的主体部分，它负责数据逻辑（业务规则）的处理和实现数据操作（即在数据库中存取数据）。


SUN 公司推出 JSP 技术的同时，也推出了两种 Web 应用程序的开发模式。即 JSP+JavaBean 和 Servlet+JSP+JavaBean。

JSP+JavaBean

JSP+JavaBean 中 JSP 用于处理用户请求，JavaBean 用于封装和处理数据。该模式只有视图和模型，一般把控制器的功能交给视图来实现，适合业务流程比较简单的 Web 程序。

 

 

通过上图可以发现 JSP 从 HTTP Request（请求）中获得所需的数据，并进行业务逻辑的处理，然后将结果通过 HTTP Response（响应）返回给浏览器。从中可见，JSP+JavaBean 模式在一定程度上实现了 MVC，即 JSP 将控制层和视图合二为一，JavaBean 为模型层。

JSP+JavaBean 模式中 JSP 身兼数职，既要负责视图层的数据显示，又要负责业务流程的控制，结构较为混乱，并且也不是我们所希望的松耦合架构模式，所以当业务流程复杂的时候并不推荐使用。

Servlet+JSP+JavaBean

Servlet+JSP+JavaBean 中 Servlet 用于处理用户请求，JSP 用于数据显示，JavaBean 用于数据封装，适合复杂的 Web 程序。

相比 JSP+JavaBean 模式来说，Servlet+JSP+JavaBean 模式将控制层单独划分出来负责业务流程的控制，接收请求，创建所需的 JavaBean 实例，并将处理后的数据返回视图层（JSP）进行界面数据展示。

Servlet+JSP+JavaBean 模式的结构清晰，是一个松耦合架构模式，一般情况下，建议使用该模式。

MVC优缺点

任何一件事都有利有弊，下面来了解一下 MVC 的优缺点。

优点

  • 多视图共享一个模型，大大提高了代码的可重用性
  • MVC 三个模块相互独立，松耦合架构
  • 控制器提高了应用程序的灵活性和可配置性
  • 有利于软件工程化管理

总之，我们通过 MVC 设计模式最终可以打造出一个松耦合+高可重用性+高可适用性的完美架构。

缺点

  • 原理复杂
  • 增加了系统结构和实现的复杂性
  • 视图对模型数据的低效率访问

MVC 并不适合小型甚至中型规模的项目，花费大量时间将 MVC 应用到规模并不是很大的应用程序，通常得不偿失，所以对于 MVC 设计模式的使用要根据具体的应用场景来决定。

Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。

Spring MVC 是结构最清晰的 Servlet+JSP+JavaBean 的实现，是一个典型的教科书式的 MVC 构架，不像 Struts 等其它框架都是变种或者不是完全基于 MVC 系统的框架。

Spring MVC 角色划分清晰，分工明细，并且和 Spring 框架无缝结合。Spring MVC 是当今业界最主流的 Web 开发框架，以及最热门的开发技能。

在 Spring MVC 框架中，Controller 替换 Servlet 来担负控制器的职责，用于接收请求，调用相应的 Model 进行处理，处理器完成业务处理后返回处理结果。Controller 调用相应的 View 并对处理结果进行视图渲染，最终客户端得到响应信息。

Spring MVC 框架采用松耦合可插拔的组件结构，具有高度可配置性，比起其它 MVC 框架更具有扩展性和灵活性。

此外，Spring MVC 的注解驱动和对 REST 风格的支持，也是它最具特色的功能。无论是在框架设计，还是扩展性、灵活性等方面都全面超越了 Struts2 等 MVC 框架。并且由于 Spring MVC 本身就是 Spring 框架的一部分，所以可以说与 Spring 框架是无缝集成，性能方面具有先天的优越性，对于开发者来说，开发效率也高于其它的 Web 框架，在企业中的应用越来越广泛，成为主流的 MVC 框架。

Spring MVC优点

  • 清晰地角色划分，Spring MVC 在 Model、View 和 Controller 方面提供了一个非常清晰的角色划分，这 3 个方面真正是各司其职，各负其责。
  • 灵活的配置功能，可以把类当作 Bean 通过 XML 进行配置。
  • 提供了大量的控制器接口和实现类，开发者可以使用 Spring 提供的控制器实现类，也可以自己实现控制器接口。
  • 真正做到与 View 层的实现无关。它不会强制开发者使用 JSP，可以根据项目需求使用 Velocity、FreeMarker 等技术。
  • 国际化支持
  • 面向接口编程
  • 与 Spring 框架无缝集成

Spring MVC和Struts2的区别

Spring MVC 和 Struts2 类似，是一款基于传统 MVC 设计模式的 Java EE 框架。它的核心是一个弹性的控制层，能够很好地发挥 MVC 模式的“分离显示逻辑和业务逻辑”的能力。

而近年来越来越多的开发者选择使用 Spring MVC 技术来代替 Struts2 技术，那么相比于 Struts2 框架，Spring MVC 的优点在哪里呢？

下面来分析一下两者的区别。

1. Spring MVC 基于方法开发，Struts2 基于类开发。

在使用 Spring MVC 框架进行开发时，会将 URL 请求路径与 Controller 类的某个方法进行绑定，请求参数作为该方法的形参。当用户请求该 URL 路径时， Spring MVC 会将 URL 信息与 Controller 类的某个方法进行映射，生成 Handler 对象，该对象中只包含了一个 method 方法。方法执行结束之后，形参数据也会被销毁。

而在使用 Struts2 框架进行开发时，Action 类中所有方法使用的请求参数都是 Action 类中的成员变量，随着方法变得越来越多，就很难分清楚 Action 中那么多的成员变量到底是给哪一个方法使用的，整个 Action 类会变得十分混乱。

相比较而言，Spring MVC 优点是其所有请求参数都会被定义为相应方法的形参，用户在网页上的请求路径会被映射到 Controller 类对应的方法上，此时请求参数会注入到对应方法的形参上。Spring MVC 的这种开发方式类似于 Service 开发。

2. Spring MVC 可以进行单例开发，Struts2 无法使用单例

Spring MVC 支持单例开发模式，而 Struts2 由于只能通过类的成员变量接受参数，所以无法使用单例模式，只能使用多例。

3. 经过专业人员的大量测试，Struts2 的处理速度要比 SpringMVC 慢，原因是 Struts2 使用了 Struts 标签，Struts 标签由于设计原因，会出现加载数据慢的情况

这里仅仅比较了 Spring MVC 在某些方面相比 Struts2 的优势，但这并不能说明 Spring MVC 比 Struts2 优秀，仅仅因为早期 Struts2 使用广泛，所以出现的漏洞也比较多，但是在新版本的 Struts2 中也修复了许多漏洞。Spring MVC 自诞生以来，几乎没有什么致命的漏洞 。且 Spring MVC 基于方法开发，这一点较接近 Service 开发，这也是 Spring MVC 近年来备受关注的原因之一。

Spring MVC视图解析器（ViewResolver）

视图解析器（ViewResolver）是 Spring MVC 的重要组成部分，负责将逻辑视图名解析为具体的视图对象。

Spring MVC 提供了很多视图解析类，其中每一项都对应 Java Web 应用中特定的某些视图技术。下面介绍一些常用的视图解析类。

二、常用视图和视图解析器
XmlViewResolver
接口 ViewResolver 的实现，从 XML 配置文件中查找视图实现（默认 XML 配置文件为 /WEB-INF/views.xml）
ResourceBundleViewResolver
接口 ViewResolver 的实现，用于从 properties 文件中查找视图
UrlBasedViewResolver
接口 ViewResolver 的实现，用于根据请求的 URL 路径返回相应的视图，该视图需为抽象类 AbstractUrlBasedView 的实现，它还有些子类，如 InternalResourceView 和 JstlView 等 .
InternalResourceViewResolver
UrlBasedViewResolver 的子类，通常用于查找 JSP（类 InternalResourceView）和 JSTL（类 JstlView，InternalResourceView 的子类）等视图
VelocityViewResolver /FreeMarkerViewResolver
UrlBasedViewResolver 的子类分别用于支持 Velocity（类 VelocityView）和 FreeMark 视图（类 FreeMarkerView）
ContentNegotiatingViewResolver
接口 ViewResolver 的实现，用于根据请求文件的后缀名或请求的 header 中的 accept 字段查找视图
对于控制器的目标方法，无论其返回值是String、View、ModelMap或是ModelAndView，SpringMVC都会在内部将它们封装为一个ModelAndView对象进行返回。
Spring MVC 借助视图解析器（ViewResolver）得到最终的视图对象（View），最终的视图可以是JSP也可是Excell、 JFreeChart等各种表现形式的视图。
三、SpringMVC的视图解析流程
　　SpringMVC的视图解析流程为：
1、调用目标方法，SpringMVC将目标方法返回的String、View、ModelMap或是ModelAndView都转换为一个ModelAndView对象；
2、然后通过视图解析器（ViewResolver）对ModelAndView对象中的View对象进行解析，将该逻辑视图View对象解析为一个物理视图View对象；
3、最后调用物理视图View对象的render()方法进行视图渲染，得到响应结果。
视图（View）
　　视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。
　　为了实现视图模型和具体实现技术的解耦，Spring在org.springframework.web.servlet包中定义了一个高度抽象的View接口。
　　视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题。所谓视图是无状态的，是指对于每一个请求，都会创建一个View对象。
　　JSP是最常见的视图技术。
视图解析器（ViewResolver）
　　视图解析器的作用是将逻辑视图转为物理视图，所有的视图解析器都必须实现ViewResolver接口。
　　 SpringMVC为逻辑视图名的解析提供了不同的策略，可以在Spring WEB上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。程序员可以选择一种视图解析器或混用多种视图解析器。可以通过order属性指定解析器的优先顺序，order越小优先级越高，SpringMVC会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则抛出ServletException异常。

URLBasedViewResolver

UrlBasedViewResolver 是对 ViewResolver 的一种简单实现，主要提供了一种拼接 URL 的方式来解析视图。

UrlBasedViewResolver 通过 prefix 属性指定前缀，suffix 属性指定后缀。当 ModelAndView 对象返回具体的 View 名称时，它会将前缀 prefix 和后缀 suffix 与具体的视图名称拼接，得到一个视图资源文件的具体加载路径，从而加载真正的视图文件并反馈给用户。

使用 UrlBasedViewResolver 除了要配置前缀和后缀属性之外，还需要配置“viewClass”，表示解析成哪种视图。示例代码如下。

  1. <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
  2. <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceViewResolver"/> <!--不能省略-->
  3. <!--前缀-->
  4. <property name="prefix" value="/WEB-INF/jsp/"/>
  5. <!--后缀-->
  6. <property name="suffix" value=".jsp"/>
  7. </bean>

上述视图解析器配置了前缀和后缀两个属性，这样缩短了 view 路径。因此《第一个Spring MVC应用》一节中的 RegisterController 和 LoginController 控制器类的视图路径仅需提供 register 和 login，视图解析器将会自动添加前缀和后缀，此处解析为 /WEB-INF/jsp/register.jsp 和 /WEB-INF/jsp/login.jsp。

上述 viewClass 值为 InternalResourceViewResolver，它用来展示 JSP 页面。如果需要使用 jstl 标签展示数据，将 viewClass 属性值指定为 JstlView 即可。

另外，存放在 /WEB-INF/ 目录下的内容不能直接通过 request 请求得到，所以为了安全性考虑，通常把 jsp 文件放在 WEB-INF 目录下。

InternalResourceViewResolver

InternalResourceViewResolver 为“内部资源视图解析器”，是日常开发中最常用的视图解析器类型。它是 URLBasedViewResolver 的子类，拥有 URLBasedViewResolver 的一切特性。

InternalResourceViewResolver 能自动将返回的视图名称解析为 InternalResourceView 类型的对象。InternalResourceView 会把 Controller 处理器方法返回的模型属性都存放到对应的 request 属性中，然后通过 RequestDispatcher 在服务器端把请求 forword 重定向到目标 URL。也就是说，使用 InternalResourceViewResolver 视图解析时，无需再单独指定 viewClass 属性。示例代码如下。

  1. <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  2. <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceViewResolver"/> <!--可以省略-->
  3. <!--前缀-->
  4. <property name="prefix" value="/WEB-INF/jsp/"/>
  5. <!--后缀-->
  6. <property name="suffix" value=".jsp"/>
  7. </bean>

FreeMarkerViewResolver

FreeMarkerViewResolver 是 UrlBasedViewResolver 的子类，可以通过 prefix 属性指定前缀，通过 suffix 属性指定后缀。

FreeMarkerViewResolver 最终会解析逻辑视图配置，返回 freemarker 模板。不需要指定 viewClass 属性。

FreeMarkerViewResolver 配置如下。

  1. <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
  2. <property name="prefix" value="fm_"/>
  3. <property name="suffix" value=".ftl"/>
  4. </bean>

下面指定 FreeMarkerView 类型最终生成的实体视图（模板文件）的路径以及其他配置。需要给 FreeMarkerViewResolver 设置一个 FreeMarkerConfig 的 bean 对象来定义 FreeMarker 的配置信息，代码如下。

  1. <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
  2. <property name="templateLoaderPath" value="/WEB-INF/ftl" />
  3. </bean>

定义了 templateLoaderPath 属性后，Spring 可以通过该属性找到 FreeMarker 模板文件的具体位置。当有模板位于不同的路径时，可以配置 templateLoaderPath 属性，来指定多个资源路径。

然后定义一个 Controller，让其返回 ModelAndView，同时定义一些返回参数和视图信息。

  1. @Controller
  2. @RequestMapping("viewtest")
  3. public class ViewController {
  4. @RequestMapping("freemarker")
  5. public ModelAndView freemarker() {
  6. ModelAndView mv = new ModelAndView();
  7. mv.addObject("username", "BianChengBang");
  8. mv.setViewName("freemarker");
  9. return mv;
  10. }
  11. }

当 FreeMarkerViewResolver 解析逻辑视图信息时，会生成一个 URL 为“前缀+视图名+后缀”（这里即“fm_freemarker.ftl”）的 FreeMarkerView 对象，然后通过 FreeMarkerConfigurer 的配置找到 templateLoaderPath 对应文本文件的路径，在该路径下找到该文本文件，从而 FreeMarkerView 就可以利用该模板文件进行视图的渲染，并将 model 数据封装到即将要显示的页面上，最终展示给用户。

在 /WEB-INF/ftl 文件夹下创建 fm_freemarker.ftl，代码如下。

  1. <html>
  2. <head>
  3. <title>FreeMarker</title>
  4. </head>
  5. <body>
  6. <b>Welcome!</b>
  7. <i>${username }</i>
  8. </body>
  9. </html>

最终返回给用户的视图如下所示。

Spring MVC执行流程

Spring MVC 框架是高度可配置的，包含多种视图技术，例如 JSP、FreeMarker、Tiles、iText 和 POI。Spring MVC 框架并不关心使用的视图技术，也不会强迫开发者只使用 JSP。

Spring MVC 执行流程

Spring MVC 执行流程如图 1 所示。

 

 

SpringMVC 的执行流程如下。

  1. 用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）；
  2. 由 DispatcherServlet 请求一个或多个 HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）。
  3. DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；
  4. HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）；
  5. Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC的底层对象，包括 Model 数据模型和 View 视图信息）；
  6. HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；
  7. DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析；
  8. ViewResolver 根据 View 信息匹配到相应的视图结果，并返回给 DispatcherServlet；
  9. DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；
  10. 视图负责将结果显示到浏览器（客户端）。

Spring MVC接口

Spring MVC 涉及到的组件有 DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）、HandlerAdapter（处理器适配器）、Handler（处理器）、ViewResolver（视图解析器）和 View（视图）。下面对各个组件的功能说明如下。

1）DispatcherServlet

DispatcherServlet 是前端控制器，从图 1 可以看出，Spring MVC 的所有请求都要经过 DispatcherServlet 来统一分发。DispatcherServlet 相当于一个转发器或中央处理器，控制整个流程的执行，对各个组件进行统一调度，以降低组件之间的耦合性，有利于组件之间的拓展。

2）HandlerMapping

HandlerMapping 是处理器映射器，其作用是根据请求的 URL 路径，通过注解或者 XML 配置，寻找匹配的处理器（Handler）信息。

3）HandlerAdapter

HandlerAdapter 是处理器适配器，其作用是根据映射器找到的处理器（Handler）信息，按照特定规则执行相关的处理器（Handler）。

一.HandlerAdapter是什么？
HandlerAdapter处理器适配，因为handlerMapping有好几种类型，有方法级别、有controller级别的、有静态资源，具体执行方式不统一，提供适配器包一层，让DispatcherServlet代码更干净，不会出现if else的分支判断；扩展性更好，增加handlerMapping/HandlerAdapter，可以实现对DispatcherServlet来说无感知

二.HandlerAdapter怎么来的？
1.DispatcherServlet调用init()方法时，如果允许全部的处理器（detectAllHandlerAdapters为true），则从spring ioc容器中取出所有detectAllHandlerAdapters类型的对象，并排序（所以HandlerAdapter的实例对象要实现Ordered排序接口）

2.sping ioc怎么会有HandlerAdapter的？
@EnableAutoConfiguration-->autoconfigure项目META-INF\spring.factories-->WebMvcAutoConfiguration配置类中在ioc容器中实例化了四个HandlerAdapter实例对象，RequestMappingHandlerAdapter（对方法级别的适配）、 HandlerFunctionAdapter、HttpRequestHandlerAdapter（加载静态资源返回给请求者，没有后续视图解析和渲染的过程）、 SimpleControllerHandlerAdapter（对controller级别的适配）

3.具体作用
HandlerAdapter接口有三个方法，supports判断是否支持的handler类型；ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);//调用handler，让handler去处理请求，返回结果；getLastModified得到上次修改时间 ，实现简单缓存

4）Handler

Handler 是处理器，和 Java Servlet 扮演的角色一致。其作用是执行相关的请求处理逻辑，并返回相应的数据和视图信息，将其封装至 ModelAndView 对象中。

5）View Resolver

View Resolver 是视图解析器，其作用是进行解析操作，通过 ModelAndView 对象中的 View 信息将逻辑视图名解析成真正的视图 View（如通过一个 JSP 路径返回一个真正的 JSP 页面）。

6）View

View 是视图，其本身是一个接口，实现类支持不同的 View 类型（JSP、FreeMarker、Excel 等）。
以上组件中，需要开发人员进行开发的是处理器（Handler，常称Controller）和视图（View）。通俗的说，要开发处理该请求的具体代码逻辑，以及最终展示给用户的界面。
注意：由于 Spring MVC 结构比较复杂，所以学习的时候也要掌握学习方法。首先要明确 Spring MVC 是一个工具，既然是工具，那么我们就需要先掌握工具的使用方法，不要陷入细节中，深入浅出，慢慢通过实际运用来加深对其的理解。

Spring MVC @Controller和@RequestMapping注解

Controller注解

@Controller 注解用于声明某类的实例是一个控制器。例如，在 net.biancheng.controller 包中创建控制器类 IndexController，示例代码如下。

  1. package net.biancheng.controller;
  3. import org.springframework.stereotype.Controller;
  5. @Controller
  6. public class IndexController {
  7. // 处理请求的方法
  8. }

Spring MVC 使用扫描机制找到应用中所有基于注解的控制器类，所以，为了让控制器类被 Spring MVC 框架扫描到，需要在配置文件中声明 spring-context，并使用 <context:component-scan/> 元素指定控制器类的基本包（请确保所有控制器类都在基本包及其子包下）。

例如，在 springmvcDemo 应用的配置文件 springmvc-servlet.xml 中添加以下代码：

  1. <!-- 使用扫描机制扫描控制器类，控制器类都在net.biancheng.controller包及其子包下 -->
  2. <context:component-scan base-package="net.biancheng.controller" />

RequestMapping注解

一个控制器内有多个处理请求的方法，如 UserController 里通常有增加用户、修改用户信息、删除指定用户、根据条件获取用户列表等。每个方法负责不同的请求操作，而 @RequestMapping 就负责将请求映射到对应的控制器方法上。

在基于注解的控制器类中可以为每个请求编写对应的处理方法。使用 @RequestMapping 注解将请求与处理方法一 一对应即可。

@RequestMapping 注解可用于类或方法上。用于类上，表示类中的所有响应请求的方法都以该地址作为父路径。

@RequestMapping 注解常用属性如下。

1. value 属性

value 属性是 @RequestMapping 注解的默认属性，因此如果只有 value 属性时，可以省略该属性名，如果有其它属性，则必须写上 value 属性名称。如下。

  • @RequestMapping(value="toUser")
  • @RequestMapping("toUser")

value 属性支持通配符匹配，如 @RequestMapping(value="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问。

2. path属性

path 属性和 value 属性都用来作为映射使用。即 @RequestMapping(value="toUser") 和 @RequestMapping(path="toUser") 都能访问 toUser() 方法。

path 属性支持通配符匹配，如 @RequestMapping(path="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问。

3. name属性

name属性相当于方法的注释，使方法更易理解。如 @RequestMapping(value = "toUser",name = "获取用户信息")。

4. method属性

method 属性用于表示该方法支持哪些 HTTP 请求。如果省略 method 属性，则说明该方法支持全部的 HTTP 请求。

@RequestMapping(value = "toUser",method = RequestMethod.GET) 表示该方法只支持 GET 请求。也可指定多个 HTTP 请求，如 @RequestMapping(value = "toUser",method = {RequestMethod.GET,RequestMethod.POST})，说明该方法同时支持 GET 和 POST 请求。

5. params属性

params 属性用于指定请求中规定的参数，代码如下。

  • @RequestMapping(value = "toUser",params = "type")
  • public String toUser() {
  • return "showUser";
  • }

以上代码表示请求中必须包含 type 参数时才能执行该请求。即 http://localhost:8080/toUser?type=xxx 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser 则不能正常访问 toUser() 方法。

  • @RequestMapping(value = "toUser",params = "type=1")
  • public String toUser() {
  • return "showUser";
  • }

以上代码表示请求中必须包含 type 参数，且 type 参数为 1 时才能够执行该请求。即 http://localhost:8080/toUser?type=1 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser?type=2 则不能正常访问 toUser() 方法。

6. header属性

header 属性表示请求中必须包含某些指定的 header 值。

@RequestMapping(value = "toUser",headers = "Referer=http://www.xxx.com") 表示请求的 header 中必须包含了指定的“Referer”请求头，以及值为“http://www.xxx.com”时，才能执行该请求。

7. consumers属性

consumers 属性用于指定处理请求的提交内容类型（Content-Type），例如：application/json、text/html。如 
@RequestMapping(value = "toUser",consumes = "application/json")。

8. produces属性

produces 属性用于指定返回的内容类型，返回的内容类型必须是 request 请求头（Accept）中所包含的类型。如 @RequestMapping(value = "toUser",produces = "application/json")。

除此之外，produces 属性还可以指定返回值的编码。如 @RequestMapping(value = "toUser",produces = "application/json,charset=utf-8")，表示返回 utf-8 编码。

使用 @RequestMapping 来完成映射，具体包括 4 个方面的信息项：请求 URL、请求参数、请求方法和请求头。

通过请求URL进行映射

1）方法级别注解

方法级别注解的示例代码如下。

  1. package net.biancheng.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  6. @Controller
  7. public class IndexController {
  8. @RequestMapping(value = "/index/login")
  9. public String login() {
  10. return "login";
  11. }
  13. @RequestMapping(value = "/index/register")
  14. public String register() {
  15. return "register";
  16. }
  17. }

上述示例中有两个 RequestMapping 注解语句，它们都作用在处理方法上。在整个 Web 项目中，@RequestMapping 映射的请求信息必须保证全局唯一。

用户可以使用如下 URL 访问 login 方法（请求处理方法），在访问 login 方法之前需要事先在 /WEB-INF/jsp/ 目录下创建 login.jsp。

http://localhost:8080/springmvcDemo/index/login

2）类级别注解

类级别注解的示例代码如下：

  1. package net.biancheng.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. @Controller
  6. @RequestMapping("/index")
  7. public class IndexController {
  8. @RequestMapping("/login")
  9. public String login() {
  10. return "login";
  11. }
  13. @RequestMapping("/register")
  14. public String register() {
  15. return "register";
  16. }
  17. }

在类级别注解的情况下，控制器类中的所有方法都将映射为类级别的请求。用户可以使用如下 URL 访问 login 方法。

http://localhost:8080/springmvcDemo/index/login

为了方便维护程序，建议开发者采用类级别注解，将相关处理放在同一个控制器类中。例如，对用户的增、删、改、查等处理方法都可以放在 UserController 控制类中。

通过请求参数、请求方法进行映射

@RequestMapping 除了可以使用请求 URL 映射请求之外，还可以使用请求参数、请求方法来映射请求，通过多个条件可以让请求映射更加精确。

  1. package net.biancheng.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  6. @Controller
  7. public class IndexController {
  8. @RequestMapping(value = "/index/success" method=RequestMethod.GET, Params="username")
  9. public String success(@RequestParam String username) {
  11. return "index";
  12. }

上述代码中，@RequestMapping 的 value 表示请求的 URL；method 表示请求方法，此处设置为 GET 请求，若是 POST 请求，则无法进入 success 这个处理方法中。params 表示请求参数，此处参数名为 username。

编写请求处理方法

在控制类中每个请求处理方法可以有多个不同类型的参数，以及一个多种类型的返回结果。

1）请求处理方法中常出现的参数类型

如果需要在请求处理方法中使用 Servlet API 类型，那么可以将这些类型作为请求处理方法的参数类型。Servlet API 参数类型的示例代码如下：

  1. package net.biancheng.controller;
  2. import javax.servlet.http.HttpSession;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. @Controller
  6. @RequestMapping("/index")
  7. public class IndexController {
  8. @RequestMapping("/login")
  9. public String login(HttpSession session,HttpServletRequest request) {
  10. session.setAttribute("skey", "session范围的值");
  11. session.setAttribute("rkey", "request范围的值");
  12. return "login";
  13. }
  14. }

除了 Servlet API 参数类型以外，还有输入输出流、表单实体类、注解类型、与 Spring 框架相关的类型等，这些类型在后续章节中使用时再详细介绍。

其中特别重要的类型是 org.springframework.ui.Model 类型，该类型是一个包含 Map 的 Spring MVC类型。在每次调用请求处理方法时 Spring MVC 都将创建 org.springframework.ui.Model 对象。Model 参数类型的示例代码如下：

  1. package net.biancheng.controller;
  2. import javax.servlet.http.HttpServletRequest;
  3. import javax.servlet.http.HttpSession;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.ui.Model;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. @Controller
  8. @RequestMapping("/index")
  9. public class IndexController {
  10. @RequestMapping("/register")
  11. public String register(Model model) {
  12. /*在视图中可以使用EL表达式${success}取出model中的值*/
  13. model.addAttribute("success", "注册成功");
  14. return "register";
  15. }
  16. }

2）请求处理方法常见的返回类型

请求处理方法可以返回如下类型的对象：

  • ModelAndView
  • Model
  • 包含模型属性的 Map
  • View
  • 代表逻辑视图名的 String
  • void
  • 其它任意Java类型

Spring MVC传递参数

Spring MVC Controller 接收请求参数的方式有很多种，有的适合 get 请求方式，有的适合 post 请求方式，有的两者都适合。主要有以下几种方式：

  • 通过实体 Bean 接收请求参数
  • 通过处理方法的形参接收请求参数
  • 通过 HttpServletRequest 接收请求参数
  • 通过 @PathVariable 接收 URL 中的请求参数
  • 通过 @RequestParam 接收请求参数
  • 通过 @ModelAttribute 接收请求参数


下面分别介绍这些方式，读者可以根据实际情况选择合适的接收方式。

通过实体Bean接收请求参数

实体 Bean 接收请求参数适用于 get 和 post 提交请求方式。需要注意，Bean 的属性名称必须与请求参数名称相同。示例代码如下。

  1. @RequestMapping("/login")
  2. public String login(User user, Model model) {
  3. if ("bianchengbang".equals(user.getName())
  4. && "123456".equals(user.getPwd())) {
  6. model.addAttribute("message", "登录成功");
  7. return "main"; // 登录成功，跳转到 main.jsp
  8. } else {
  9. model.addAttribute("message", "用户名或密码错误");
  10. return "login";
  11. }
  12. }

通过处理方法的形参接收请求参数

通过处理方法的形参接收请求参数就是直接把表单参数写在控制器类相应方法的形参中，即形参名称与请求参数名称完全相同。该接收参数方式适用于 get 和 post 提交请求方式。示例代码如下：

  1. @RequestMapping("/login")
  2. public String login(String name, String pwd, Model model) {
  3. if ("bianchengbang".equals(user.getName())
  4. && "123456".equals(user.getPwd())) {
  6. model.addAttribute("message", "登录成功");
  7. return "main"; // 登录成功，跳转到 main.jsp
  8. } else {
  9. model.addAttribute("message", "用户名或密码错误");
  10. return "login";
  11. }
  12. }

通过HttpServletRequest接收请求参数

通过 HttpServletRequest 接收请求参数适用于 get 和 post 提交请求方式，示例代码如下：

  1. @RequestMapping("/login")
  2. public String login(HttpServletRequest request, Model model) {
  3. String name = request.getParameter("name");
  4. String pwd = request.getParameter("pwd");
  6. if ("bianchengbang".equals(name)
  7. && "123456".equals(pwd)) {
  9. model.addAttribute("message", "登录成功");
  10. return "main"; // 登录成功，跳转到 main.jsp
  11. } else {
  12. model.addAttribute("message", "用户名或密码错误");
  13. return "login";
  14. }
  15. }

通过@PathVariable接收URL中的请求参数

通过 @PathVariable 获取 URL 中的参数，示例代码如下。

  1. @RequestMapping("/login/{name}/{pwd}")
  2. public String login(@PathVariable String name, @PathVariable String pwd, Model model) {
  4. if ("bianchengbang".equals(name)
  5. && "123456".equals(pwd)) {
  7. model.addAttribute("message", "登录成功");
  8. return "main"; // 登录成功，跳转到 main.jsp
  9. } else {
  10. model.addAttribute("message", "用户名或密码错误");
  11. return "login";
  12. }
  13. }

在访问“http://localhost:8080/springMVCDemo02/user/register/bianchengbang/123456”路径时，上述代码会自动将 URL 中的模板变量 {name} 和 {pwd} 绑定到通过 @PathVariable 注解的同名参数上，即 name=bianchengbang、pwd=123456。

通过@RequestParam接收请求参数

在方法入参处使用 @RequestParam 注解指定其对应的请求参数。@RequestParam 有以下三个参数：

  • value：参数名
  • required：是否必须，默认为 true，表示请求中必须包含对应的参数名，若不存在将抛出异常
  • defaultValue：参数默认值


通过 @RequestParam 接收请求参数适用于 get 和 post 提交请求方式，示例代码如下。

  1. @RequestMapping("/login")
  2. public String login(@RequestParam String name, @RequestParam String pwd, Model model) {
  4. if ("bianchengbang".equals(name)
  5. && "123456".equals(pwd)) {
  7. model.addAttribute("message", "登录成功");
  8. return "main"; // 登录成功，跳转到 main.jsp
  9. } else {
  10. model.addAttribute("message", "用户名或密码错误");
  11. return "login";
  12. }
  13. }

该方式与“通过处理方法的形参接收请求参数”部分的区别如下：当请求参数与接收参数名不一致时，“通过处理方法的形参接收请求参数”不会报 404 错误，而“通过 @RequestParam 接收请求参数”会报 404 错误。

通过@ModelAttribute接收请求参数

@ModelAttribute 注解用于将多个请求参数封装到一个实体对象中，从而简化数据绑定流程，而且自动暴露为模型数据，在视图页面展示时使用。

而“通过实体 Bean 接收请求参数”中只是将多个请求参数封装到一个实体对象，并不能暴露为模型数据（需要使用 model.addAttribute 语句才能暴露为模型数据，数据绑定与模型数据展示后面教程中会讲解）。

通过 @ModelAttribute 注解接收请求参数适用于 get 和 post 提交请求方式，示例代码如下。

纯文本复制
  1. @RequestMapping("/login")
  2. public String login(@ModelAttribute("user") User user, Model model) {
  4. if ("bianchengbang".equals(name)
  5. && "123456".equals(pwd)) {
  7. model.addAttribute("message", "登录成功");
  8. return "main"; // 登录成功，跳转到 main.jsp
  9. } else {
  10. model.addAttribute("message", "用户名或密码错误");
  11. return "login";
  12. }
  13. }

Spring MVC重定向和转发

Spring MVC 请求方式分为转发、重定向 2 种，分别使用 forward 和 redirect 关键字在 controller 层进行处理。

重定向是将用户从当前处理请求定向到另一个视图（例如 JSP）或处理请求，以前的请求（request）中存放的信息全部失效，并进入一个新的 request 作用域；转发是将用户对当前处理的请求转发给另一个视图或处理请求，以前的 request 中存放的信息不会失效。

转发是服务器行为，重定向是客户端行为。

1）转发过程

客户浏览器发送 http 请求，Web 服务器接受此请求，调用内部的一个方法在容器内部完成请求处理和转发动作，将目标资源发送给客户；在这里转发的路径必须是同一个 Web 容器下的 URL，其不能转向到其他的 Web 路径上，中间传递的是自己的容器内的 request。

在客户浏览器的地址栏中显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。

2）重定向过程

客户浏览器发送 http 请求，Web 服务器接受后发送 302 状态码响应及对应新的 location 给客户浏览器，客户浏览器发现是 302 响应，则自动再发送一个新的 http 请求，请求 URL 是新的 location 地址，服务器根据此请求寻找资源并发送给客户。

在这里 location 可以重定向到任意 URL，既然是浏览器重新发出了请求，那么就没有什么 request 传递的概念了。在客户浏览器的地址栏中显示的是其重定向的路径，客户可以观察到地址的变化。重定向行为是浏览器做了至少两次的访问请求。

在 Spring MVC 框架中，控制器类中处理方法的 return 语句默认就是转发实现，只不过实现的是转发到视图。示例代码如下：

  1. @RequestMapping("/register")
  2. public String register() {
  3. return "register"; //转发到register.jsp
  4. }

在 Spring MVC 框架中，重定向与转发的示例代码如下：

  1. package net.biancheng.controller;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  6. @Controller
  7. @RequestMapping("/index")
  8. public class IndexController {
  9. @RequestMapping("/login")
  10. public String login() {
  11. //转发到一个请求方法（同一个控制器类可以省略/index/）
  12. return "forward:/index/isLogin";
  13. }
  15. @RequestMapping("/isLogin")
  16. public String isLogin() {
  17. //重定向到一个请求方法
  18. return "redirect:/index/isRegister";
  19. }
  21. @RequestMapping("/isRegister")
  22. public String isRegister() {
  23. //转发到一个视图
  24. return "register";
  25. }
  26. }

在 Spring MVC 框架中，不管是重定向或转发，都需要符合视图解析器的配置，如果直接转发到一个不需要 DispatcherServlet 的资源，例如：

return "forward:/html/my.html";

则需要使用 mvc:resources 配置：

<mvc:resources location="/html/" mapping="/html/**" />

Spring MVC @Autowired和@Service注解

@Autowired 注解属于 org.springframework.beans.factory. annotation 包，可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。

@Service 注解属于 org.springframework.stereotype 包，会将标注类自动注册到 Spring 容器中。

在配置文件中需要添加 <component-scan/> 元素来扫描依赖基本包。

<mvc:annotation-driven />

<context:component-scan base-package="net.biancheng.service"/>

Spring MVC @ModelAttribute注解

本文介绍在 Spring MVC 中非常重要的注解 @ModelAttribute，用来将请求参数绑定到 Model 对象。

在 Controller 中使用 @ModelAttribute 时，有以下几种应用情况。

  • 应用在方法上
  • 应用在方法的参数上
  • 应用在方法上，并且方法也使用了 @RequestMapping


需要注意的是，因为模型对象要先于 controller 方法之前创建，所以被 @ModelAttribute 注解的方法会在 Controller 每个方法执行之前都执行。因此一个 Controller 映射多个 URL 时，要谨慎使用。

@ModelAttribute 和 @RequestMapping 注解同时应用在方法上时，有以下作用：

  1. 方法的返回值会存入到 Model 对象中，key 为 ModelAttribute 的 value 属性值。
  2. 方法的返回值不再是方法的访问路径，访问路径会变为 @RequestMapping 的 value 值，例如：@RequestMapping(value = "/index") 跳转的页面是 index.jsp 页面。


总而言之，@ModelAttribute 注解的使用方法有很多种，非常灵活，可以根据业务需求选择使用。

Model和ModelView的区别

Model：每次请求中都存在的默认参数，利用其 addAttribute() 方法即可将服务器的值传递到客户端页面中。

ModelAndView：包含 model 和 view 两部分，使用时需要自己实例化，利用 ModelMap 来传值，也可以设置 view 的名称。

Spring MVC类型转换器（Converter）

内置的类型转换器

在 Spring MVC 框架中，对于常用的数据类型，开发者无须创建自己的类型转换器，因为 Spring MVC 框架有许多内置的类型转换器用于完成常用的类型转换。Spring MVC 框架提供的内置类型转换包括以下几种类型。

1）标量转换器

名称作用
StringToBooleanConverter String 到 boolean 类型转换
ObjectToStringConverter Object 到 String 转换，调用 toString 方法转换
StringToNumberConverterFactory String 到数字转换（例如 Integer、Long 等）
NumberToNumberConverterFactory 数字子类型（基本类型）到数字类型（包装类型）转换
StringToCharacterConverter String 到 Character 转换，取字符串中的第一个字符
NumberToCharacterConverter 数字子类型到 Character 转换
CharacterToNumberFactory Character 到数字子类型转换
StringToEnumConverterFactory String 到枚举类型转换，通过 Enum.valueOf 将字符串转换为需要的枚举类型
EnumToStringConverter 枚举类型到 String 转换，返回枚举对象的 name 值
StringToLocaleConverter String 到 java.util.Locale 转换
PropertiesToStringConverter java.util.Properties 到 String 转换，默认通过 ISO-8859-1 解码
StringToPropertiesConverter String 到 java.util.Properties 转换，默认使用 ISO-8859-1 编码

2）集合、数组相关转换器

名称作用
ArrayToCollectionConverter 任意数组到任意集合（List、Set）转换
CollectionToArrayConverter 任意集合到任意数组转换
ArrayToArrayConverter 任意数组到任意数组转换
CollectionToCollectionConverter 集合之间的类型转换
MapToMapConverter Map之间的类型转换
ArrayToStringConverter 任意数组到 String 转换
StringToArrayConverter 字符串到数组的转换，默认通过“，”分割，且去除字符串两边的空格（trim）
ArrayToObjectConverter 任意数组到 Object 的转换，如果目标类型和源类型兼容，直接返回源对象；否则返回数组的第一个元素并进行类型转换
ObjectToArrayConverter Object 到单元素数组转换
CollectionToStringConverter 任意集合（List、Set）到 String 转换
StringToCollectionConverter String 到集合（List、Set）转换，默认通过“，”分割，且去除字符串两边的空格（trim）
CollectionToObjectConverter 任意集合到任意 Object 的转换，如果目标类型和源类型兼容，直接返回源对象；否则返回集合的第一个元素并进行类型转换
ObjectToCollectionConverter Object 到单元素集合的类型转换

类型转换是在视图与控制器相互传递数据时发生的。Spring MVC 框架对于基本类型（例如 int、long、float、double、boolean 以及 char 等）已经做好了基本类型转换。

Spring MVC数据格式化（Formatter）

内置的格式化转换器

Spring MVC 提供了几个内置的格式化转换器，具体如下。

  • NumberFormatter：实现 Number 与 String 之间的解析与格式化。
  • CurrencyFormatter：实现 Number 与 String 之间的解析与格式化（带货币符号）。
  • PercentFormatter：实现 Number 与 String 之间的解析与格式化（带百分数符号）。
  • DateFormatter：实现 Date 与 String 之间的解析与格式化。

Spring MVC表单标签库

我们在进行 Spring MVC 项目开发时，一般会使用 EL 表达式和 JSTL 标签来完成页面视图的开发。其实 Spring 也有自己的一套表单标签库，通过 Spring 表单标签，可以很容易地将模型数据中的命令对象绑定到 HTML 表单元素中。下面我们就通过一个示例来演示该标签库的用法。

首先和 JSTL 标签的使用方法相同，在使用 Spring 表单标签之前，必须在 JSP 页面开头处声明 taglib 指令，指令代码如下。

<%@ taglib prefix="fm" uri="http://www.springframework.org/tags/form"%>


常用的 Spring 表单标签如下表所示。

名称作用
form 渲染表单元素
input 输入框组件标签，渲染 <input type="text"/> 元素
password 密码框组件标签，渲染 <input type="password"/> 元素
hidden 隐藏框组件标签，渲染 <input type="hidden"/> 元素
textarea 多行输入框组件标签，渲染 textarea 元素
checkbox 复选框组件标签，渲染一个 <input type="checkbox"/> 元素
checkboxes 渲染多个 <input type="checkbox"/> 元素
radiobutton 单选框组件标签，渲染一个 <input type="radio"/> 元素
radiobuttons 渲染多个 <input type="radio"/> 元素
select 下拉列表组件标签，渲染一个选择元素
option 渲染一个选项元素
options 渲染多个选项元素
errors 显示表单数据校验所对应的错误信息

以上标签基本都拥有以下属性。

    • path：属性路径，表示表单对象属性，如 userName、userCode 等。
    • cssClass：表单组件对应的 CSS 样式类名。
    • cssErrorClass：当提交表单后报错（服务端错误），采用的 CSS 样式类。
    • cssStyle：表单组件对应的 CSS 样式。
    • htmlEscape：绑定的表单属性值是否要对 HTML 特殊字符进行转换，默认为 true。

Spring MVC JSON数据交互

Spring MVC 在数据绑定的过程中需要对传递数据的格式和类型进行转换，它既可以转换 String 等类型的数据，也可以转换 JSON 等其他类型的数据。本节将针对 Spring MVC 中 JSON 类型的数据交互进行讲解。

JSON 概述

JSON（JavaScript Object Notation, JS 对象标记）是一种轻量级的数据交换格式。与 XML 一样，JSON 也是基于纯文本的数据格式。它有对象结构和数组结构两种数据结构。

1）对象结构

对象结构以{开始、以}结束，中间部分由 0 个或多个以英文,分隔的 key/value 对构成，key 和 value 之间以英文:分隔。对象结构的语法结构如下：

{
    key1:value1,
    key2:value2,
    ...
}

其中，key 必须为 String 类型，value 可以是 String、Number、Object、Array 等数据类型。例如，一个 person 对象包含姓名、密码、年龄等信息，使用 JSON 的表示形式如下：

{
    "pname":"张三",
    "password":"123456",
    "page":40
}

2）数组结构

数组结构以[开始、以]结束，中间部分由 0 个或多个以英文,分隔的值的列表组成。数组结构的语法结构如下：

{
    value1,
    value2,
    ...
}

上述两种（对象、数组）数据结构也可以分别组合构成更加复杂的数据结构。例如，一个 student 对象包含 sno、sname、hobby 和 college 对象，其 JSON 的表示形式如下：

{
    "sno":"201802228888",
    "sname":"张三",
    "hobby":["篮球","足球"]，
    "college":{
        "cname":"清华大学",
        "city":"北京"
    }
}

JSON 数据转换

为实现浏览器与控制器类之间的 JSON 数据交互，Spring MVC 提供了 MappingJackson2HttpMessageConverter 实现类默认处理 JSON 格式请求响应。该实现类利用 Jackson 开源包读写 JSON 数据，将 Java 对象转换为 JSON 对象和 XML 文档，同时也可以将 JSON 对象和 XML 文档转换为 Java 对象。

在使用注解开发时需要用到两个重要的 JSON 格式转换注解，分别是 @RequestBody 和 @ResponseBody。

  • @RequestBody：用于将请求体中的数据绑定到方法的形参中，该注解应用在方法的形参上。
  • @ResponseBody：用于直接返回 return 对象，该注解应用在方法上。


需要注意的是，在该处理方法上，除了通过 @RequestMapping 指定请求的 URL，还有一个 @ResponseBody 注解。该注解的作用是将标注该注解的处理方法的返回结果直接写入 HTTP Response Body（Response 对象的 body 数据区）中。一般情况下，@ResponseBody 都会在异步获取数据时使用，被其标注的处理方法返回的数据都将输出到响应流中，客户端获取并显示数据。

各个JSON技术比较

早期 JSON 的组装和解析都是通过手动编写代码来实现的，这种方式效率不高，所以后来有许多的关于组装和解析 JSON 格式信息的工具类出现，如 json-lib、Jackson、Gson 和 FastJson 等，可以解决 JSON 交互的开发效率。

1）json-lib

json-lib 最早也是应用广泛的 JSON 解析工具，缺点是依赖很多的第三方包，如 commons-beanutils.jar、commons-collections-3.2.jar、commons-lang-2.6.jar、commons-logging-1.1.1.jar、ezmorph-1.0.6.jar 等。

对于复杂类型的转换，json-lib 在将 JSON 转换成 Bean 时还有缺陷，比如一个类里包含另一个类的 List 或者 Map 集合，json-lib 从 JSON 到 Bean 的转换就会出现问题。

所以 json-lib 在功能和性能上面都不能满足现在互联网化的需求。

2）开源的Jackson

开源的 Jackson 是 Spring MVC 内置的 JSON 转换工具。相比 json-lib 框架，Jackson 所依赖 jar 文件较少，简单易用并且性能也要相对高些。并且 Jackson 社区相对比较活跃，更新速度也比较快。

但是 Jackson 对于复杂类型的 JSON 转换 Bean 会出现问题，一些集合 Map、List 的转换出现问题。而 Jackson 对于复杂类型的 Bean 转换 JSON，转换的 JSON 格式不是标准的 JSON 格式。

3）Google的Gson

Gson 是目前功能最全的 JSON 解析神器，Gson 当初是应 Google 公司内部需求由 Google 自行研发。自从在 2008 年 5 月公开发布第一版后，Gson 就已经被许多公司或用户应用。

Gson 主要提供了 toJson 与 fromJson 两个转换函数，不需要依赖其它的 jar 文件，就能直接在 JDK 上运行。在使用这两个函数转换之前，需要先创建好对象的类型以及其成员才能成功的将 JSON 字符串转换为相对应的对象。

类里面只要有 get 和 set 方法，Gson 完全可以将复杂类型的 JSON 到 Bean 或 Bean 到 JSON 的转换，是 JSON 解析的神器。Gson 在功能上面无可挑剔，但性能比 FastJson 有所差距。

4）阿里巴巴的FastJson

FastJson 是用 Java 语言编写的高性能 JSON 处理器，由阿里巴巴公司开发。

FastJson 不需要依赖其它的 jar 文件，就能直接在 JDK 上运行。

FastJson 在复杂类型的 Bean 转换 JSON 上会出现一些问题，可能会出现引用的类型，导致 JSON 转换出错，需要制定引用。

FastJson 采用独创的算法，将 parse 的速度提升到极致，超过所有 JSON 库。

综上 4 种 JSON 技术的比较，在项目选型的时候可以使用 Google 的 Gson 和阿里巴巴的 FastJson 两种并行使用，如果只是功能要求，没有性能要求，可以使用Google 的 Gson。如果有性能上面的要求可以使用 Gson 将 Bean 转换 JSON 确保数据的正确，使用 FastJson 将 JSON 转换 Bean。

示例

本节示例基于阿里巴巴提供的 FastJson。下面结合具体需求演示 Spring MVC 如何处理 JSON 格式数据。（本节代码基于《》一节的 springmvcDemo2 实现）

1. 导入jar文件

导入所需 jar 包 fastjson-1.2.62.jar，下载地址：https://github.com/alibaba/fastjson/releases。

Maven 项目在 pom.xml 文件中添加以下依赖。

  1. <!-- fastjson -->
  2. <dependency>
  3. <groupId>com.alibaba</groupId>
  4. <artifactId>fastjson</artifactId>
  5. <version>1.2.62</version>
  6. </dependency>

2. 配置Spring MVC核心配置文件

在 springmvc-servlet.xml 中添加以下代码。

纯文本复制
  1. <mvc:annotation-driven>
  2. <!--配置@ResponseBody由fastjson解析 -->
  3. <mvc:message-converters>
  4. <bean
  5. class="org.springframework.http.converter.StringHttpMessageConverter">
  6. <property name="defaultCharset" value="UTF-8" />
  7. </bean>
  8. <bean
  9. class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter4" />
  10. </mvc:message-converters>
  11. </mvc:annotation-driven>
  12. <mvc:default-servlet-handler />
  13. <bean id="fastJsonpResponseBodyAdvice"
  14. class="com.alibaba.fastjson.support.spring.FastJsonpResponseBodyAdvice">
  15. <constructor-arg>
  16. <list>
  17. <value>callback</value>
  18. <value>jsonp</value>
  19. </list>
  20. </constructor-arg>
  21. </bean>
  22. <!-- annotation-driven用于简化开发的配置，注解DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter -->
  23. <!-- 使用resources过滤掉不需要dispatcherservlet的资源（即静态资源，例如css、js、html、images）。
  24. 在使用resources时必须使用annotation-driven，否则resources元素会阻止任意控制器被调用 -->
  25. <!-- 允许js目录下的所有文件可见 -->
  26. <mvc:resources location="/" mapping="/**" />

Spring MVC拦截器（Interceptor）

Spring MVC 提供了 Interceptor 拦截器机制，用于请求的预处理和后处理。

在开发一个网站时可能有这样的需求：某些页面只希望几个特定的用户浏览。对于这样的访问权限控制，应该如何实现呢？拦截器就可以实现上述需求。在 Struts2 框架中，拦截器是其重要的组成部分，Spring MVC 框架也提供了拦截器功能。

Spring MVC 的拦截器（Interceptor）与 Java Servlet 的过滤器（Filter）类似，它主要用于拦截用户的请求并做相应的处理，通常应用在权限验证、记录请求信息的日志、判断用户是否登录等功能上。

拦截器的定义

在 Spring MVC 框架中定义一个拦截器需要对拦截器进行定义和配置，主要有以下 2 种方式。

  1. 通过实现 HandlerInterceptor 接口或继承 HandlerInterceptor 接口的实现类（例如 HandlerInterceptorAdapter）来定义；
  2. 通过实现 WebRequestInterceptor 接口或继承 WebRequestInterceptor 接口的实现类来定义。


本节以实现 HandlerInterceptor 接口的定义方式为例讲解自定义拦截器的使用方法。示例代码如下。

  1. package net.biancheng.interceptor;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  6. import org.springframework.web.servlet.HandlerInterceptor;
  7. import org.springframework.web.servlet.ModelAndView;
  9. public class TestInterceptor implements HandlerInterceptor {
  10. @Override
  11. public void afterCompletion(HttpServletRequest request,
  12. HttpServletResponse response, Object handler, Exception ex)
  13. throws Exception {
  14. System.out.println("afterCompletion方法在控制器的处理请求方法执行完成后执行，即视图渲染结束之后执行");
  16. }
  18. @Override
  19. public void postHandle(HttpServletRequest request,
  20. HttpServletResponse response, Object handler,
  21. ModelAndView modelAndView) throws Exception {
  22. System.out.println("postHandle方法在控制器的处理请求方法调用之后，解析视图之前执行");
  23. }
  25. @Override
  26. public boolean preHandle(HttpServletRequest request,
  27. HttpServletResponse response, Object handler) throws Exception {
  28. System.out.println("preHandle方法在控制器的处理请求方法调用之前执行");
  29. return false;
  30. }
  31. }

上述拦截器的定义中实现了 HandlerInterceptor 接口，并实现了接口中的 3 个方法，说明如下。

  • preHandle( )：该方法在控制器的处理请求方法前执行，其返回值表示是否中断后续操作，返回 true 表示继续向下执行，返回 false 表示中断后续操作。
  • postHandle( )：该方法在控制器的处理请求方法调用之后、解析视图之前执行，可以通过此方法对请求域中的模型和视图做进一步的修改。
  • afterCompletion( )：该方法在控制器的处理请求方法执行完成后执行，即视图渲染结束后执行，可以通过此方法实现一些资源清理、记录日志信息等工作。

拦截器的配置

让自定义的拦截器生效需要在 Spring MVC 的配置文件中进行配置，配置示例代码如下：

纯文本复制
  1. <!-- 配置拦截器 -->
  2. <mvc:interceptors>
  3. <!-- 配置一个全局拦截器，拦截所有请求 -->
  4. <bean class="net.biancheng.interceptor.TestInterceptor" />
  5. <mvc:interceptor>
  6. <!-- 配置拦截器作用的路径 -->
  7. <mvc:mapping path="/**" />
  8. <!-- 配置不需要拦截作用的路径 -->
  9. <mvc:exclude-mapping path="" />
  10. <!-- 定义<mvc:interceptor>元素中，表示匹配指定路径的请求才进行拦截 -->
  11. <bean class="net.biancheng.interceptor.Interceptor1" />
  12. </mvc:interceptor>
  13. <mvc:interceptor>
  14. <!-- 配置拦截器作用的路径 -->
  15. <mvc:mapping path="/gotoTest" />
  16. <!-- 定义在<mvc:interceptor>元素中，表示匹配指定路径的请求才进行拦截 -->
  17. <bean class="net.biancheng.interceptor.Interceptor2" />
  18. </mvc:interceptor>
  19. </mvc:interceptors>

在上述示例代码中，元素说明如下。

  • <mvc:interceptors>：该元素用于配置一组拦截器。
  • <bean>：该元素是 <mvc:interceptors> 的子元素，用于定义全局拦截器，即拦截所有的请求。
  • <mvc:interceptor>：该元素用于定义指定路径的拦截器。
  • <mvc:mapping>：该元素是 <mvc:interceptor> 的子元素，用于配置拦截器作用的路径，该路径在其属性 path 中定义。path 的属性值为/**时，表示拦截所有路径，值为/gotoTest时，表示拦截所有以/gotoTest结尾的路径。如果在请求路径中包含不需要拦截的内容，可以通过 <mvc:exclude-mapping> 子元素进行配置。


需要注意的是，<mvc:interceptor> 元素的子元素必须按照 <mvc:mapping.../>、<mvc:exclude-mapping.../>、<bean.../> 的顺序配置。

Spring MVC数据校验

Spring MVC 有以下两种方法可以验证输入：

  • 利用 Spring 自带的验证框架
  • 利用 JSR 303 实现


数据验证分为客户端验证和服务器端验证，客户端验证主要是过滤正常用户的误操作，通过 JavaScript 代码完成。服务器端验证是整个应用阻止非法数据的最后防线，通过在应用中编程实现。

本节使用 JSR 303 实现服务器端的数据验证。

JSR 303 是 Java 为 Bean 数据合法性校验所提供的标准框架。JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对 Bean 进行验证。可以通过 https://jcp.org/en/jsr/detail?id=303 查看详细内容并下载 JSR 303 Bean Validation。

JSR 303 不需要编写验证器，它定义了一套可标注在成员变量、属性方法上的校验注解，如下表所示。

名称说明
@Null 被标注的元素必须为 null
@NotNull 被标注的元素必须不为 null
@AssertTrue 被标注的元素必须为 true
@AssertFalse 被标注的元素必须为 false
@Min(value) 被标注的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value) 被标注的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMax(value) 被标注的元素必须是一个数字，其值必须大于等于指定的最大值
@DecimalMin(value) 被标注的元素必须是一个数字，其值必须小于等于指定的最小值
@size 被标注的元素的大小必须在指定的范围内
@Digits（integer，fraction） 被标注的元素必须是一个数字，其值必须在可接受的范围内；integer 指定整数精度，fraction 指定小数精度
@Past 被标注的元素必须是一个过去的日期
@Future 被标注的元素必须是一个将来的日期
@Pattern(value) 被标注的元素必须符合指定的正则表达式

Spring MVC 支持 JSR 303 标准的校验框架，Spring 的 DataBinder 在进行数据绑定时，可同时调用校验框架来完成数据校验工作，非常简单方便。在 Spring MVC 中，可以直接通过注解驱动的方式来进行数据校验。

Spring 本身没有提供 JSR 303 的实现，Hibernate Validator 实现了 JSR 303，所以必须在项目中加入来自 Hibernate Validator 库的 jar 文件，下载地址为 http://hibernate.org/validator/。本节使用版本为 hibernate-validator-5.1.0.Final-dist.zip，复制其中的 3 个 jar 文件即可，Spring 将会自动加载并装配。

    • hibernate-validator-5.1.0.Final.jar
    • jboss-logging-3.1.0.CR2.jar
    • validation-api-1.0.0.GA.jar

1. 导入依赖

pom.xml 文件中添加以下代码。

  1. <!-- 数据校验 -->
  2. <dependency>
  3. <groupId>javax.validation</groupId>
  4. <artifactId>validation-api</artifactId>
  5. <version>1.1.0.Final</version>
  6. </dependency>
  7. <dependency>
  8. <groupId>org.jboss.logging</groupId>
  9. <artifactId>jboss-logging</artifactId>
  10. <version>3.1.0.CR2</version>
  11. </dependency>
  12. <dependency>
  13. <groupId>org.hibernate</groupId>
  14. <artifactId>hibernate-validator</artifactId>
  15. <version>5.1.0.Final</version>
  16. </dependency>

2. 创建实体类

创建 User 实体类，代码如下。

  1. package net.biancheng.po;
  3. import javax.validation.constraints.NotNull;
  5. import org.hibernate.validator.constraints.Email;
  6. import org.hibernate.validator.constraints.Length;
  8. public class User {
  9. @NotNull(message = "用户id不能为空")
  10. private Integer id;
  11. @NotNull
  12. @Length(min = 2, max = 8, message = "用户名不能少于2位大于8位")
  13. private String name;
  14. @Email(regexp = "[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]", message = "邮箱格式不正确")
  15. private String email;
  17. /** 省略setter和getter方法*/
  18. }

3. 创建JSP页面

创建 addUser.jsp，代码如下。

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2. pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>添加用户</title>
  8. </head>
  9. <body>
  10. <form action="${pageContext.request.contextPath}/validate" method="post">
  11. 用户id：<input type="text" name="id" />
  12. <br>
  13. 用户名：<input type="text" name="name" />
  14. <br>
  15. 邮箱：<input type="text" name="email" />
  16. <br>
  17. <input type="submit" value="提交" />
  18. </form>
  19. </body>
  20. </html>

4. 创建控制器

创建 UserController 控制器类，代码如下。

纯文本复制
  1. package net.biancheng.controller;
  3. import java.util.List;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpSession;
  7. import javax.validation.Valid;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.validation.BindingResult;
  11. import org.springframework.validation.ObjectError;
  12. import org.springframework.web.bind.annotation.PathVariable;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  14. import org.springframework.web.bind.annotation.RequestMethod;
  16. import net.biancheng.po.User;
  18. @Controller
  19. public class UserController {
  21. @RequestMapping("/validate")
  22. public String validate(@Valid User user, BindingResult result) {
  23. // 如果有异常信息
  24. if (result.hasErrors()) {
  25. // 获取异常信息对象
  26. List<ObjectError> errors = result.getAllErrors();
  27. // 将异常信息输出
  28. for (ObjectError error : errors) {
  29. System.out.println(error.getDefaultMessage());
  30. }
  31. }
  32. return "index";
  33. }
  35. @RequestMapping(value = "/addUser")
  36. public String add() {
  38. return "addUser";
  39. }
  40. }

5. 运行测试

访问地址：http://localhost:8080/springmvcDemo2/addUser，运行结果如下。

Spring MVC异常处理

Spring MVC 有以下 3 种处理异常的方式：

  1. 使用 Spring MVC 提供的简单异常处理器 SimpleMappingExceptionResolver。
  2. 实现 Spring 的异常处理接口 HandlerExceptionResolver，自定义自己的异常处理器。
  3. 使用 @ExceptionHandler 注解实现异常处理

1. @ExceptionHandler

局部异常处理仅能处理指定 Controller 中的异常。

示例 1：下面使用 @ExceptionHandler 注解实现。定义一个处理过程中可能会存在异常情况的 testExceptionHandle 方法。

  1. @RequestMapping("/testExceptionHandle")
  2. public String testExceptionHandle(@RequestParam("i") Integer i) {
  3. System.out.println(10 / i);
  4. return "success";
  5. }

显然，当 i=0 时会产生算术运算异常。

下面在同一个类中定义处理异常的方法。

  1. @ExceptionHandler({ ArithmeticException.class })
  2. public String testArithmeticException(Exception e) {
  3. System.out.println("打印错误信息 ===> ArithmeticException:" + e);
  4. // 跳转到指定页面
  5. return "error";
  6. }

注意：该注解不是加在产生异常的方法上，而是加在处理异常的方法上。

异常页面 error.jsp 代码如下。

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2. pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>错误页面</title>
  8. </head>
  9. <body>
  10. 发生算术运算异常，请重新输出数据！
  11. </body>
  12. </html>

访问地址：http://localhost:8080/springmvcDemo2/testExceptionHandle?i=0，页面跳转到 error.jsp 页面，运行结果如图 1 所示。

控制器输出结果如下。

打印错误信息 ===> ArithmeticException:java.lang.ArithmeticException: / by zero

@ExceptionHandler 注解定义的方法优先级问题：例如发生的是 NullPointerException，但是声明的异常有 RuntimeException 和 Exception，这时候会根据异常的最近继承关系找到继承深度最浅的那个@ExceptionHandler 注解方法，即标记了 RuntimeException 的方法。

被 @ExceptionHandler 标记为异常处理方法，不能在方法中设置别的形参。但是可以使用 ModelAndView 向前台传递数据。

使用局部异常处理，仅能处理某个 Controller 中的异常，若需要对所有异常进行统一处理，可使用以下两种方法。

2. HandlerExceptionResolver

Spring MVC 通过 HandlerExceptionResolver 处理程序异常，包括处理器异常、数据绑定异常以及控制器执行时发生的异常。HandlerExceptionResolver 仅有一个接口方法，源码如下。

  1. public interface HandlerExceptionResolver {
  2. @Nullable
  3. ModelAndView resolveException(
  4. HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
  5. }

发生异常时，Spring MVC 会调用 resolveException() 方法，并转到 ModelAndView 对应的视图中，返回一个异常报告页面反馈给用户。

示例 2：在 net.biancheng.exception 包中创建一个 HandlerExceptionResolver 接口的实现类 MyExceptionHandler，代码如下。

  1. package net.biancheng.exception;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  9. import org.springframework.web.servlet.HandlerExceptionResolver;
  10. import org.springframework.web.servlet.ModelAndView;
  12. public class MyExceptionHandler implements HandlerExceptionResolver {
  13. @Override
  14. public ModelAndView resolveException(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2,
  15. Exception arg3) {
  16. Map<String, Object> model = new HashMap<String, Object>();
  17. // 根据不同错误转向不同页面（统一处理），即异常与View的对应关系
  18. if (arg3 instanceof ArithmeticException) {
  19. return new ModelAndView("error", model);
  20. }
  21. return new ModelAndView("error-2", model);
  22. }
  23. }

在 springmvc-servlet.xml 文件中添加以下代码。

  1. <!--托管MyExceptionHandler-->
  2. <bean class="net.biancheng.exception.MyExceptionHandler"/>

再次访问 http://localhost:8080/springmvcDemo2/testExceptionHandle?i=0，页面跳转到 error.jsp 页面，运行结果如上图 1 所示。

3. SimpleMappingExceptionResolver

全局异常处理可使用 SimpleMappingExceptionResolver 来实现。它将异常类名映射为视图名，即发生异常时使用对应的视图报告异常。

示例 3：在 springmvc-servlet.xml 中配置全局异常，代码如下。

纯文本复制
  1. <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
  2. <!-- 定义默认的异常处理页面，当该异常类型注册时使用 -->
  3. <property name="defaultErrorView" value="error"></property>
  4. <!-- 定义异常处理页面用来获取异常信息的变量名，默认名为exception -->
  5. <property name="exceptionAttribute" value="ex"></property>
  6. <!-- 定义需要特殊处理的异常，用类名或完全路径名作为key，异常页名作为值 -->
  7. <property name="exceptionMappings">
  8. <props>
  9. <prop key="ArithmeticException">error</prop>
  10. <!-- 在这里还可以继续扩展对不同异常类型的处理 -->
  11. </props>
  12. </property>
  13. </bean>

再次访问 http://localhost:8080/springmvcDemo2/testExceptionHandle?i=0，页面跳转到 error.jsp 页面，运行结果如上图 1 所示。

Spring MVC REST风格

pring REST 风格可以简单理解为：使用 URL 表示资源时，每个资源都用一个独一无二的 URL 来表示，并使用 HTTP 方法表示操作，即准确描述服务器对资源的处理动作（GET、POST、PUT、DELETE），实现资源的增删改查。

  • GET：表示获取资源
  • POST：表示新建资源
  • PUT：表示更新资源
  • DELETE：表示删除资源


下面举例说明 REST 风格的 URL 与传统 URL 的区别。

/userview.html?id=12    VS     /user/view/12
/userdelete.html?id=12    VS     /user/delete/12
/usermodify.html?id=12    VS     /user/modify/12

我们发现 REST 风格的 URL 中最明显的就是参数不再使用“?”传递。这种风格的 URL 可读性更好，使得项目架构清晰，最关键的是 Spring MVC 也提供对这种风格的支持。

由于 HTTP 不支持 PUT 和 DELETE 请求，所以需要将 DELETE 和 PUT 请求转换成 POST 请求，在 web.xml 中配置过滤器 HiddenHttpMethodFilter。

纯文本复制
  1. <!-- HiddenHttpMethodFilter过滤器可以将POST请求转化为put请求和delete请求! -->
  2. <filter>
  3. <filter-name>hiddenHttpMethodFilter</filter-name>
  4. <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  5. </filter>
  6. <filter-mapping>
  7. <filter-name>hiddenHttpMethodFilter</filter-name>
  8. <url-pattern>/*</url-pattern>
  9. </filter-mapping>

Spring MVC文件上传

Spring MVC 框架的文件上传基于 commons-fileupload 组件，并在该组件上做了进一步的封装，简化了文件上传的代码实现，取消了不同上传组件上的编程差异。

MultipartResolver接口

在 Spring MVC 中实现文件上传十分容易，它为文件上传提供了直接支持，即 MultpartiResolver 接口。MultipartResolver 用于处理上传请求，将上传请求包装成可以直接获取文件的数据，从而方便操作。

MultpartiResolver 接口有以下两个实现类：

  • StandardServletMultipartResolver：使用了 Servlet 3.0 标准的上传方式。
  • CommonsMultipartResolver：使用了 Apache 的 commons-fileupload 来完成具体的上传操作。


MultpartiResolver 接口具有以下方法。

名称作用
byte[] getBytes() 以字节数组的形式返回文件的内容
String getContentType() 返回文件的内容类型
InputStream getInputStream() 返回一个InputStream，从中读取文件的内容
String getName() 返回请求参数的名称
String getOriginalFillename() 返回客户端提交的原始文件名称
long getSize() 返回文件的大小，单位为字节
boolean isEmpty() 判断被上传文件是否为空
void transferTo(File destination) 将上传文件保存到目标目录下


下面我们使用 CommonsMultipartResolver 来完成文件上传，分为单文件上传和多文件上传两部分介绍。

单文件上传

1. 导入 jar 文件

文件上传使用 Apache Commons FileUpload 组件，需要导入 commons-io-2.4.jar 和 commons-fileupload-1.2.2.jar 两个 jar 文件（可在 Apache 官网下载）。

Maven 项目在 pom.xml 文件中添加以下依赖。

  1. <dependency>
  2. <groupId>commons-io</groupId>
  3. <artifactId>commons-io</artifactId>
  4. <version>2.4</version>
  5. </dependency>
  7. <dependency>
  8. <groupId>commons-fileupload</groupId>
  9. <artifactId>commons-fileupload</artifactId>
  10. <version>1.2.2</version>
  11. </dependency>

2. 配置 MultipartResolver

使用 CommonsMultipartReslover 配置 MultipartResolver 解析器，在 springmvc-servlet.xml 中添加代码如下。

纯文本复制
  1. <!-- 配置MultipartResolver，用于上传文件，使用spring的CommonsMultipartResolver -->
  2. <bean id="multipartResolver"
  3. class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  4. <property name="maxUploadSize" value="5000000" />
  5. <property name="defaultEncoding" value="UTF-8" />
  6. </bean>
  • defaultEncoding：请求的编码格式，默认为 ISO-8859-1，此处设置为 UTF-8（注：defaultEncoding 必须和 JSP 中的 pageEncoding 一致，以便正确读取表单的内容）。
  • maxUploadSize：上传文件大小上限，单位为字节。

3. 编写文件上传表单页面

负责文件上传表单的编码类型必须是“multipart/form-data”类型。

fleUpload.jsp 代码如下。

纯文本复制
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2. pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>文件上传</title>
  8. </head>
  9. <body>
  10. <form action="${pageContext.request.contextPath }/fileupload"
  11. method="post" enctype="multipart/form-data">
  12. 选择文件：<input type="file" name="myfile"><br>
  13. 文件描述：<input type="text" name="description"><br>
  14. <input type="submit" value="提交">
  15. </form>
  16. </body>
  17. </html>

基于表单的文件上传需要使用 enctype 属性，并将它的值设置为 multipart/form-data，同时将表单的提交方式设置为 post。

表单的 enctype 属性指定的是表单数据的编码方式，该属性有以下 3 个值。

  • application/x-www-form-urlencoded：这是默认的编码方式，它只处理表单域里的 value 属性值。
  • multipart/form-data：该编码方式以二进制流的方式来处理表单数据，并将文件域指定文件的内容封装到请求参数里。
  • text/plain：该编码方式只有当表单的 action 属性为“mailto：”URL 的形式时才使用，主要适用于直接通过表单发送邮件的方式。

由上面 3 个属性的解释可知，在基于表单上传文件时 enctype 的属性值应为 multipart/form-data。

4. 创建POJO类

创建 net.biancheng.opjo 包，在该包下创建 FileDomain 类，在该 POJO 类中声明一个 MultipartFile 类型的属性封装被上传的文件信息，属性名与文件选择页面 filleUpload.jsp 中的 file 类型的表单参数名 myfile 相同，代码如下。

  1. package net.biancheng.po;
  3. import org.springframework.web.multipart.MultipartFile;
  5. public class FileDomain {
  6. private String description;
  7. private MultipartFile myfile;
  9. /** 省略setter和getter参数*/
  10. }

5. 编写控制器

创建 net.biancheng.controller 包，在该包下创建 FileUploadController 控制类，具体代码如下。

  1. package net.biancheng.controller;
  3. import java.io.File;
  5. import javax.servlet.http.HttpServletRequest;
  7. import org.apache.commons.logging.Log;
  8. import org.apache.commons.logging.LogFactory;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.ModelAttribute;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  13. import net.biancheng.po.FileDomain;
  15. @Controller
  16. public class FileUploadController {
  17. // 得到一个用来记录日志的对象，这样在打印信息时能够标记打印的是哪个类的信息
  18. private static final Log logger = LogFactory.getLog(FileUploadController.class);
  20. @RequestMapping("getFileUpload")
  21. public String getFileUpload() {
  22. return "fileUpload";
  23. }
  25. /**
  26. * 单文件上传
  27. */
  28. @RequestMapping("/fileupload")
  29. public String oneFileUpload(@ModelAttribute FileDomain fileDomain, HttpServletRequest request) {
  30. /*
  31. * 文件上传到服务器的位置“/uploadfiles”,该位置是指 workspace\.metadata\.plugins\org.eclipse
  32. * .wst.server.core\tmp0\wtpwebapps, 发布后使用
  33. */
  34. String realpath = request.getServletContext().getRealPath("uploadfiles");
  35. String fileName = fileDomain.getMyfile().getOriginalFilename();
  36. File targetFile = new File(realpath, fileName);
  37. if (!targetFile.exists()) {
  38. targetFile.mkdirs();
  39. }
  40. // 上传
  41. try {
  42. fileDomain.getMyfile().transferTo(targetFile);
  43. logger.info("成功");
  44. } catch (Exception e) {
  45. e.printStackTrace();
  46. }
  47. return "showFile";
  48. }
  49. }

6. 创建成功显示页面

showFile.jsp 代码如下。

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2. pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>文件上传</title>
  8. </head>
  9. <body>
  10. 文件描述：${fileDomain.description }
  11. <br>
  12. <!-- fileDomain.getMyFile().getOriginalFilename()-->
  13. 文件名称：${fileDomain.myfile.originalFilename }
  14. </body>
  15. </html>

7. 测试文件上传

访问地址：http://localhost:8080/springmvcDemo2/getFileUpload，运行结果如下。

Spring MVC文件下载

文件下载的实现方法

文件下载有以下两种实现方法：

  • 通过超链接实现下载：实现简单，但暴露了下载文件的真实位置，并且只能下载 Web 应用程序所在目录下的文件，WEB-INF 目录除外。
  • 利用程序编码实现下载：增强安全访问控制，可以下载除 Web 应用程序所在目录以外的文件，也可以将文件保存到数据库中。


利用程序编码实现下载需要设置以下两个报头：

  1. Web 服务器需要告诉浏览器其所输出内容的类型不是普通文本文件或 HTML 文件，而是一个要保存到本地的下载文件，这需要设置 Content-Type 的值为 application/x-msdownload。
  2. Web 服务器希望浏览器不直接处理相应的实体内容，而是由用户选择将相应的实体内容保存到一个文件中，这需要设置 Content-Disposition 报头。


该报头指定了接收程序处理数据内容的方式，在 HTTP 应用中只有 attachment 是标准方式，attachment 表示要求用户干预。在 attachment 后面还可以指定 filename 参数，该参数是服务器建议浏览器将实体内容保存到文件中的文件名称。

设置报头的示例如下：

response.setHeader("Content-Type", "application/x-msdownload");
response.setHeader("Content-Disposition", "attachment;filename="+filename);


程序编码文件下载可分为两个步骤：

    1. 在客户端使用一个文件下载超链接，链接指向后台下载文件的方法以及文件名。
    2. 在控制器类中，提供文件下载方法进行下载。

示例

下面继续通过 springMVCDemo2 应用讲述利用程序实现下载的过程，要求从《Spring MVC文件上传》上传文件的目录（workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\springMVCDemo2\uploadfiles）中下载文件，具体开发步骤如下。

1. 编写控制器类

首先编写控制器类 FileDownController，在该类中有 3 个方法，即 show、down 和 toUTF8String。其中，show 方法获取被下载的文件名称；down 方法执行下载功能；toUTF8String 方法是下载保存时中文文件名的字符编码转换方法。

FileDownController 类的代码如下：

  1. package controller;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.UnsupportedEncodingException;
  6. import java.util.ArrayList;
  7. import javax.servlet.ServletOutputStream;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import org.apache.commons.logging.Log;
  11. import org.apache.commons.logging.LogFactory;
  12. import org.springframework.stereotype.Controller;
  13. import org.springframework.ui.Model;
  14. import org.springframework.web.bind.annotation.RequestMapping;
  15. import org.springframework.web.bind.annotation.RequestParam;
  17. @Controller
  18. public class FileDownController {
  19. // 得到一个用来记录日志的对象，在打印时标记打印的是哪个类的信息
  20. private static final Log logger = LogFactory
  21. .getLog(FileDownController.class);
  23. /**
  24. * 显示要下载的文件
  25. */
  26. @RequestMapping("showDownFiles")
  27. public String show(HttpServletRequest request, Model model) {
  28. // 从 workspace\.metadata\.plugins\org.eclipse.wst.server.core\
  29. // tmp0\wtpwebapps\springMVCDemo11\下载
  30. String realpath = request.getServletContext()
  31. .getRealPath("uploadfiles");
  32. File dir = new File(realpath);
  33. File files[] = dir.listFiles();
  34. // 获取该目录下的所有文件名
  35. ArrayList<String> fileName = new ArrayList<String>();
  36. for (int i = 0; i < files.length; i++) {
  37. fileName.add(files[i].getName());
  38. }
  39. model.addAttribute("files", fileName);
  40. return "showDownFiles";
  41. }
  43. /**
  44. * 执行下载
  45. */
  46. @RequestMapping("down")
  47. public String down(@RequestParam String filename,
  48. HttpServletRequest request, HttpServletResponse response) {
  49. String aFilePath = null; // 要下载的文件路径
  50. FileInputStream in = null; // 输入流
  51. ServletOutputStream out = null; // 输出流
  52. try {
  53. // 从workspace\.metadata\.plugins\org.eclipse.wst.server.core\
  54. // tmp0\wtpwebapps下载
  55. aFilePath = request.getServletContext().getRealPath("uploadfiles");
  56. // 设置下载文件使用的报头
  57. response.setHeader("Content-Type", "application/x-msdownload");
  58. response.setHeader("Content-Disposition", "attachment; filename="
  59. + toUTF8String(filename));
  60. // 读入文件
  61. in = new FileInputStream(aFilePath + "\\" + filename);
  62. // 得到响应对象的输出流，用于向客户端输出二进制数据
  63. out = response.getOutputStream();
  64. out.flush();
  65. int aRead = 0;
  66. byte b[] = new byte[1024];
  67. while ((aRead = in.read(b)) != -1 & in != null) {
  68. out.write(b, 0, aRead);
  69. }
  70. out.flush();
  71. in.close();
  72. out.close();
  73. } catch (Throwable e) {
  74. e.printStackTrace();
  75. }
  76. logger.info("下载成功");
  77. return null;
  78. }
  80. /**
  81. * 下载保存时中文文件名的字符编码转换方法
  82. */
  83. public String toUTF8String(String str) {
  84. StringBuffer sb = new StringBuffer();
  85. int len = str.length();
  86. for (int i = 0; i < len; i++) {
  87. // 取出字符中的每个字符
  88. char c = str.charAt(i);
  89. // Unicode码值为0~255时，不做处理
  90. if (c >= 0 && c <= 255) {
  91. sb.append(c);
  92. } else { // 转换 UTF-8 编码
  93. byte b[];
  94. try {
  95. b = Character.toString(c).getBytes("UTF-8");
  96. } catch (UnsupportedEncodingException e) {
  97. e.printStackTrace();
  98. b = null;
  99. }
  100. // 转换为%HH的字符串形式
  101. for (int j = 0; j < b.length; j++) {
  102. int k = b[j];
  103. if (k < 0) {
  104. k &= 255;
  105. }
  106. sb.append("%" + Integer.toHexString(k).toUpperCase());
  107. }
  108. }
  109. }
  110. return sb.toString();
  111. }
  112. }

2. 创建文件列表页面

下载文件示例需要一个显示被下载文件的 JSP 页面 showDownFiles.jsp，代码如下：

纯文本复制
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2. pageEncoding="UTF-8"%>
  3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  4. <head>
  5. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  6. <title>Insert title here</title>
  7. </head>
  8. <body>
  9. <table>
  10. <tr>
  11. <td>被下载的文件名</td>
  12. </tr>
  13. <!--遍历 model中的 files-->
  14. <c:forEach items="${files}" var="filename">
  15. <tr>
  16. <td>
  17. <a href="${pageContext.request.contextPath }/down?filename=${filename}">${filename}</a>
  18. </td>
  19. </tr>
  20. </c:forEach>
  21. </table>
  22. </body>
  23. </html>

3. 测试下载功能

访问地址：http://localhost:8080/springmvcDemo2/showDownFiles，运行结果如下。

 

posted @ 2022-03-08 00:49  hanease  阅读(193)  评论(0)  编辑  收藏  举报