Spring核心技术 - Spring MVC 技术整理 - 《Java架构技术》

Spring MVC的应用
Spring MVC的执行流程
- Spring MVC组件解析
- Spring MVC注解详解
  - @Controller
  - @RequestMapping
Spring MVC的请求
- 请求参数
SpringMVC响应
- 页面跳转
Spring MVC进阶

MVC 模式：MVC是软件工程中的一种软甲架构模式，是一种分离业务逻辑与现实界面的开发思想。

M(Model): 处理业务逻辑，封装实体
V（View）：视图展示内容
C（Controller）控制器负责调度分发（1.接收请求 2.调用模型 3.转发到视图）

SpringMVC是一种基于java的实现了MVC设计模式的轻量级Web框架，属于springFrameWork的后续产品，已经融合在Spring Web Flow中。 SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0的发布，全面超越了Struts2，成为最优秀的MVC框架，它通过一套注解，让一个简单的java类成为处理请求的控制器，而无需实现任何借口。同时它还支持RESTful编程风格的请求。

:::tips SpringMVC 的框架就是封装了原来Servlet中的共有行为。例如：参数封装、视图转发等。 :::

Spring MVC的应用

客户端发起请求，服务器接受请求，执行逻辑并进行视图跳转

创建web项目，导入springMVC相关依赖

<dependencies>
     <!-- spring mvc的依赖 -->
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.1.5.RELEASE</version>
     </dependency>
     <!-- servlet依赖 -->
     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
         <version>3.1.0</version>
         <scope>provided</scope>
     </dependency>
     <!-- jsp依赖 -->
     <dependency>
         <groupId>javax.servlet.jsp</groupId>
         <artifactId>jsp-api</artifactId>
         <version>2.2</version>
         <scope>provided</scope>
     </dependency>
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.11</version>
         <scope>test</scope>
     </dependency>
 </dependencies>

配置springMVC的前端控制器DispathcerServlet ```xml <?xml version=”1.0” encoding=”UTF-8”?> <web-app xmlns=”http://xmlns.jcp.org/xml/ns/javaee“

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  version="4.0">

 <servlet-name>DispatcherServlet</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

 <servlet-name>DispatcherServlet</servlet-name>
 <!-- /会匹配到所有的访问路径 但是不会匹配到*.jsp这样的URL  ， /*就是所有的都会匹配到-->
 <url-pattern>/</url-pattern>


3. Controller类和视图页面
3. 注解配置Controller中业务方法的映射地址
```java
@Controller //bean 对象注入到了IOC容器
public class UserController {

    @RequestMapping("/quick")
    public String quick() {
        //业务逻辑
        System.out.println("spring mvc quick start");
        //视图跳转 跳转的路径写在return中
        return "/WEB-INF/pages/success.jsp";
    }
}

配置SpringMVC核心文件 spring-mvc.xml

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    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
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd">
 <!-- IOC 注解扫描 创建实例存储到spring mvc 所创建的IOC容器中 -->
 <context:component-scan base-package="com.prim"/>
</beans>

注意：还需要在web.xml中进行相关的配置，加载springMVC的核心文件

 <!-- spring mvc 前端控制器 DispatcherServlet -->
 <servlet>
     <servlet-name>DispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <!-- 初始化参数：解析spring-mvc配置文件 -->
     <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:spring-mvc.xml</param-value>
     </init-param>
     <!-- 在应用启动时，就完成servlet的实例化及初始化操作 -->
     <load-on-startup>2</load-on-startup>
 </servlet>

这样我们就springMVC就全部配置完毕了，配置Tomcat服务器启动即可测试。

JavaWeb的执行流程：

Spring MVC的执行流程

用户发送请求至前端控制器DispatcherServlet
DispatcherServlet收到请求调用HandlerMapping处理器映射器
处理器映射器找到具体的处理器(根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器一并返回给DispatcherServlet
DispatcherServlet调用HandlerAdapter处理器适配器
HandlerAdapter经过适配调用具体的处理器(Controller 也叫后端控制器)
Controller 执行完成返回ModelAndView
HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet.
DispatcherServlet将ModelAndView传给ViewResolver视图解析器
ViewResolver解析后返回具体View
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）
DispatcherServlet将渲染后的视图响应响应用户。

Spring MVC组件解析

前端控制器：DispatcherServlet

用户请求到达前端控制器，它就相当于MVC模式中的C，DispatcherServle是整个流程控制的中心，由它调用其他组件处理用户的请求，DispatcherServlet的存在降低了组件之间的耦合性。

处理器映射器：HandlerMapping

HandlerMapping负责根据用户请求找到Handler即处理器，SpringMVC提供了不同的映射器实现不同的映射方法，例如：配置文件方式、实现接口方式、注解方式等等。

处理器适配器：HandlerAdapter

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

处理器:Handler(Controller) 【开发者编写】

它就是我们开发中要编写的具体业务控制器。由DispatcherServlet把用户请求转发到Handler。由Handler对具体的用户请求进行处理

视图解析器:ViewResolver

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名，即具体的页面地址，生成View视图对象，最后对view进行渲染将结果通过页面展示给用户。

视图：View 【开发者编写】

SpringMVC框架提供了很多的View视图类型的支持，包括：jstlView、freemarkerView\pdfView等，最常用的视图就是jsp，一般情况下需要通过页面标签或页面模板技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面。

:::success SpringMVC 三大组件：处理器映射器(HandlerMapping)、处理器适配器(HandlerAdapter)、视图解析器(ViewResoler). :::

配置处理器适配器/映射器

  <!-- 配置处理器适配器\处理器映射器 进行了功能的增强：支持json读写 -->
  <mvc:annotation-driven/>

视图解析器配置

  <!-- 视图解析器 -->
  <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <!-- 配置前缀和后缀,那么Controller中的返回值进行视图跳转返回逻辑视图名即可：
      例如success == /WEB-INF/pages/success.jsp
      -->
      <property name="prefix" value="/WEB-INF/pages/"/>
      <property name="suffix" value=".jsp"/>
  </bean>

那么Controller中就可改为：

  @RequestMapping("/quick")
  public String quick() {
      //业务逻辑
      System.out.println("spring mvc quick start");
      //视图跳转 跳转的路径写在return中 逻辑视图名
      return "success";
  }

Spring MVC注解详解

@Controller

SpringMVC是基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，需要开启注解扫描的配置。
@Controller在springIOC的模块讲解过，主要用于Web层类上，生成Web层的类的实例。

需要注意在spring-mvc.xml 中SpringMVC核心配置,只管理Controller层的对象

    <!-- IOC 注解扫描 创建实例存储到spring mvc 所创建的IOC容器中 spring-mvc 配置管理web层对象 -->
    <context:component-scan base-package="com.prim.controller"/>

在applicationContext.xml 中的spring核心配置，管理service层和dao层的对象

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- spring核心配置文件 管理service层和dao层的对象 -->
    <context:component-scan base-package="com.prim.service"/>
    <context:component-scan base-package="com.prim.dao"/>
</beans>

@RequestMapping

用于建立请求URL和处理请求方法之间的对应关系

位置

类上：请求URL的一级访问目录，如果不写的话就相当于应用的根目录，必须要以/开头

它出现的目的是为了使我们的URL可以按照模块化管理
用户模块：/user/add /user/update …..
账户模块：/account/add /account/update ……

方法上：请求URL的第二级访问目录，和一级目录组成一个完整的URL路径

@Controller //bean 对象注入到了IOC容器
@RequestMapping("/user") //一级访问目录
public class UserController {

 //二级访问目录 http://localhost:8080/../user/quick
 @RequestMapping("/quick")
 public String quick() {
     //业务逻辑
     System.out.println("spring mvc quick start");
     //视图跳转 跳转的路径写在return中 逻辑视图名
     return "success";
 }
}

属性
- path：作用等同于value，同样是设置方法的映射地址的
- method: 用来限定请求的方式,例如：RequestMethod.GET/POST/....
- params: 用来限定请求参数的条件。例如：params = {"accountName"} 请求参数必须携带accountName. 请求：http://localhost:8080/springmvc_quickstart/user/quick?accountName=1

如果不携带参数就会报错：

    //二级访问目录 http://localhost:8080/../user/quick?accountName=...
    @RequestMapping(path = "/quick",method = RequestMethod.GET,params = {"accountName"})
    public String quick() {
        //业务逻辑
        System.out.println("spring mvc quick start");
        //视图跳转 跳转的路径写在return中 逻辑视图名
        return "success";
    }

Spring MVC的请求

请求参数

SpringMVC可以接收的参数类型：

基本类型参数
对象类型参数
数组类型参数
集合类型参数

服务器要获取请求的参数的时候要进行类型转换，有时还需要进行数据的封装。
下面来具体的讲解不同类型参数的接收

基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射配置。并且能自动做类型转换；自动类型转换是指从String向其他类型的转换。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%--pageContext.request.contextPath 获取当前的项目路径--%>
<a href="${pageContext.request.contextPath}/user/simpleParam?id=1&username='张三'">基本类型参数</a>
</body>
</html>

    /**
     * 基本类型的参数请求
     *
     * @param id       请求参数名必须和当前方法参数名一致
     * @param username 请求参数名必须和当前方法参数名一致
     * @return
     */
    @RequestMapping("/simpleParam")
    public String simpleParam(Integer id, String username) {
        System.out.println("id:" + id + " username:" + username);//id:1 username:'张三'
        return "success";
    }

获取对象类型参数

Controller中的业务方法参数的POJO属性名与请求参数的name一致，参数值会自动映射匹配

<form action="${pageContext.request.contextPath}/user/objectParam" method="post">
    编号：<input type="text" name="id"> <br>
    用户名：<input type="text" name="username"> <br>
    <input type="submit" value="对象传参">
</form>

    @RequestMapping("/objectParam")
    public String objectParam(User user) {
        System.out.println(user);
        return "success";
    }

post请求如果传递username是中文，得到的是个乱码

中文乱码过滤器

在web.xml中配置过滤器

    <!-- 中文乱码过滤器 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!-- 设置编码的格式 -->
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <!-- /* 拦截所有 -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>

这样我们就可解决中文乱码的问题

User{id=1, username='张飞'}

获取数组类型参数

Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配


<%--数组类型请求参数--%>
<form action="${pageContext.request.contextPath}/user/arrayParam">
    <input type="checkbox" name="ids" value="1">1 <br>
    <input type="checkbox" name="ids" value="2">2 <br>
    <input type="checkbox" name="ids" value="3">3 <br>
    <input type="checkbox" name="ids" value="4">4 <br>
    <input type="checkbox" name="ids" value="5">5 <br>
    <input type="submit" value="复选框-数组传参">
</form>

    /**
     * 获取数组类型请求参数
     */
    @RequestMapping("/arrayParam")
    public String arrayParam(Integer[] ids) {
        System.out.println(Arrays.toString(ids));
        return "success";
    }

打印结果：[1, 3, 5]

获取集合类型参数

获取集合参数时，要将集合参数包装到一个POJO中才可以

编写pojo-VO来接受复杂的请求参数

public class QueryVO {
    private String keyword;

    private User user;
    private List<User> userList;
    private Map<String, User> userMap;
}

<%--复杂类型请求参数--%>
<form action="${pageContext.request.contextPath}/user/queryParam">
    关键字：<input type="text" name="keyword"> <br>
    User对象：
    <input type="text" name="user.id" placeholder="编号"> <br>
    <input type="text" name="user.username" placeholder="用户名"> <br>
    <%--  list集合  --%>
    List集合：
    <input type="text" name="userList[0].id" placeholder="集合[0]-编号"> <br>
    <input type="text" name="userList[0].username" placeholder="集合[0]-用户名"> <br>
    <input type="text" name="userList[1].id" placeholder="集合[1]-编号"> <br>
    <input type="text" name="userList[1].username" placeholder="集合[1]-用户名"> <br>
    Map集合：
    <input type="text" name="userMap['user1'].id" placeholder="Map-编号1"> <br>
    <input type="text" name="userMap['user1'].username" placeholder="Map-用户名1"> <br>
    <input type="submit" value="复杂类型-集合传参">
</form>

    /**
     * 获取复杂类型请求参数
     */
    @RequestMapping("/queryParam")
    public String queryParam(QueryVO queryVO) {
        System.out.println(queryVO);
        //QueryVO{
        // keyword='汉仪折纸',
        // user=User{id=1, username='张飞'},
        // userList=[User{id=0, username='关羽'}, User{id=1, username='刘备'}],
        // userMap={
        // user1=User{id=10, username='曹操'}
        // }
        // }
        return "success";
    }

自定义类型转换器

SpringMVC 默认已经提供了一些常用的类型转换器.例如：客户端提交的字符串转换成int型进行参数设置，日期格式类型要求为：yyyy/MM/dd 不然会报错，对于特有的行为，SpringMVC 提供了自定义类型转换器方便开发者自定义处理。
常见的日期类型：默认的

<%--自定义类型转换器 错误的产生 2012/2/2--%>
<form action="${pageContext.request.contextPath}/user/converterParam">
    生日： <input type="text" name="birthday">
    <input type="submit" value="自定义类型转换器">
</form>

    @RequestMapping("/converterParam")
    public String converterParam(Date birthday) {
        System.out.println(birthday);//得到的结果：Mon Jan 02 00:00:00 CST 2012
        return "success";
    }

如果输入：2012-1-2 则会出现异常，如果业务要求必须是-分隔，那么就需要自定义类型转换器

/**
 * 自定义日期类型转换器
 * Converter<String, Date>: String类型 转换为 Date类型
 */
public class DateConverter implements Converter<String, Date> {
    /**
     * @param s 表单传递过来的请求参数
     * @return
     */
    @Override
    public Date convert(String s) {
        //把日期类型的字符串转换成日期对象
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-ddcode");
        Date date = null;
        try {
            date = dateFormat.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}

在spring-mvc核心配置文件中，配置自定义转换器

    <!-- 配置处理器适配器\处理器映射器 进行了功能的增强：支持json读写 -->
    <mvc:annotation-driven conversion-service="conversionService"/>    
<!-- 自定义类型转换器配置 -->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.prim.converter.DateConverter"/>
            </set>
        </property>
    </bean>

这样我们在输入：2012-1-2 就不会在报错了

获取Servlet相关API

SpringMVC 支持使用原始ServletAPI对象

    /**
     * 原始Servlet API的获取
     */
    @RequestMapping("/servletApi")
    public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession httpSession) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(httpSession);
        return "success";
    }

SpringMVC响应

页面跳转：

返回字符串逻辑视图 - 在上述讲解中就是用的该方式
void原始ServletAPI
ModelAndView

返回数据：

直接返回字符串数据
将对象或集合转为json返回

页面跳转

返回字符串逻辑视图

之前有讲过，就不再复述了

    @RequestMapping(path = "/quick", method = RequestMethod.GET, params = {"accountName"})
    public String quick() {
        //业务逻辑
        System.out.println("spring mvc quick start");
        //视图跳转 跳转的路径写在return中 逻辑视图名
        return "success";
    }

void 原始Servlet API

类似JavaWeb的通过request、response

    /**
     * 通过原始ServletAPI 进行页面跳转
     */
    @RequestMapping("returnVoid")
    public void returnVoid(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 借助request对象完成请求转发
        request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);

        //2. 借助response对象完成重定向 两次请求 WEB-INF 是安全目录，不允许外部请求直接访问该目录资源，只可以进行服务器内部请求转发
        response.sendRedirect(request.getContextPath() + "/index.jsp");
    }

返回字符串逻辑视图-其实就是请求转发。
还可以通过：forward 进行请求转发

    /**
     * 演示forward关键字请求转发
     */
    @RequestMapping("/forward")
    public String forward(Model model) {
        //还想在模型中设置一些值 转发到jsp页面 可以获取到该值
        // 注意model 是存储在request域中
        model.addAttribute("username", "张飞");

        //forward既可以转发到jsp，也可以转发到其他控制器方法
//        return "forward:/product/findAll";//转发到控制器方法
        return "forward:/WEB-INF/pages/success.jsp";//路径必须写全了 不写成：success
    }

JSP 获取模型中设置的值

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>Spring MVC Quick Start ${username}</h2>
</body>
</html>

springMVC重定向关键字：redirect

    /**
     * 演示redirect关键字 重定向
     */
    @RequestMapping("/redirect")
    public String redirect(Model model) {
        //底层还是使用的还是 request.setAttribute  而request域的范围是一次请求 所以在重定向的页面是取不到username
        model.addAttribute("username", "刘备");
        //http://localhost:8080/springmvc_quickstart/index.jsp?username=刘备
        return "redirect:/index.jsp";
    }

:::tips 当遇到forward和redirect关键字，不会再走视图解析器 :::

ModelAndView

在Controller中方法创建并返回ModelAndView对象，并设置视图名称

 /**
  * ModelAndView 进行页面跳转 方式一
  */
 @RequestMapping("/returnModelAndView")
 public ModelAndView returnModelAndView() {
     /**
      * model : 模型 - 就是封装存放数据
      * view : 视图 - 用来展示数据
      */
     ModelAndView modelAndView = new ModelAndView();
     //设置模型数据
     modelAndView.addObject("username", "关羽");
     //设置视图名称
     modelAndView.setViewName("success");//直接写逻辑视图名称即可 因为最终会通过视图解析器 去解析modeandview对象，
     // 会根据在SpringMVC中的核心配置的视图解析器配置，拼接前缀和后缀

     return modelAndView;
 }

在Controller中方法形参上直接声明ModelAndView，无需在方法中自己创建，在方法中直接使用该对象设置视图，同样可以跳转页面

/**
  * ModelAndView 进行页面跳转 方式二 推荐使用
  * @return
  */
 @RequestMapping("/returnModelAndView2")
 public ModelAndView returnModelAndView2(ModelAndView modelAndView) {
     /**
      * model : 模型 - 就是封装存放数据
      * view : 视图 - 用来展示数据
      */
     //设置模型数据
     modelAndView.addObject("username", "关羽");
     //设置视图名称
     modelAndView.setViewName("success");//直接写逻辑视图名称即可 因为最终会通过视图解析器 去解析modeandview对象，
     // 会根据在SpringMVC中的核心配置的视图解析器配置，拼接前缀和后缀

     return modelAndView;
 }

@SessionAttributes

如果在多个请求之间共用数据，则可以在控制器类上标注一个@SessionAttributes,配置需要在session中存放的数据范围，Spring MVC 将存放在model中对应的数据暂存到HttpSession中。@SessionAttributes只能定义在类上。

静态资源访问开启

SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是 /(缺省),代表对所有的静态资源都进行处理操作，这样就不会执行Tomcat内置的DefaultServlet处理，我们可以通过以下两种方式指定放行静态资源:

 <!-- 方式一：放行指定的静态资源 mapping：映射资源 location：放行的目录-->
 <mvc:resources mapping="/js/**" location="/js/"/>
 <mvc:resources mapping="/css/**" location="/css/"/>
 <mvc:resources mapping="/images/**" location="/images/"/>

 <!-- 方式二：开启DefaultServlet处理静态资源 -->
 <mvc:default-servlet-handler/>

Spring MVC进阶

ajax 异步交互

SpringMVC对json数据进行转换默认是支持的，需要加入jackson包；同时开启json功能增强<mvc:annotation-driven/>

     <!-- jackson 依赖 -->
     <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-databind</artifactId>
         <version>2.9.8</version>
     </dependency>
     <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-core</artifactId>
         <version>2.9.8</version>
     </dependency>
     <dependency>
         <groupId>com.fasterxml.jackson.core</groupId>
         <artifactId>jackson-annotations</artifactId>
         <version>2.9.8</version>
     </dependency>

@RequestBody

该注解用于Controller的方法的形参声明，当使用ajax提交并指定contentType为json形式时，通过HttpMessageConverter接口转换为对象的POJO对象

<script src="js/jquery-3.5.1.js"></script>
<button id="btn">ajax交互</button>
<script>
    $("#btn").click(function () {
        let url = '${pageContext.request.contextPath}/user/ajaxRequest'
        let data = '[{"id":1,"username":"张飞"},{"id":2,"username":"关羽"}]'
        $.ajax({
            type: 'POST',
            url: url,
            data: data,
            contentType: 'application/json;charset=UTF-8',
            success: function (result) {
                console.log(result)
            }
        })
    });
</script>

    /**
     * ajax异步交互
     *
     * @return
     */
    @RequestMapping("/ajaxRequest")
    public String ajaxRequest(@RequestBody List<User> userList) {
        System.out.println(userList);
        return "";
    }

@ResonseBody

该注解用于将Controller的方法返回的对象，通过HttpMessageConverter接口转换为指定格式的数据如：json xml等，通过Response响应给客户端。

    /**
     * ajax异步交互
     *
     * @return
     */
    @RequestMapping("/ajaxRequest")
    @ResponseBody
    public List<User> ajaxRequest(@RequestBody List<User> userList) {
        System.out.println(userList);//[User{id=1, username='张飞'}, User{id=2, username='关羽'}]
        return userList;
    }

接收到了响应：

RESTful

RESTful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。

@PathVariable 获取restful风格url的参数值

  /**
     * 根据id进行查询
     *
     * @return
     */
    @RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
    @ResponseBody //
    public String findById(@PathVariable Integer id) {
        //调用service根据id查询
        return "findById: " + id;
    }

restful风格的请求：http://localhost:8080/springmvc_quickstart/restful/user/2

@RestController

RESTful风格多用于前后端分离项目开发，前端通过ajax与服务器进行异步交互，处理器通常返回的是json数据所以使用@RestController来代替@Controller 和 @ResponseBody 两个注解

@RestController  //相当于 @Controller 和 @ResponseBody
@RequestMapping("/restful")
public class RestfulController {
    /**
     * 根据id进行查询
     *
     * @return
     */
//    @RequestMapping(value = "/user/{id}", method = RequestMethod.GET)
    @GetMapping("/user/{id}") //和上述的RequestMapping的配置一致
    public String findById(@PathVariable Integer id) {
        //调用service根据id查询
        return "findById: " + id;
    }

    /**
     * 新增操作
     *
     * @return
     */
    @PostMapping("/user")
    public String post() {
        //调用service的新增方法
        return "post";
    }

    /**
     * 更新方法
     */
    @PutMapping("/user/{id}")
    public String put(@PathVariable Integer id) {
        return "put";
    }

    /**
     * 删除方法
     */
    @DeleteMapping("/user/{id}")
    public String delete(@PathVariable Integer id) {
        return "delete";
    }
}

文件上传

文件上传的三要素：

表单项 type = “file”
表单的提交方式 method = “POST”
表单的enctype属性是多部分表单形式 enctype=”multipart/form-data”

当form表单修改为多部分表单时 request.getParameter()将失效
当form表单的enctype取值为：application/x-www-form-urlencoded
1. 正文内容格式:name=value&name=value
当form表单的enctype取值为：mutilpart/form-data时，请求正文内容就变成多部分形式

实现文件上传
引入：fileupload和io坐标

        <!-- 文件上传依赖 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>

配置文件上传解析器：

    <!-- 配置文件上传解析器 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 设定文件上传的最大值为5M -->
        <property name="maxUploadSize" value="5242880"/>
        <!-- 设定文件上传时 写入内存的最大值，如果小于这个参数不会生成临时文件 默认10240 -->
        <property name="maxInMemorySize" value="40960"/>
    </bean>

前端页面：

<form action="${pageContext.request.contextPath}/fileupload" method="post" enctype="multipart/form-data">
    名称： <input type="text" name="username"> <br>
    文件：
    <input type="file" name="filePic" value="上传文件"> <br>
    <input type="submit" value="单文件上传">
</form>

Controller层编写

    /**
     * @param username
     * @param filePic  MultipartFile 文件上传类型
     * @return
     */
    @RequestMapping(value = "/fileupload", method = RequestMethod.POST)
    public String fileupload(String username, MultipartFile filePic) {
        //获取表单的提交参数 完成文件上传
        System.out.println(username);

        //当前的文件 存到哪个目录下
        try {
            String originalFilename = filePic.getOriginalFilename();//获取原始的文件上传名
            filePic.transferTo(new File("/Users/prim/workspace/upload/" + originalFilename));
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "success";
    }

多文件上传的处理：遍历MultipartFile数组即可

    /**
     * 多文件上传
     *
     * @param username
     * @param filePic
     * @return
     */
    @RequestMapping(value = "/fileupload", method = RequestMethod.POST)
    public String fileuploads(String username, MultipartFile[] filePic) {
        //获取表单的提交参数 完成文件上传
        System.out.println(username);
        //当前的文件 存到哪个目录下
        try {
            for (MultipartFile file : filePic) {
                String originalFilename = file.getOriginalFilename();//获取原始的文件上传名
                file.transferTo(new File("/Users/prim/workspace/upload/" + originalFilename));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return "success";
    }

异常处理

在Java中，对于异常处理一般有两种方式：

一种是当前方法捕获处理，这种方式会导致业务代码和异常处理代码耦合
另一种是自己不处理，而是抛给调用者处理，调用者再抛给它的调用。

SpringMVC的异常处理机制：
系统的dao、service、controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交给异常处理器进行异常处理

自定义异常处理器

创建异常处理器

/**
* 自定义异常处理器
*/
public class GlobalExceptionResolver implements HandlerExceptionResolver {
 /**
  * @param httpServletRequest
  * @param httpServletResponse
  * @param handler
  * @param e                   抛出的异常对象
  * @return
  */
 @Override
 public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler, Exception e) {
     //处理异常，跳转到异常页面
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("error", e.getMessage());
     modelAndView.setViewName("error");
     return modelAndView;
 }
}

配置异常处理器

 <!-- 配置异常处理器 -->
 <bean id="globalExceptionResolver" class="com.prim.exception.GlobalExceptionResolver"></bean>

编写异常页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
 <title>Title</title>
</head>
<body>
<h1>异常显示页面 ${error}</h1>
</body>
</html>

web异常处理机制:处理404和500异常,需要在web.xml中进行配置

 <!-- 异常处理 -->
 <error-page>
     <error-code>404</error-code>
     <location>/400.jsp</location>
 </error-page>
 <error-page>
     <error-code>500</error-code>
     <location>/500.jsp</location>
 </error-page>

拦截器

SpringMVC的拦截器类似于Servlet中的过滤器Filter，用于对处理器进行预处理和后处理拦截器按一定的顺序结成一条链：拦截器链。拦截器也是AOP思想的具体实现

创建拦截器实现HandlerInterceptor接口

public class MyInterceptor1 implements HandlerInterceptor {
 /**
  * 在目标方法执行之前进行拦截
  *
  * @param request
  * @param response
  * @param handler
  * @return false 不放行 true ：放行
  * @throws Exception
  */
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     System.out.println("preHandle");
     return true;
 }

 /**
  * 在目标方法执行之后，视图对象返回之前执行的方法
  *
  * @param request
  * @param response
  * @param handler
  * @param modelAndView
  * @throws Exception
  */
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
     System.out.println("postHandle");
 }

 /**
  * 在流程都执行完成后，执行的方法
  *
  * @param request
  * @param response
  * @param handler
  * @param ex
  * @throws Exception
  */
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
     System.out.println("afterCompletion");
 }
}

配置拦截器在spring-mvc的核心配置文件中进行配置

 <!-- 配置拦截器 -->
 <mvc:interceptors>
     <mvc:interceptor>
         <!-- 对应拦截的路径 /** 对所有controller类的所有方法都进行拦截 -->
         <mvc:mapping path="/**"/>
         <bean class="com.prim.interceptor.MyInterceptor1"/>
     </mvc:interceptor>
 </mvc:interceptors>

测试拦截器的拦截效果 ```java

@Controller public class TargetController { @RequestMapping(“/target”) public String targetMethod() { System.out.println(“目标方法执行了”); return “success”; } }

打印结果如下：

preHandle 目标方法执行了 postHandle afterCompletion

<a name="4nwpj"></a>
#### 拦截连
> 多个拦截器和配置拦截器的顺序和拦截器执行的顺序一致。

```xml
    <!-- 配置拦截器 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 对应拦截的路径 /** 对所有controller类的所有方法都进行拦截 -->
            <mvc:mapping path="/**"/>
            <bean class="com.prim.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!-- 对应拦截的路径 /** 对所有controller类的所有方法都进行拦截 -->
            <mvc:mapping path="/**"/>
            <bean class="com.prim.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

执行结果：

preHandle
preHandle2
目标方法执行了
postHandle2
postHandle
afterCompletion2
afterCompletion

Spring MVC 技术整理