springmvc

Springmvc

1.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）：模型对象拥有最多的处理任务，是应用程序的主体部分，它负责数据逻辑（业务规则）的处理和实现数据操作（即在数据库中存取数据）。

2.springmvc是什么

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 框架。

springmvc优点

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

3.第一个Springmvc程序

搭建步骤如下：

1. 创建 Web 应用并引入 JAR 包。
2. Spring MVC 配置：在 web.xml 中配置 Servlet，创建 Spring MVC 的配置文件
3. 创建 Controller（处理请求的控制器）
4. 创建 View（本教程使用 JSP 作为视图）
5. 部署运行

1.spring-mvc配置

Spring MVC 是基于 Servlet 的，DispatcherServlet 是整个 Spring MVC 框架的核心，主要负责截获请求并将其分派给相应的处理器处理。所以配置 Spring MVC，首先要定义 DispatcherServlet。跟所有 Servlet 一样，用户必须在 web.xml 中进行配置。

定义DispatcherServlet

在开发 Spring MVC 应用时需要在 web.xml 中部署 DispatcherServlet，代码如下：

<!-- 部署 DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 表示容器再启动时立即加载servlet -->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

Spring MVC 初始化时将在应用程序的 WEB-INF 目录下查找配置文件，该配置文件的命名规则是“servletName-servlet.xml”，例如 springmvc.xml。

也可以将 Spring MVC 的配置文件存放在应用程序目录中的任何地方，但需要使用 servlet 的 init-param 元素加载配置文件，通过 contextConfigLocation 参数来指定 Spring MVC 配置文件的位置，

此处使用 Spring 资源路径的方式进行指定，即 classpath:springmvc.xml

上述代码配置了一个名为“springmvc”的 Servlet。该 Servlet 是 DispatcherServlet 类型，它就是 Spring MVC 的入口，并通过 <load-on-startup>1</load-on-startup> 配置标记容器在启动时就加载此 DispatcherServlet，即自动启动。然后通过 servlet-mapping 映射到“/”，即 DispatcherServlet 需要截获并处理该项目的所有 URL 请求。

创建Spring MVC配置文件

在resource静态资源目录下创建springmvc.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- Login控制器类，映射到"/login" -->
    <bean name="/login"
          class="com.yc.www.login"/>
    <!-- Login控制器类，映射到"/register" -->
    <bean name="/register"
          class="com.yc.www.Register"/>
</beans>

2.创建Controller

在 src 目录下创建 com.yc.www 包，并在该包中创建 Register和 Login两个传统风格的控制器类（实现 Controller 接口），分别处理首页中“注册”和“登录”超链接的请求。

Controller 是控制器接口，接口中只有一个方法 handleRequest，用于处理请求和返回 ModelAndView。

1. Register代码如下

public class Register implements Controller {

    public ModelAndView handleRequest(HttpServletRequest arg0,
                                      HttpServletResponse arg1) throws Exception {
        return new ModelAndView("/WEB-INF/jsp/login.jsp");
    }
}

2. login代码如下

public class login implements  Controller{
    
    public ModelAndView handleRequest(HttpServletRequest arg0,
                                      HttpServletResponse arg1) throws Exception {
        return new ModelAndView("/WEB-INF/jsp/register.jsp");
    }
}

3.创建VIew

index.jsp 代码如下。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        未注册的用户，请
        <a href="${pageContext.request.contextPath }/register"> 注册</a>！
        <br /> 已注册的用户，去
        <a href="${pageContext.request.contextPath }/login"> 登录</a>！
    </body>
</html>

在 WEB-INF 下创建 jsp 文件夹，将 login.jsp 和 register.jsp 放到 jsp 文件夹下。login.jsp 代码如下。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        登录页面
    </body>
</html>

register,jsp代码如下

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        注册页面
    </body>
</html>

4.Spring MVC视图解析器（ViewResolver）

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

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

1.InternalResourceViewResolver

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

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

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd 
                           http://www.springframework.org/schema/mvc 
                           https://www.springframework.org/schema/mvc/spring-mvc.xsd 
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.yc.www"/>


    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> <!--可以省略-->
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>  
    </bean>
</beans>

示例

1. 修改login的Controller

@Controller
public class login{
    @RequestMapping("/login")
    public ModelAndView register() {
        ModelAndView  mv = new ModelAndView();
        mv.addObject("name","登录页面的首页");
        mv.setViewName("login");
        return  mv;
    }
}

2. 修改register的Controller

@Controller
public class Register{
    @RequestMapping("/register")
    public ModelAndView  login() {
        ModelAndView  mv = new ModelAndView();
        mv.addObject("name","注册页面的首页");
        mv.setViewName("register");
        return mv;
    }
}

3. 修改login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <h1>${name}</h1>
    </body>
</html>

3. 修改register.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <H1>${name }</H1>
    </body>
</html>

5.Springmvc执行流程

在学习框架之前，首先来了解一下 Spring MVC 框架的整体请求流程和使用到的 API 类。

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

springmvc执行流程
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. 视图负责将结果显示到浏览器（客户端）。

springmvc接口

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）。

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 是一个工具，既然是工具，那么我们就需要先掌握工具的使用方法，不要陷入细节中，深入浅出，慢慢通过实际运用来加深对其的理解。

6.Spring MVC @Controller和@RequestMapping注解

Spring 2.5 版本新增了 Spring MVC 注解功能，用于替换传统的基于 XML 的 Spring MVC 配置。

使用基于注解的控制器具有以下 2 个优点：

1. 在基于注解的控制器类中可以编写多个处理方法，进而可以处理多个请求（动作），这就允许将相关的操作编写在同一个控制器类中，从而减少控制器类的数量，方便以后维护。
2. 基于注解的控制器不需要在配置文件中部署映射，仅需要使用 @RequestMapping 注解一个方法进行请求处理即可。

下面介绍在 Spring MVC 中最重要的两个注解类型：@Controller 和 @RequestMapping。

1.@Controller注解

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

package com.yc.www.controller;
import org.springframework.stereotype.Controller;
@Controller
public class IndexController {
    // 处理请求的方法
}

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

在springmvc.xml中配置以下代码

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

2.@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.headers属性

headers属性表示请求中必须包含某些指定的 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、请求参数、请求方法和请求头。

3.编写请求处理方法

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

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public ModelAndView register(HttpSession session,HttpServletRequest request) {
        ModelAndView  mv = new ModelAndView();
        mv.addObject("name","登录页面的首页");
        mv.setViewName("login");
        return  mv;
    }
}

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model) {
        /*在视图中可以使用EL表达式${success}取出model中的值*/
        model.addAttribute("name","登录页的首页");
        return  "login";
    }
}

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

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

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

7.Spring MVC接收参数

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

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

1.通过实体Bean接收请求参数

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model,User user) {
        if ("admin".equals(user.getName())&& "123".equals(user.getPass())) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model,String name,String pass) {
        if ("admin".equals(name)&& "123".equals(pass)) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

3.通过HttpServletRequest接收请求参数

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model,HttpServletRequest request) {
        String name = request.getParameter("name");
        String pass = request.getParameter("pass");

        if ("admin".equals(name)&& "123".equals(pass)) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login/{name}/{pass}")
    public String register(Model model,@PathVariable String name,@PathVariable String pass) {
        if ("admin".equals(name)&& "123".equals(pass)) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

在访问http://localhost:8080/springmvc2/index/login/admin/123路径时，上述代码会自动将 URL 中的模板变量 {name} 和 {pass} 绑定到通过 @PathVariable 注解的同名参数上，即 name=admin、pass=123。

注意：如果在路径中的模块变量与方法中的形参不一样，这时候需要在@PathVariable的name属性中添加模块变量的名字，这时候就被转换成了形参中的变量。

5.通过@RequestParam接收请求参数

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model,@RequestParam(value="name1") String name,@RequestParam(value="pass1") String pass) {
        if ("admin".equals(name)&& "123".equals(pass)) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

6.通过@ModelAttribute接收请求参数

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

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String register(Model model,@ModelAttribute("User") User user) {
        if ("admin".equals(user.getName())&& "123".equals(user.getPass())) {
            model.addAttribute("message", "登录成功");
            return "main"; // 登录成功，跳转到 main.jsp
        } else {
            model.addAttribute("message", "用户名或密码错误");
            return "register";
        }
    }
}

8.Spring MVC重定向和转发

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

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

转发过程

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

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

重定向过程

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

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

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

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

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

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value="/login")
    public String login() {
        return "forward:/index/register";  //请求转发（同一个控制器类可以省略/index/）
    }

    @RequestMapping("/login1")
    public String isLogin() {
        //重定向到一个请求方法
        return "redirect:/index/register";  //重定向
    }

    @RequestMapping("/register")
    public String register() {
        return  "register";
    }
}

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

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

则需要使用 mvc:resources 配置：

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

9.Spring MVC @Autowired和@Service注解

将依赖注入到 Spring MVC 控制器时需要用到 @Autowired 和 @Service 注解。

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

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

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

<context:component-scan base-package="com.yc.www.service"/>

示例

1. 创建一个User实体类

public class User {
    private String name;
    private String pass;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPass() {
        return pass;
    }
    public void setPass(String pass) {
        this.pass = pass;
    }

}

2. 创建UserService接口

public interface UserService {
    //登录验证
    boolean UserLogin(User user);
}

3. 创建UserServiceImpl实体类，实现UserService接口

@Service  //该注释必须存在，将这个类注入到bean
public class UserServiceImpl implements UserService {
    //创建假数据
    private  String name="admin";
    private  String pass="123";
    //登录验证
    @Override
    public boolean UserLogin(User user) {
        if(user.getName().equals(this.name)&&user.getPass().equals(this.pass)) {
            return true;
        }
        return false;
    }

}

4. 创建login的controller控制

@Controller
@RequestMapping("/index")
public class login{

    @Autowired
    private  UserService  userservice;

    @RequestMapping(value="/login")
    public String login(User user) {
        boolean userLogin = userservice.UserLogin(user);
        if(userLogin) {
            return "main";
        }else {
            return "login";
        }
    }
}

5. 创建springmvc.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd 
                           http://www.springframework.org/schema/mvc 
                           https://www.springframework.org/schema/mvc/spring-mvc.xsd 
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd">
    <!--扫描controller层-->
    <context:component-scan base-package="com.yc.www.controller"  />
    <!--扫描service层-->
    <context:component-scan base-package="com.yc.www.service"/>

    <!--试图解析器-->
    <bean   class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> <!--可以省略-->
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>  
    </bean>
</beans>

6. 创建login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <form action="${pageContext.request.contextPath }/index/login" method="get">
            账号<input type="text" name="name"/><br>
            密码<input  type="password" name="pass"/><br>
            <input  type="submit" value="login">    
        </form>
    </body>
</html>

10.Spring MVC @ModelAttribute注解

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

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

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

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

1.应用在方法上

@Controller
@RequestMapping("/index")
public class login{
    // 方法无返回值
    @ModelAttribute
    public void myModel(@RequestParam(required = false) String name, Model model) {
        model.addAttribute("name", name);
    }
    @ModelAttribute
    public void myModel1(@RequestParam(required = false) String name, Model model) {
        model.addAttribute("name1", name);
    }
    @RequestMapping(value = "/login")
    public String model() {
        return "main";
    }
}

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <h1>登陆成功-----${name }---${name1 }</h1>
    </body>
</html>

访问地址:http://localhost:8080/springmvc2/index/login?name=我的世界,在进行访问时，springmvc优先执行myModel和myModel1方法，并且获取url地址中对应的参数，将 name 的值存入到 Model 中。然后执行 model 方法，这样 name 的值就被带到了 model 方法中。

2.应用在有返回值的方法

1. 创建Controller

@Controller
@RequestMapping("/index")
public class login{
	// 方法有返回值
    @ModelAttribute
    public String myModel(@RequestParam(required = false) String name) {
    	return name;
    }
    @RequestMapping(value = "/login")
    public String model() {
        return "main";
    }
}

2. main.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <h1>登陆成功-----${string}</h1>
    </body>
</html>

对于以上情况，返回值对象 name 会被默认放到隐含的 Model 中，在 Model 中 key 为返回值首字母小写，value 为返回的值。等同于 model.addAttribute("string", name);。

但正常情况下，程序中尽量不要出现 key 为 string、int、float 等这样数据类型的返回值。使用 @ModelAttribute 注解 value 属性可以自定义 key，代码如下。

// 方法无返回值
@ModelAttribute("namestring")
public String myModel(@RequestParam(required = false) String name) {
    return name;
}

等同于

model.addAttribute("namestring", name);

3.应用在方法的参数上

@ModelAttribute 注解在方法的参数上，调用方法时，模型的值会被注入。这在实际使用时非常简单，常用于将表单属性映射到模型对象。

1. controller

@Controller
@RequestMapping("/index")
public class login{
    @RequestMapping(value = "/login")
    public String model(@ModelAttribute("user") User  user) {
        return  "main";
    }
}

2. jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        <h1>登陆成功-----${user.name}----${user.pass}</h1>
    </body>
</html>

上述代码中“@ModelAttribute(“user”) User user ”语句的功能有两个：

• 将请求参数的输入封装到 user 对象中
• 创建 User实例

以“user”为键值存储在 Model 对象中，和“model.addAttribute(“user”,user)”语句的功能一样。如果没有指定键值，即“@ModelAttribute User user”，那么在创建 User 实例时以“userForm”为键值存储在 Model 对象中，和“model.addAtttribute(“userForm”, user)”语句的功能一样。

4.Model和ModelView的区别

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

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

11.Spring MVC类型转换器（Converter）

​ Spring MVC 框架的 Converter<S，T> 是一个可以将一种数据类型转换成另一种数据类型的接口，这里 S 表示源类型，T 表示目标类型。开发者在实际应用中使用框架内置的类型转换器基本上就够了，但有时需要编写具有特定功能的类型转换器。

​ 例如，用户输入的日期可能有许多种形式，如“December 25,2014”“12/25/2014”和“2014-12-25”，这些都表示同一个日期。默认情况下，Spring 会期待用户输入的日期样式与当前语言区域的日期样式相同。例如，对于美国的用户而言，就是月/日/年的格式。如果希望 Spring 在将输入的日期字符串绑定到 LocalDate 时，使用不同的日期样式，则需要编写一个 Converter，才能将字符串转换成日期。

​ java.time.LocalDate 类是 Java 8 的一个新类型，用来替代 java.util.Date。还需使用新的 Date/Time API 来替换旧有的 Date 和 Calendar 类。

1.内置的类型转换器

在 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 等）已经做好了基本类型转换。

注意：在使用内置类型转换器时，请求参数输入值与接收参数类型要兼容，否则会报 400 错误。请求参数类型与接收参数类型不兼容问题需要学习输入校验后才可解决。

2.自定义类型转换器

当 Spring MVC 框架内置的类型转换器不能满足需求时，开发者可以开发自己的类型转换器。

例如需要用户在页面表单中输入信息来创建商品信息。当输入“hello world，18，1.85”时表示在程序中自动创建一个 new User，并将“hello world”值自动赋给 name 属性，将“18”值自动赋给 age 属性，将“1.85”值自动赋给 height 属性。

如果想实现上述应用，需要做以下 5 件事：

• 创建实体类。
• 创建控制器类。
• 创建自定义类型转换器类。
• 注册类型转换器。
• 创建相关视图。

12.Spring MVC数据格式化（Formatter）

​ Spring MVC 框架的 Formatter 与 Converter<S, T> 一样，也是一个可以将一种数据类型转换成另一种数据类型的接口。不同的是，Formatter 的源类型必须是 String 类型，而 Converter 的源类型可以是任意数据类型。Formatter 更适合 Web 层，而 Converter 可以在任意层中。所以对于需要转换表单中的用户输入的情况，应该选择 Formatter，而不是 Converter。

​ 在 Web 应用中由 HTTP 发送的请求数据到控制器中都是以 String 类型获取，因此在 Web 应用中选择 Formatter 比选择 Converter<S, T> 更加合理。

1.内置的格式化转换器

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

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

13.Spring MVC JSON数据交互

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

1.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":"北京"
            }
}

2.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。

3.@ResponseBody由fastjson解析

1. 配置springmvc.xml，添加以下代码

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

<mvc:annotation-driven>
    <!--配置@ResponseBody由fastjson解析 -->
    <mvc:message-converters>
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <property name="supportedMediaTypes">
                <list>
                    <value>application/json;charset=utf-8</value>
                </list>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

2. 创建一个User类实体类

public class User {
    @JSONField(name="uname")
    private String name;

    @JSONField(serialize=true)
    private String pass;

    @JSONField(format="yyyy-MM-dd-HH-ss-SSS")
    private Date date;

    private Double salary;
    //省略get和set方法
}

上面实体类中的注释是fastjson自带的，可以简化返回json格式的内容，在后面会详细介绍

3. 创建返回json的controller类

@Controller
@RequestMapping("/index")
public class login{
    @ResponseBody
    @RequestMapping(value="/login")
    public User model(User user) {
        user.setDate(new Date());
        return  user;
    }
}

4. 创建login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
        <script type="text/javascript" src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    </head>
    <body>
        <form action="">
            用户名：<input type="text" name="name" id="name" />
            <br>
            密码：<input type="password" name="pass" id="password" />
            <br>
            价格：<input type="text" name="salary" id="salary">
            <br>
            <input type="button" value="测试" οnclick="testJson()" />
        </form>
    </body>
    <script type="text/javaScript">
        function testJson() {
            var name = $("#name").val();
            var pass = $("#password").val();
            var salary = $("#salary").val();
            $.ajax({
                //请求路径
                url : "${pageContext.request.contextPath}/index/login?name="+name+"&pass="+pass+"&salary="+salary,
                //请求类型
                type : "get",
                //定义回调响应的数据格式为JSON字符串，该属性可以省略
                dataType : "json",
                //成功响应的结果
                success : function(data) {
                    if (data != null) {
                        alert("输入的用户名：" + data.uname + "，密码：" + data.pass+",时间："+data.date
                              + "， 年龄：" + data.salary);
                    }
                }
            });
        }
    </script>
</html>

14.Spring MVC拦截器（Interceptor）

在系统中，经常需要在处理用户请求之前和之后执行一些行为，例如检测用户的权限，或者将请求的信息记录到日志中，即平时所说的“权限检测”及“日志记录”。当然不仅仅这些，所以需要一种机制，拦截用户的请求，在请求的前后添加处理逻辑。

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

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

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

1.拦截器的定义

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

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

public class TestInterceptor implements HandlerInterceptor {

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
        throws Exception {
        // TODO Auto-generated method stub
        System.out.println("afterCompletion方法在控制器的处理请求方法执行完成后执行，即视图渲染结束之后执行");
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub
        System.out.println("postHandle方法在控制器的处理请求方法调用之后，解析视图之前执行");
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
        // TODO Auto-generated method stub
        System.out.println("preHandle方法在控制器的处理请求方法调用之前执行");
        return false;
    }

}

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

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

2.拦截器的配置

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

<!-- 配置拦截器 -->
<mvc:interceptors>
    <!-- 配置一个全局拦截器，拦截所有请求 -->
    <bean class="net.biancheng.interceptor.TestInterceptor" /> 
    <mvc:interceptor>
        <!-- 配置拦截器作用的路径 -->
        <mvc:mapping path="/**" />
        <!-- 配置不需要拦截作用的路径 -->
        <mvc:exclude-mapping path="" />
        <!-- 定义<mvc:interceptor>元素中，表示匹配指定路径的请求才进行拦截 -->
        <bean class="net.biancheng.interceptor.Interceptor1" />
    </mvc:interceptor>
    <mvc:interceptor>
        <!-- 配置拦截器作用的路径 -->
        <mvc:mapping path="/gotoTest" />
        <!-- 定义在<mvc:interceptor>元素中，表示匹配指定路径的请求才进行拦截 -->
        <bean class="net.biancheng.interceptor.Interceptor2" />
    </mvc:interceptor>
</mvc:interceptors>

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

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

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

示例

​ 下面通过拦截器来完成一个用户登录权限验证的 Web 应用，具体要求如下：只有成功登录的用户才能访问系统的主页面 main.jsp，如果没有成功登录而直接访问主页面，则拦截器将请求拦截，并转发到登录页面 login.jsp。当成功登录的用户在系统主页面中单击“退出”链接时回到登录页面。

1. 创建POJO层的User类

public class User {
    private String name;

    private String pwd;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

2. 创建控制器类

@Controller
public class userController {

    /**
     * 登录页面初始化
     */
    @RequestMapping("/toLogin")
    public String initLogin() {
        return "login";
    }
    /**
     * 处理登录功能
     */
    @RequestMapping("/login")
    public String login(User user, Model model, HttpSession session) {
        System.out.println(user.getName());
        if ("admin".equals(user.getName()) && "123".equals(user.getPwd())) {
            // 登录成功，将用户信息保存到session对象中
            session.setAttribute("user", user);
            session.setMaxInactiveInterval(10);
            // 重定向到主页面的跳转方法
            return "redirect:main";
        }
        model.addAttribute("msg", "用户名或密码错误，请重新登录！ ");
        return "login";
    }
    /**
     * 跳转到主页面
     */
    @RequestMapping("/main")
    public String toMain() {
        return "main";
    }
    /**
     * 退出登录
     */
    @RequestMapping("/logout")
    public String logout(HttpSession session) {
        // 清除 session
        session.invalidate();
        return "login";
    }
}

3. 创建拦截器类

public class LoginInterceptor implements  HandlerInterceptor  {

	@Override
	public void afterCompletion(javax.servlet.http.HttpServletRequest request, HttpServletResponse response,
			Object handler, Exception ex) throws Exception {
		// TODO Auto-generated method stub
//		HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
	}

	@Override
	public void postHandle(javax.servlet.http.HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		// TODO Auto-generated method stub
//		HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
	}

	@Override
	public boolean preHandle(javax.servlet.http.HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
		// TODO Auto-generated method stub
	      // 获取请求的URL
        String url = request.getRequestURI();
        // login.jsp或登录请求放行，不拦截
        if (url.indexOf("/toLogin") >= 0 || url.indexOf("/login") >= 0) {
            System.out.println(url);
            return true;
        }
        // 获取 session
        HttpSession session = request.getSession();
        Object obj = session.getAttribute("user");
        if (obj != null)
            return true;
        // 没有登录且不是登录页面，转发到登录页面，并给出提示错误信息
        request.setAttribute("msg", "还没登录，请先登录！");
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
	}
   
}

4. 配置拦截器

​ 在 WEB-INF 目录下创建配置文件 springmvc-servlet.xml 和 web.xml。web.xml 的代码和 springmvcDemo2 一样，这里不再赘述。在 springmvc.xml 文件中配置拦截器 LoginInterceptor，代码如下。

<!-- 配置拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 配置拦截器作用的路径 -->
        <mvc:mapping path="/**"/>
        <bean class="com.yc.www.interceptor.LoginInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

5. 创建jsp页面，login.jsp如下

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        ${msg }
        <form action="${pageContext.request.contextPath }/login" method="get">
            用户名：<input type="text" name="name" /><br>
            密码：<input type="password" name="pwd" /><br>
            <input type="submit" value="登录" />
        </form>
    </body>
</html>

main.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Insert title here</title>
    </head>
    <body>
        欢迎 ${user.name }，登录编程帮！<br />
        <a href="${pageContext.request.contextPath }/logout">退出</a>
    </body>
</html>

15.Spring MVC数据校验

一般情况下，用户的输入是随意的，为了保证数据的合法性，数据验证是所有 Web 应用必须处理的问题。

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

16.Spring MVC异常处理

在 Spring MVC 应用的开发中，不管是操作底层数据库，还是业务层或控制层，都会不可避免地遇到各种可预知的、不可预知的异常。我们需要捕捉处理异常，才能保证程序不被终止。

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

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

1.@ExceptionHandler

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

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

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

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

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

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

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

请求http://localhost:8080/springmvc2/login?name=0

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

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

2.HandlerExceptionResolver

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

public interface HandlerExceptionResolver {
    @Nullable
    ModelAndView resolveException(
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
}

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

public class MyExceptionHandler implements  HandlerExceptionResolver   {

    @Override
    public ModelAndView resolveException(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2,
                                         Exception arg3) {
        ModelAndView modelAndView = new ModelAndView();
        // 根据不同错误转向不同页面（统一处理），即异常与View的对应关系
        if (arg3 instanceof ArithmeticException) {
            modelAndView.addObject("name",arg3);
            modelAndView.setViewName("error");
            return modelAndView;
        }
        modelAndView.setViewName("main");
        return modelAndView;
    }

}

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

<bean  class="com.yc.www.interceptor.MyExceptionHandler" />

3.SimpleMappingExceptionResolver

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

在 springmvc.xml 中配置全局异常，代码如下。

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

17.Spring MVC REST风格

REST（Representational State Transfer）即表述性转移，是目前最流行的一种软件架构风格。它结构清晰、易于理解、有较好的扩展性。

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

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

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

但是也有弊端，对于国内项目，URL 参数有时会传递中文，而中文乱码是一个令人头疼的问题，所以我们应该根据实际情况进行灵活处理。很多网站都是传统 URL 风格与 REST 风格混搭使用。

18.springmvc整合swagger

Swagger是一个用于生成、描述和调用 RESTful 接口的 Web 服务。通俗的来讲，Swagger 就是将项目中所有（想要暴露的）接口展现在页面上，并且可以进行接口调用和测试的服务。 PS：Swagger 遵循了 OpenAPI 规范，OpenAPI 是 Linux 基金会的一个项目，试图通过定义一种用来描述 API 格式或 API 定义的语言，来规范 RESTful 服务开发过程。

1. 导入swagger的pom依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.3</version>
</dependency>

2. 创建swagger的配置类

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .groupName("超哥解说")
            // enable 参数为false则不能在浏览器访问,true为默认
            .enable(true)
            .select()
            //配置扫描接口的方法,按照包去扫描
            .apis(RequestHandlerSelectors.basePackage("com.yc.controller"))
            .build();
    }

    private ApiInfo apiInfo(){
        Contact contact=new Contact("瓤瓤","https://blog.csdn.net/lovely__RR","2293557957@qq.com");
        return new ApiInfo(
            "瓤瓤",
            "你我山巅自相逢,予你与我遇清风",
            "1.0",
            "https://swagger.io/",
            contact,
            "Apache 2.0",
            "http://www.apache.org/licenses/LICENSE-2.0",
            new ArrayList<>()
        );
    }
}

3. 将swagger的配置类注入到springmvc.xml中

<bean class="com.yc.config.SwaggerConfig"/>