SpringMVC

1. SpringMVC简介

1.1 什么是MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分

M：Model，模型层，指工程中的JavaBean，作用是处理数据

JavaBean分为两类：

• 一类称为实体类Bean：专门存储业务数据的，如Student、User等
• 一类称为业务处理Bean：指Service或Dao对象，专门用于处理业务逻辑和数据访问。

V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据

C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

MVC的工作流程：用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果找到相应的View视图，渲染数据后最终响应给浏览器

1.2 什么是SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子项目

SpringMVC是Spring为表述层开发提供的一整套完备的解决方案。在表述层框架历经Strust、WebWork、Strust2等诸多产品的历代更迭之后，目前业界普遍选择了SpringMVC作为Java EE项目表述层开发的首选方案。

注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台servlet

1.3 SpringMVC的特点

• Spring家族原生产品，与IOC容器等基础设施无缝对接
• 基于原生的Servlet，通过了功能强大的前端控制器DispatcherServlet，对请求和响应进行统一处理
• 表述层各细分领域需要解决的问题全方位覆盖，提供全面解决方案
• 代码清新简洁，大幅度提升开发效率
• 内部组件化程度高，可插拔式组件即插即用，想要什么功能配置相应组件即可
• 性能卓著，尤其适合现代大型、超大型互联网项目要求

2. 入门案例

2.1 创建maven工程

①pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SSM</artifactId>
        <groupId>com.fuli</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springmvc_helloworld</artifactId>
    <!--注意SpringMVC的打包方式要为war，因为是一个web工程，并且这里设置了war打包方式之后，后面在进行第二步的时候就无须单独添加web模块了-->
    <packaging>war</packaging>

    <dependencies>
        <!--SpringMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

        <!--ServletAPI-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

        <!--Spring5和Thymeleaf整合包-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>

    </dependencies>

</project

②添加web模块

最后点击应用，完成即可

完成之后项目结构如下：

2.2 配置web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!--配置 SpringMVC 的前端控制器， 对浏览器发送的请求统一进行处理-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置和名称-->
        <init-param>
            <!-- contextConfigLocation 为固定值 -->
            <param-name>contextConfigLocation</param-name>
            <!--使用classpath:表示从类路径查找配置文件，例如maven工程中的src/main/resources-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--
            作为框架的核心组件，
            在启动过程中有大量的初始化操作要做而这些操作放在第一次请求时才执行会严重影响访问速度
            因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <!--
            设置springMVC的核心控制器所能处理的请求的请求路径:
            /所匹配的请求可以是/login或.html或.js或.css方式的请求路径但是
            /不能匹配.jsp请求路径的请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

标签中使用/和/*的区别：

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请求

因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面

/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写法

2.3 创建请求控制器

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要创建处理具体请求的类，即请求控制器

请求控制器中每一个处理请求的方法成为控制器方法

因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

package com.fuli.spring.controller;

import org.springframework.stereotype.Controller;

@Controller
public class HelloController {
}

2.4 创建SpringMVC的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描包-->
    <context:component-scan base-package="com.fuli.spring.controller"/>

    <!--配置Thymeleaf视图解析器-->
    <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!--视图前缀-->
                        <property name="prefix" value="/WEB-INF/templates/"/>
                        <!-- 视图后缀-->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8"/>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

2.5 测试HelloWorld

package com.fuli.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

//@RequestMapping注解：处理请求和控制器方法之间的映射关系
//@RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径
//localhost:8080/springMVC/
@Controller
public class HelloController {
    @RequestMapping("/index")
    public String testIndex(){
        return "index";
    }

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

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8" >
    <title>Title</title>
</head>
<body>
<h1>这是首页</h1>
<a th:href="@{/hello}">这是我的第一个springMVC案例</a>
</body>
</html>

注意：要想你的html视图能够使用thymeleaf的语法，必须在html视图的html标签中加上xmlns:th="http://www.thymeleaf.org"

index页面的目录结构：

整个工程的目录结构：

测试结果：

2.6 总结

浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器DispatcherServlet处理。

前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器，将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面

3. @RequestMapping注解

3.1 @RequestMapping注解的功能

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

SpringMVC接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

3.2 @RequestMapping注解的位置

• @RequestMapping标识在类上：设置映射请求的请求路径的初始信息
• @RequestMapping标识在方法上：设置映射请求请求路径的具体信息

package com.fuli.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/test")
public class RequestMappingController {
    @RequestMapping("/index")
    public String testIndex(){
        return "index";//若要成功访问视图，则访问饿地址为：http://localhost:8080/SpringMVC/test/index
    }
}

3.3 @RequestMapping注解的value属性

• @RequestMapping注解的value属性通过请求的请求地址匹配请求映射

• @RequestMapping注解的value属性是**一个字符串类型的==数组==**，表示该请求映射能够匹配多个请求地址所对应的请求

• @RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8" >
    <title>Title</title>
</head>
<body>
<h1>这是首页</h1>
<a th:href="@{/hello}">这是我的第一个springMVC案例</a><br>
<a th:href="@{/test/testrequestmapping}">测试@RequestMapping的value属性值</a><br>
<a th:href="@{/test/test}">测试@RequestMapping的value属性值</a><br>
</body>
</html>

package com.fuli.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/test")
public class RequestMappingController {
    @RequestMapping(
            value = {"/test","/testrequestmapping"} //即这里可以是数组，只要是这里面任意一个映射地址都可以
    )
    public String testRequestMappingValue(){
        return "hello";
    }
}

3.4 @RequestMapping注解的method属性

• @RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射
• @RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配多种请求方式的请求
• 若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错405：Request method 'POST' not supported

<form th:action="@{/test/testmetohd}" method="post">
    <input type="submit" value="测试@RequstMapping的method属性">
</form>

    @RequestMapping(
            value = "/testmetohd",
            method = {RequestMethod.POST}
            //这里面可以是数组，如：method = {RequestMethod.POST,RequestMethod.GET}
    )
    public String testRequestMappingMethod(){
        return "hello";
    }

注：

这里的表单提交我设置的是post方式提交，如果你的@RequestMapping的method属性值只有RequestMethod.GET，则会报405错误

1、对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解

• 处理get请求的映射–>@GetMapping
• 处理post请求的映射–>@PostMapping
• 处理put请求的映射–>@PutMapping
• 处理delete请求的映射–>@DeleteMapping

2、常用的请求方式有get、post、put、delete

但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符串（put或delete），则按照默认的请求方式get处理。

若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在RESTful部分会讲到

3.5 @RequestMapping注解的params属性（了解）

• @RequestMapping注解的params属性通过请求的请求参数匹配请求映射
• @RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数和请求映射的匹配关系
• "param"：要求请求映射所匹配的请求必须携带param请求参数
• "param=value"：要求请求映射所匹配的请求必须携带param请求参数且param=value
• "param!=value"：要求请求映射所匹配的请求必须携带param请求参数但是param!=value

<a th:href="@{/test(username='admin',password=123456)">测试@RequestMapping的params属性</a><br>

@RequestMapping(
    value={"/testRequestMapping","/test"},
    method={RequestMethod.GET,RequestMethod.POST},
    params={"username","password!=123456"}
)
public String testRequestMapping(){
    return "success";
}

注：

若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时页面回报错400：Parameter conditions "username, password!=123456" not met for actualrequest parameters: username={admin}, password={123456}

3.6 SpringMVC支持ant风格的路径

• ？：表示任意的单个字符(但是不能为问号本身)

  <!--这里的请求路径为antqwen，可以看出对比下面的控制器的请求路径多了一个q，这个q就是用？来表示了-->
  <a th:href="@{/test/antqwen}">测试ant风格路径的？</a>
  

  @RequestMapping("/ant?wen")//注意这里我写了个问号，表示我的请求路径：ant+任意单个字符+wen
  public String testAntWen(){
      return "hello";
  }
  

  

• *：表示任意的0个或多个字符

  <a th:href="@{/test/antwen}">测试ant风格路径的*</a><br>
  

  @RequestMapping("/ant*wen")
  public String testAntXing(){
      return "hello";
  }
  

  

  <a th:href="@{/test/hhhhhantwen}">测试ant风格路径的*</a><br>
  

  @RequestMapping("/*antwen")
  public String testAntXing(){
      return "hello";
  }
  

  

• **：表示任意层数的任意目录

  注意：在使用**时，只能使用/**/xxx的方式(也就是请求的地址是固定的)

3.7 SpringMVC支持路径中的占位符（重点）

原始方式：/deleteUser?id=1

rest方式：/user/delete/1

SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参；其中@PathVariable注解中的value值可写可不写

<a th:href="@{/test/rest/1}">测试restful风格路径的占位符</a><br>

@RequestMapping("/rest/{id}")
public String testRestFul(@PathVariable("id") Integer id){
    System.out.println("传参过来的id为："+id);
    return "hello";
}

4. SpringMVC获取请求参数

4.1 通过ServletAPI获取(现在用的较少)

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象

<form th:action="@{/test/testservletapi}">
    <input type="text" name="username">
    <input type="text" name="password">
    <input type="submit" value="测试servletAPI获取参数">
</form>

@RequestMapping("/testservletapi")
public String testServletAPI(HttpServletRequest request ){
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    System.out.println("username:"+username+",password:"+password);
    return "hello";
}

4.2 通过控制器方法的形参获取请求参数

在控制器方法的形参位置，设置和请求参数==同名==的形参，当浏览器发送请求，匹配到请求映射时，在DispatcherServlet中就会将请求参数赋值给相应的形参

@RequestMapping("/testservletapi")
public String testServletAPI(String username ,String password ){//用形参来接收，前提是必须要与请求参数同名
    System.out.println("username:"+username+",password:"+password);
    return "hello";
}

4.3 @RequestParam

• @RequestParam是将请求参数和控制器方法的形参创建映射关系

  <form th:action="@{/test/testpojo}">
      <input type="text" name="name">
      <input type="text" name="pwd">
      <input type="submit" value="测试POJO获取参数">
  </form>
  

  @RequestMapping("/testRequestParam")
  public String testServletAPI(@RequestParam("name") String username ,@RequestParam("pwd") String password ){//用形参来接收，若形参与传过来的参数不同名，可以使用@RequestParam来指定
      System.out.println("username:"+username+",password:"+password);
      return "hello";
  }
  

• @RequestParam注解一共有三个属性：

  • value：指定为形参赋值的请求参数的参数名

  • required：设置是否必须传输此请求参数，默认值为true

    若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置defaultValue属性，则页面报错400：Required String parameter 'xxx' is not present；若设置为false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为null

  • defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为””时，则使用默认值为形参赋值

4.4 通过POJO获取请求参数

可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实体类中的属性名一致，那么请求参数就会为此属性赋值

package com.fuli.spring.pojo;

public class User {
    private String name;
    private int age;
    private String sex;
    //无参构造...
    //有参构造...
    //getAndSet
    //toString
}

<form th:action="@{/test/testpojo}">
    <input type="text" name="name">
    <input type="text" name="age">
    <input type="submit" value="测试POJO获取参数">
</form>

@RequestMapping("/testpojo")
public String testPojo(User user){
    System.out.println(user);
    return "hello";
}

4.5 解决获取请求参数的乱码问题

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册

<!--配置springMVC的编码过滤器-->
<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>
    <!--设置了forceEncoding为true之后，表示请求和响应的编码都是UTF-8，如果没设置，则只是请求的编码为UTF-8-->
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

5. 域对象共享数据

5.1 使用ServletAPI向request域对象共享数据

index:
<a th:href="@{/testServletAPI}">测试使用ServletAPI 向 request 域对象共享数据</a>

hello:
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>这是我的第一个springMVC案例</h1>
<p th:text="${testScope}"></p>
</body>
</html>

@RequestMapping("/testServletAPI")
public String testServletAPI(HttpServletRequest request){
    request.setAttribute("testScope","helloSpringMVC");
    return "hello";
}

5.2 使用ModelAndView向request域对象共享数据

<a th:href="@{/testModelAndView}">测试使用ModelAndView 向 request 域对象共享数据</a><br>

hello页面不变

@RequestMapping("/testModelAndView")
/**
 * ModelAndView有Model和View的功能
 * Model主要用于向请求域共享数据
 * View主要用于设置视图，实现页面跳转
 */
public ModelAndView testModelAndView(){
    ModelAndView mav = new ModelAndView();
    //向请求域共享数据
    mav.addObject("testScope","使用ModelAndView向request域共享数据");
    //设置视图，实现页面跳转
    mav.setViewName("hello");
    return  mav;
}

5.3 使用Model向request域对象共享数据

<a th:href="@{/testModel}">测试使用Model 向 request 域对象共享数据</a><br>

@RequestMapping("/testModel")
public String testModel(Model model){
    model.addAttribute("testScope","使用Model向request域共享数据");
    return "hello";
}

5.4 使用map向request域对象共享数据

<a th:href="@{/testMap}">测试使用Map 向 request 域对象共享数据</a><br>

@RequestMapping("/testMap")
public String testMap(Map<String,Object> map){
    map.put("testScope","使用Map向request域共享数据");
    return "hello";
}

5.5 使用ModelMap向request域对象共享数据

@RequestMapping("/testModelMap")
public String testMap(ModelMap modelMap){
    modelMap.addAttribute("testScope","hello,ModelMap");
    return "hello";
}

5.6 Model、ModelMap、Map的关系

Model、ModelMap、Map类型的参数其实本质上都是BindingAwareModelMap类型的

public interface Model{}
public class ModelMap extends LinkedHashMap<String,Object>{}
public class ExtendedModelMap extends ModelMap implements Model{}
public class BindingAwareModelMap extends ExtendedModelMap{}

5.7 向session域共享数据

@RequestMapping("/testSession")
public String testSession(HttpSession session){
    session.setAttribute("testScope","hello,Session");
    return "hello";
}

5.8 向application域共享数据

@RequestMapping("/testApplication")
public String testApplication(HttpSession session){
    ServletContext application = session.getServletContext();
    application.setAttribute("testScope","hello,application");
    return "hello";
}

6. SpringMVC的视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户

SpringMVC视图的种类很多，默认有转发视图和重定向视图

当工程引入jstl的依赖，转发视图会自动转换为JstlView

若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视图解析器解析之后所得到的是ThymeleafView

6.1 ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图后缀所得到的最终路径，会通过转发的方式实现跳转

就如前面的所有案例

6.2 转发视图

SpringMVC中默认的转发视图是InternalResourceView

SpringMVC中创建转发视图的情况：

当控制器方法中所设置的视图名称以"forward:"为前缀时，创建InternalResourceView视图，此时的视图名称==不会==被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"forward:"去掉，剩余部分作为最终路径通过转发的方式实现跳转

例如：

@RequestMapping("/testForward")
public String testForward(){
    return "forward:/testHello";//最终转发的路径的为/testHello(在地址栏中看不见testHello)
}

6.3 重定向视图

SpringMVC中默认的重定向视图是RedirectView

当控制器方法中所设置的视图名称以"redirect:"为前缀时，创建RedirectView视图，此时的视图名称==不会==被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀"redirect:"去掉，剩余部分作为最终路径通过重定向的方式实现跳转

@RequestMapping("/testRedirect")
public String testRedirect(){
    return "redirect:/testHello";//最终重定向的路径的为/testHello(在地址栏中显示的是testHello)
}

注:

重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径

6.4 视图控制器view-controller

当控制器方法中，仅仅用来实现页面跳转，而没有任何的逻辑实现，即只需要设置视图名称时，可以将处理器方法使用view-controller标签进行表示

例如下面的情况：只是用来页面的跳转，就无需单独写个controller方法，只需要在SpirngMVC核心配置文件中配置即可

package com.fuli.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ProtalController {
    @RequestMapping("/")
    public String protal(){
        return "index";
    } 
}

改进：取消上面的controller方法

<!--
    path：设置处理的请求地址
    view-name：设置请求地址所对应的视图名称
-->
<mvc:view-controller path="/index" view-name="index"></mvc:view-controller>

注意：

当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将==全部失效==，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：<mvc:annotation-driven />

如果没有开启mvc的注解驱动标签，则除了view-controller中的请求能够访问以外，其他所有的请求都无法访问，会出现404

所以，最好两种连着使用

<mvc:annotation-driven/>
<mvc:view-controller path="/index" view-name="index"></mvc:view-controller>

7. RESTful

7.1 RESTful实现

具体说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。

它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源，PUT用来更新资源，DELETE用来删除资源。

REST风格提倡URL地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为URL地址的一部分，以保证整体风格的一致性。

操作	传统放视	REST风格
查询操作	getUserById?id=1	user/1–>get请求方式
保存操作	saveUser	user–>post请求方式
删除操作	deleteUser?id=1	user/1–>delete请求方式
更新操作	updateUser	user–>put请求方式

7.2 HiddenHttpMethodFilter(重要)

由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？

SpringMVC提供了HiddenHttpMethodFilter帮助我们将POST请求转换为DELETE或PUT请求

HiddenHttpMethodFilter处理put和delete请求的条件：

• 当前请求的请求方式必须为post
• 当前请求必须传输请求参数_method

满足以上条件，HiddenHttpMethodFilter过滤器就会将当前请求的请求方式转换为请求参数_method的值，因此请求参数_method的值才是最终的请求方式

<form th:action="@{/testREST}" method="post"><!--这里的method只能写post-->
    <!--这里的name只能写_method，value值，如果你想是put方式发送请求就写put，如果想是delete方式方式请求就写delete-->
    <input type="hidden" name="_method" value="put"> <!--注意这个标签是隐藏了的-->
    <input type="submit" value="更新用户信息">
</form>

在**web.xml**中注册HiddenHttpMethodFilter

<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

注：

目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和HiddenHttpMethodFilter

在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter

8. RESTful案例(这个案例的数据层是写死了的)

8.1 准备工作

和传统CRUD一样，实现对员工信息的增删改查。

• 准备实体类

  package com.fuli.springmvc.pojo;
  
  
  public class Employee {
      private Integer id;
      private String lastName;
      private String email;
      //1 male,0 female
      private Integer gender;
  
      public Employee() {
      }
  
      public Employee(Integer id, String lastName, String email, Integer gender) {
          this.id = id;
          this.lastName = lastName;
          this.email = email;
          this.gender = gender;
      }
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getLastName() {
          return lastName;
      }
  
      public void setLastName(String lastName) {
          this.lastName = lastName;
      }
  
      public String getEmail() {
          return email;
      }
  
      public void setEmail(String email) {
          this.email = email;
      }
  
      public Integer getGender() {
          return gender;
      }
  
      public void setGender(Integer gender) {
          this.gender = gender;
      }
  
      @Override
      public String toString() {
          return "Employee{" +
                  "id=" + id +
                  ", lastName='" + lastName + '\'' +
                  ", email='" + email + '\'' +
                  ", gender=" + gender +
                  '}';
      }
  }
  

• 准备dao模拟数据

  package com.fuli.springmvc.dao;
  
  import com.fuli.springmvc.pojo.Employee;
  import org.springframework.stereotype.Repository;
  
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Map;
  
  @Repository
  public class EmployeeDao {
      private static Map<Integer, Employee> employees = null;
      static{
          employees = new HashMap<Integer, Employee>();
          employees.put(1001, new Employee(1001, "E-AA", "aa@163.com", 1));
          employees.put(1002, new Employee(1002, "E-BB", "bb@163.com", 1));
          employees.put(1003, new Employee(1003, "E-CC", "cc@163.com", 0));
          employees.put(1004, new Employee(1004, "E-DD", "dd@163.com", 0));
          employees.put(1005, new Employee(1005, "E-EE", "ee@163.com", 1));
      }
  
      private static Integer initId = 1006;
  
      //这个保存方法既有添加对象的功能，也有修改对象的功能
      public void save(Employee employee){
          if (employee.getId() == null){
              employee.setId(initId++);
          }
          employees.put(employee.getId(), employee);
      }
  
      //查询所有对象
      public Collection<Employee> getAll(){
          return employees.values();
      }
  
      //根据id查询某个员工信息
      public Employee getEmployee(Integer id){
          return employees.get(id);
      }
  
      public void deleteEmployee(Integer id){
          employees.remove(id);
      }
  }
  

• web.xml

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
           version="3.1">
      <!--编码过滤器-->
      <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>
          <init-param>
              <param-name>forceEncoding</param-name>
              <param-value>true</param-value>
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>CharacterEncodingFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  
      <!--用来处理put和delete请求-->
      <filter>
          <filter-name>HiddenHttpMethodFilter</filter-name>
          <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
      </filter>
      <filter-mapping>
          <filter-name>HiddenHttpMethodFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  
      <servlet>
          <servlet-name>SpringMVC</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          <init-param>
              <param-name>contextConfigLocation</param-name>
              <param-value>classpath:springmvc.xml</param-value>
          </init-param>
          <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
          <servlet-name>SpringMVC</servlet-name>
          <url-pattern>/</url-pattern>
      </servlet-mapping>
  </web-app>
  

• 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/context
         https://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/mvc
         http://www.springframework.org/schema/mvc/spring-mvc.xsd  ">
  
      <!--开启自动扫描-->
      <context:component-scan base-package="com.fuli.springmvc"/>
  
      <!--配置Thymeleaf视图解析器-->
      <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
          <property name="order" value="1"/>
          <property name="characterEncoding" value="UTF-8"/>
          <property name="templateEngine">
              <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                  <property name="templateResolver">
                      <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                          <!--视图前缀-->
                          <property name="prefix" value="/WEB-INF/templates/"/>
                          <!-- 视图后缀-->
                          <property name="suffix" value=".html"/>
                          <property name="templateMode" value="HTML5"/>
                          <property name="characterEncoding" value="UTF-8"/>
                      </bean>
                  </property>
              </bean>
          </property>
      </bean>
  
      <!--开启MVC注解驱动-->
      <mvc:annotation-driven/>
  
      <mvc:view-controller path="/index" view-name="index"/>
      <mvc:view-controller path="/to/add" view-name="employee_add"/><!--跳转到添加员工界面-->
  </beans>
  

8.2 显示全部员工

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>employee_list</title>
</head>
<body>
    <table border = "1">
        <tr>
            <th colspan="5">employee Info</th>
        </tr>
        <tr>
            <td>id</td>
            <td>lastName</td>
            <td>email</td>
            <td>gender</td>
            <td>options(<a th:href="@{/to/add}">add</a>)</td>
        </tr>
        <tr th:each="employee : ${employeesList}">
            <td th:text="${employee.id}"></td>
            <td th:text="${employee.lastName}"></td>
            <td th:text="${employee.email}"></td>
            <td th:text="${employee.gender}"></td>
            <td>
                <a th:href="@{'/employee'+${employee.id}">delete</a>
                <a href="">update</a>
            </td>

        </tr>
    </table>
</body>
</html>

• 控制器

  package com.fuli.springmvc.controller;
  
  import com.fuli.springmvc.dao.EmployeeDao;
  import com.fuli.springmvc.pojo.Employee;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.PostMapping;
  
  import java.util.Collection;
  
  /**
   * 使用restful风格
   * 查询所有员工信息：/employee--->GET
   * 跳转到添加员工信息界面：/to/add
   * 添加员工信息：/employee---->POST
   * 删除员工信息：/employee/id---->DELETE
   */
  @Controller
  public class EmplyeeController {
      @Autowired
      private EmployeeDao employeeDao;
  
      @GetMapping("/employee")
      public String getEmployeeList(Model model){
          Collection<Employee> employees = employeeDao.getAll();
          //共享数据到域对象
          model.addAttribute("employeesList",employees);
          return "employee_list";
      }
  }
  

8.3 添加员工信息

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>employee_add</title>
</head>
<body>
<form th:action="@{/employee}" method="post">
    <table border="1">
        <tr>
            <th colspan="2">employee_add</th>
        </tr>
        <tr>
            <td>lastName</td>
            <td><input type="text" name="lastName"></td>
        </tr>
        <tr>
            <td>email</td>
            <td><input type="text" name="email"></td>
        </tr>
        <tr>
            <td>gender</td>
            <td>
                <input type="radio" name= "gender" value="1" >male
                <input type="radio" name= "gender" value="0" >female
            </td>
        </tr>
        <tr>
            <td colspan="2">
                <input type="submit" value="提交">
            </td>
        </tr>
    </table>
</form>
</body>
</html>

• 控制器

  package com.fuli.springmvc.controller;
  
  import com.fuli.springmvc.dao.EmployeeDao;
  import com.fuli.springmvc.pojo.Employee;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.PostMapping;
  
  import java.util.Collection;
  
  /**
   * 使用restful风格
   * 查询所有员工信息：/employee--->GET
   * 跳转到添加员工信息界面：/to/add
   * 添加员工信息：/employee---->POST
   * 删除员工信息：/employee/id---->DELETE
   */
  @Controller
  public class EmplyeeController {
      @Autowired
      private EmployeeDao employeeDao;
  
      @GetMapping("/employee")
      public String getEmployeeList(Model model){
          Collection<Employee> employees = employeeDao.getAll();
          //共享数据到域对象
          model.addAttribute("employeesList",employees);
          return "employee_list";
      }
  
      @PostMapping("/employee")
      public String addEmployee(Employee employee){
          employeeDao.save(employee);
          /**
           * 为什么此处要用重定向：
           * 因为当你点击添加按钮的时候提交表单，走的是这个方法
           * 当这个方法走完return的时候，你不能直接跳转到employee_list页面
           * 也就是你不能直接写return “employee_list”
           * 因为你要先到“/employee”之后，获取全部的员工对象之后，才有数据展示
           */
          return "redirect:/employee";
      }
  }
  

• 删除需要用到Vue，暂时没有，所以没写，修改也暂时没写

9. SpringMVC处理ajax请求

9.1 @RequestBody

@RequestBody可以获取请求体信息，使用@RequestBody注解**标识控制器方法的==形参==**，当前请求的请求体就会为当前注解所标识的形参赋值

<!--此时必须使用post请求方式，因为get请求没有请求体-->
<form th:action="@{/test/RequestBody}" method="post">
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit">
</form>

@RequestMapping("/test/RequestBody")
public String testRequestBody(@RequestBody String requestBody){
    System.out.println("requestBody:"+requestBody);
    return "success";
}

输出结果：

requestBody:username=admin&password=123456(这个数据是从ajax获取的，上面的代码并没有显示出来)

9.2 @RequestBody获取json格式的请求参数

在使用了axios发送ajax请求之后，浏览器发送到服务器的请求参数有两种格式：

1、name=value&name=value...，此时的请求参数可以通过request.getParameter()获取，对应SpringMVC中，可以直接通过控制器方法的形参获取此类请求参数

2、{key:value,key:value,...}，此时无法通过request.getParameter()获取，之前我们使用操作json的相关jar包gson或jackson处理此类请求参数，可以将其转换为指定的实体类对象或map集合。在SpringMVC中，直接使用@RequestBody注解标识控制器方法的形参即可将此类请求参数转换为java对象

使用@RequestBody获取json格式的请求参数的条件：

1. 导入jackson的依赖

   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.12.1</version>
   </dependency>
   

2. SpringMVC的配置文件中设置开启mvc的注解驱动

   <!--开启mvc的注解驱动-->
   <mvc:annotation-driven/>
   

3. 在控制器方法的形参位置，设置json格式的请求参数要转换成的java类型（实体类或map）的参数，并使用@RequestBody注解标识

   <input type="button" value="测试@RequestBody获取json格式的请求参数" @click="testRequestBody()"><br>
   <script type="text/javascript" th:src="@{/js/vue.js}"></script>
   <script type="text/javascript"th:src="@{/js/axios.min.js}"></script>
   <script type="text/javascript">
       var vue = new Vue({
           el:"#app",
           methods:{
               testRequestBody(){
                   axios.post(
                       "/SpringMVC/test/RequestBody/json",
                       {username:"admin",password:"123456"}//这个就是json格式的数据
                   ).then(response=>{
                       console.log(response.data);
                   });
               }
           }
       });
   </script>
   

   //将json格式的数据转换为map集合
   @RequestMapping("/test/RequestBody/json")
   public void testRequestBody(@RequestBody Map<String,Object> map,HttpServletResponse response) throws IOException{
       System.out.println(map);
       //{username=admin,password=123456}
       response.getWriter().print("hello,axios");
   }
   
   //将json格式的数据转换为实体类对象
   @RequestMapping("/test/RequestBody/json")
   public void testRequestBody(@RequestBody User user,HttpServletResponse response)throws IOException{
       System.out.println(user);
       //User{id=null,username='admin',password='123456',age=null,gender='null'}
       response.getWriter().print("hello,axios");
   }
   

9.3 @ResponseBody

@ResponseBody用于标识一个控制器方法，可以将该方法的返回值直接作为响应报文的响应体响应到浏览器

@RequestMapping("/testResponseBody")
public String testResponseBody(){
    //此时会跳转到逻辑视图success所对应的页面
    return"success";
}

@RequestMapping("/testResponseBody")
@ResponseBody
public String testResponseBody(){
    //此时响应浏览器数据success
    return"success";//即是浏览器显示的就是success字符串
}

9.4 @ResponseBody响应浏览器json数据

服务器处理ajax请求之后，大多数情况都需要向浏览器响应一个java对象，此时必须将java对象转换为json字符串才可以响应到浏览器，之前我们使用操作json数据的jar包gson或jackson将java对象转换为json字符串。在SpringMVC中，我们可以直接使用@ResponseBody注解实现此功能

@ResponseBody响应浏览器json数据的条件：

1. 导入jackson的依赖

   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.12.1</version>
   </dependency>
   

2. SpringMVC的配置文件中设置开启mvc的注解驱动

   <!--开启mvc的注解驱动-->
   <mvc:annotation-driven/>
   

3. 使用@ResponseBody注解标识控制器方法，在方法中，将需要转换为json字符串并响应到浏览器的java对象作为控制器方法的返回值，此时SpringMVC就可以将此对象直接转换为json字符串并响应到浏览器

   <input type="button" value="测试@ResponseBody响应浏览器json格式的数据" @click="testResponseBody()"><br>
   <script type="text/javascript" th:src="@{/js/vue.js}"></script>
   <script type="text/javascript" th:src="@{/js/axios.min.js}"></script>
   <scripttype="text/javascript">
       var vue = new Vue({
           el:"#app",
           methods:{
               testResponseBody(){
               axios.post("/SpringMVC/test/ResponseBody/json").then(response=>{
                   console.log(response.data);
               });
               }
           }
       });
   </script>
   

   //响应浏览器list集合
   @RequestMapping("/test/ResponseBody/json")
   @ResponseBody
   public List<User> testResponseBody(){
       User user1 = new User(1001,"admin1","123456",23,"男");
       User user2 = new User(1002,"admin2","123456",23,"男");
       User user3 = new User(1003,"admin3","123456",23,"男");
       List<User> list = Arrays.asList(user1,user2,user3);
       return list;
   }
   //响应浏览器map集合
   @RequestMapping("/test/ResponseBody/json")
   @ResponseBody
   public Map<String,Object> testResponseBody(){
       User user1 = new User(1001,"admin1","123456",23,"男");
       User user2 = new User(1002,"admin2","123456",23,"男");
       User user3 = new User(1003,"admin3","123456",23,"男");
       Map<String,Object> map = new HashMap<>();
       map.put("1001",user1);
       map.put("1002",user2);
       map.put("1003",user3);
       returnmap;
   }
   //响应浏览器实体类对象
   @RequestMapping("/test/ResponseBody/json")
   @ResponseBody
   public User testResponseBody(){
       return user;
   }
   

9.5 @RestController注解

@RestController注解是springMVC提供的一个复合注解，标识在控制器的类上，就相当于为类添加了@Controller注解，并且为其中的每个方法添加了@ResponseBody注解

10 .文件上传和下载

10.1 文件下载(以后照着这个写就可以，只需要替换文件名即可)

ResponseEntity用于控制器方法的返回值类型，该控制器方法的返回值就是响应到浏览器的响应报文使用ResponseEntity实现下载文件的功能

package com.fuli.springmvc.controller;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

@Controller
public class FileController {

    @RequestMapping("/testDown")
    public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws Exception {
        //获取ServletContext对象
        ServletContext servletContext = session.getServletContext();

        //获取服务器中文件的真实路径
        String path = servletContext.getRealPath("/img/tou.jpg");

        //创建输入流
        InputStream is = new FileInputStream(path);

        //创建字节数组
        byte[] bytes = new byte[is.available()];

        //将流读到字节数组中
        is.read(bytes);

        //创建 HttpHeaders 对象设置响应头信息
        MultiValueMap<String,String> headers = new HttpHeaders();

        //设置要下载方式以及下载文件的名字
        headers.add("Content-Disposition", "attachment;filename=tou.jpg");

        //设置响应状态码
        HttpStatus status = HttpStatus.OK;

        //创建ResponseEntity对象
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<byte[]>(bytes, headers, status);

        //关闭流
        is.close();
        return responseEntity;
    }
}

图片路径：和web-inf 在同一层

10.2 文件上传

文件上传要求form表单的请求方式必须为post，并且添加属性enctype="multipart/form-data"``SpringMVC中将上传的文件封装到MultipartFile对象中，通过此对象可以获取文件相关信息

上传步骤：

1. 添加依赖：

   <!--https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload-->
   <dependency>
       <groupId>commons-fileupload</groupId>
       <artifactId>commons-fileupload</artifactId>
       <version>1.3.1</version>
   </dependency>
   

2. 在SpringMVC的配置文件中添加配置：

    <!--必须通过文件解析器的解析才能将文件转换为MultipartFile对象-->
   <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
   </beans>
   

3. 上传页面

   <!DOCTYPE html>
   <html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
       <meta charset="UTF-8" >
       <title>index</title>
   </head>
   <body>
   <h1>首页</h1>
   <form th:action="@{/testUp}" enctype="multipart/form-data" method="post">
       头像：<input type="file" name="photo"><br>
       <input type="submit" value="上传">
   </form>
   </body>
   </html>
   

4. 控制器方法：

   @RequestMapping(value = "/testUp",method = RequestMethod.POST)
   public String testUp(MultipartFile photo, HttpSession session) throws IOException {
       //获取上传的文件的文件名
       String filename = photo.getOriginalFilename();
       //处理文件重名问题(这里使用的是UUID)
       //这句话的意思就是将获取最后一个.之后的字符串，也就是后缀：例如tou.jpg获取的就是.jpg
       String hzName = filename.substring(filename.lastIndexOf("."));
       filename = UUID.randomUUID().toString()+hzName;//使用UUID来解决文件名冲突问题
   
       //获取服务器中photo目录的路径
       ServletContext servletContext = session.getServletContext();
       String path = servletContext.getRealPath("phone");
       File file = new File(path);
       if (!file.exists()){
           file.mkdir();//如果该文件夹不存在，那么就创建一个该文件夹
       }
       String filePath = path + File.separator + filename;
   
       //实现上传功能
       photo.transferTo(new File(filePath));
       return "success";
   }
   

   结果：

   

   可以看出这个图片的文件名很乱，这就是使用UUID来解决文件重名的问题

11. 拦截器

11.1 拦截器的配置

SpringMVC中的拦截器用于拦截控制器方法的执行

SpringMVC中的拦截器需要实现HandlerInterceptor

package com.fuli.springmvc.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class FirstInterceptor implements HandlerInterceptor{
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("FirstInterceptor------------>preHandle");
        return false;//设置为false表示拦截，设置为true表示放行
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("FirstInterceptor------------>postHandle");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("FirstInterceptor------------>afterCompletion");
    }
}

SpringMVC的拦截器必须在SpringMVC的配置文件中进行配置：

<!--这里也可以不用写bean，只需要把自己的拦截器添加一个Component注解，就可以交给IOC容器来管理了-->
<bean id="FirstInterceptor" class="com.fuli.springmvc.interceptor.FirstInterceptor"></bean>
<mvc:interceptors>
    <!--<bean class="com.fuli.springmvc.interceptor.FirstInterceptor"/>-->
    <!--<ref bean="FirstInterceptor"/>-->
    <!-- 以上两种配置方式都是对 DispatcherServlet 所处理的所有的请求进行拦截(对所有请求进行拦截的时候，二选一即可) -->

    <!--使用如下配置，可以配置那些请求需要拦截，那些则排除拦截-->
    <mvc:interceptor>
        <!--表示对所有的请求进行拦截-->
        <mvc:mapping path="/**"/>
        <!--表示排除对/index请求-->
        <mvc:exclude-mapping path="/index"/>
        <ref bean="FirstInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

11.2 拦截器的三个抽象方法

SpringMVC中的拦截器有三个抽象方法：

preHandle：控制器方法执行==之前==执行preHandle()，其boolean类型的返回值表示是否拦截或放行，返回true为放行，即调用控制器方法；返回false表示拦截，即不调用控制器方法

postHandle：控制器方法执行之后执行postHandle()

afterCompletion：处理完视图和模型数据，渲染视图完毕之后执行afterCompletion()

11.3 多个拦截器的执行顺序

①若每个拦截器的preHandle()都返回true

此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关：

preHandle()会按照配置的顺序执行，而postHandle()和afterCompletion()会按照配置的==反序==执行

②若某个拦截器的preHandle()返回了false

preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterCompletion()会执行

12. 异常处理器

12.1 基于配置的异常处理

SpringMVC提供了一个处理控制器方法执行过程中所出现的异常的接口：HandlerExceptionResolver

HandlerExceptionResolver接口的实现类有：DefaultHandlerExceptionResolver和SimpleMappingExceptionResolver

SpringMVC提供了自定义的异常处理器SimpleMappingExceptionResolver，使用方式：

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="exceptionMappings">
        <props>
            <!--
                properties的键表示处理器方法执行过程中出现的异常
                properties的值表示若出现指定异常时，设置一个新的视图名称，跳转到指定页面
            -->
            <prop key="java.lang.ArithmeticException">error</prop>
        </props>
    </property>
    
    <!--exceptionAttribute属性设置一个属性名，将出现的异常信息在请求域中进行共享-->
    <property name="exceptionAttribute" value="ex"></property>
</bean>

12.2 基于注解的异常处理

//@ControllerAdvice将当前类标识为异常处理的组件
@ControllerAdvice
public class ExceptionController{
    //@ExceptionHandler用于设置所标识方法处理的异常
    @ExceptionHandler(ArithmeticException.class)
    //ex表示当前请求处理中出现的异常对象
    public String handleArithmeticException(Exception ex,Model model){
        //把异常共享到域对象中
        model.addAttribute("ex",ex);
        return "error";
    }
}

13. 注解配置SpringMVC

使用配置类和注解代替web.xml和SpringMVC配置文件的功能

13.1 创建初始化类，代替web.xml

在Servlet3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果找到的话就用它来配置Servlet容器。Spring提供了这个接口的实现，名为SpringServletContainerInitializer，这个类反过来又会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。Spring3.2引入了一个便利的WebApplicationInitializer基础实现，名为AbstractAnnotationConfigDispatcherServletInitializer，当我们的类扩展了AbstractAnnotationConfigDispatcherServletInitializer并将其部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文。

public class WebInit extends AbstractAnnotationConfigDispatcherServletInitializer{
    /**
    *指定spring的配置类
    *
    @return
    */
    @Override
    protected Class<?>[] getRootConfigClasses(){
        return new Class[]{SpringConfig.class};
    }
    /**
    *指定SpringMVC的配置类
    *
    @return
    */
    @Override
    protected Class<?>[] getServletConfigClasses(){
        return new Class[]{WebConfig.class};
    }
    /**
    *指定DispatcherServlet的映射规则，即url-pattern
    *
    @return
    */
    @Override
    protected String[] getServletMappings(){
        return new String[]{"/"};
    }
    /**
    *添加过滤器
    *
    @return
    */
    @Override
    protected Filter[] getServletFilters(){
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");
        encodingFilter.setForceRequestEncoding(true);
          HiddenHttpMethodFilter hiddenHttpMethodFilter = new HiddenHttpMethodFilter();
        return new Filter[]{encodingFilter,hiddenHttpMethodFilter};
    }
}

13.2 创建SpringConfig配置类，代替spring的配置文件

//别忘了加注解，只有加上@Configuration这个类才是配置类
@Configuration
public class SpringConfig{
    //ssm整合之后，spring的配置信息写在此类中
}

13.3 创建WebConfig配置类，代替SpringMVC的配置文件

@Configuration
//扫描组件
@ComponentScan("com.fuli.mvc.controller")
//开启MVC注解驱动
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer{
    //使用默认的servlet处理静态资源
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer){
        configurer.enable();
    }
    //配置文件上传解析器
    @Bean
    public CommonsMultipartResolver multipartResolver(){
        return new CommonsMultipartResolver();
    }
    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry){
        FirstInterceptor firstInterceptor = newFirstInterceptor();
           registry.addInterceptor(firstInterceptor).addPathPatterns("/**");
    }
    //配置视图控制
    /*@Override
    public void addViewControllers(ViewControllerRegistry registry){
        registry.addViewController("/").setViewName("index");
    }*/
    //配置异常映射
    /*@Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers){
        SimpleMappingExceptionResolver exceptionResolver = new SimpleMappingExceptionResolver();
        Properties prop = new Properties();
        prop.setProperty("java.lang.ArithmeticException","error");
        //设置异常映射
        exceptionResolver.setExceptionMappings(prop);
        //设置共享异常信息的键
        exceptionResolver.setExceptionAttribute("ex");
        resolvers.add(exceptionResolver);
        }*/
    //配置生成模板解析器
    @Bean
    public ITemplateResolver templateResolver(){
        WebApplicationContext webApplicationContext = ContextLoader.getCurrentWebApplicationContext();
        //ServletContextTemplateResolver需要一个ServletContext作为构造参数，可通过WebApplicationContext的方法获得
        ServletContextTemplateResolver templateResolver = new ServletContextTemplateResolver(webApplicationContext.getServletContext());
        templateResolver.setPrefix("/WEB-INF/templates/");
        templateResolver.setSuffix(".html");
        templateResolver.setCharacterEncoding("UTF-8");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        returntemplateResolver;
     }
    //生成模板引擎并为模板引擎注入模板解析器
    @Bean
    public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver){
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        return templateEngine;
    }
    //生成视图解析器并未解析器注入模板引擎
    @Bean
    public ViewResolver viewResolver(SpringTemplateEnginetemplateEngine){
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        	viewResolver.setCharacterEncoding("UTF-8");
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
}

13.4 测试功能

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