Spring MVC 是 Spring 给我们提供的一个基于简化 Web 开发的框架

• 主要内容：
• 1、Spring MVC 应用（常规使用）
  2、Spring MVC 高级技术（拦截器、异常处理器等——全局生效的）
  3、手写 MVC 框架（自定义 MVC 框架，难点/重点）
  4、Spring MVC 源码深度剖析（难点/重点）
  5、SSM 整合

第一部分 Spring MVC 应用

第 1 节 Spring MVC 简介

1.1 MVC 体系结构

1、在 JavaEE 开发中，几乎全都是基于 B/S 架构的开发。那么在 B/S 架构中，系统标准的三层架构包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多，所以我们课程中的案例也都是基于三层架构设计的。 三层架构中，每一层各司其职，接下来我们就说说每层都负责哪些方面：

表现层

也就是我们常说的web层。它负责接收客户端请求， 向客户端响应结果， 通常客户端使用http协议请求web层， web需要接收http请求， 完成http响应。
表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。
表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。
表现层的设计一般都使用MVC模型。(MVC是表现层的设计模型， 和其他层没有关系)

业务层

也就是我们常说的service层。它负责业务逻辑处理， 和我们开发项目的需求息息相关。web层依赖业务层， 但是业务层不依赖web层。
业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。(也就是我们说的，事务应该放到业务层来控制)

持久层

也就是常说的dao层。负责数据持久化， 包括数据层即数据库和数据访问层， 数据库是对数据进行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库中。通俗的讲，持久层就是和数据库交互，对数据库表进行增删改查的。

MVC设计模式

MVC全名是Model View Controller， 是模型(model) -视图(view) -控制器(controller) 的缩写， 是一种用于设计创建Web应用程序表现层的模式。MVC中每个部分各司其职：

• Model(模型) ：模型包含业务模型和数据模型， 数据模型用于封装数据， 业务模型用于处理业务。
• View(视图) ：通常指的就是我们的jsp或者html。作用一般就是展示数据的。通常视图是依据模型数据创建的。
• Controller(控制器) ：是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。 MVC提倡：每一层只编写自己的东西， 不编写任何其他的代码； 分层是为了解耦， 解耦是为了维护方便和分工协作。

MVC框架是应用于表现层的框架。

1.2 Spring MVC 是什么？

Spring MVC已经成为目前最主流的MVC框架之一， 并且随着Spring 3.0的发布， 全面超越Struts2，成为最优秀的MVC框架。
servlet、struts实现接口、spring mvc中要让一个java类能够处理请求只需要添加注解就ok
它通过一套注解， 让一个简单的Java类成为处理请求的控制器， 而无须实现任何接口。同时它还支持RESTful编程风格的请求。

总之：Spring MVC和Struts 2一样， 都是为了解决表现层问题的web框架， 它们都是基于MVC设计模式的。而这些表现层框架的主要职责就是处理前端HTTP请求。
Spring MVC本质可以认为是对servlet的封装， 简化了我们serlvet的开发
作用：1)接收请求。2)返回响应，跳转页面

第 2 节 Spring Web MVC 工作流程

需求：前端浏览器请求url：http://localhost:8080/demo/handle01，前端页面显示后台服务器的时间 开发过程
1）配置DispatcherServlet前端控制器
2）开发处理具体业务逻辑的Handler（@Controller、@RequestMapping）
3）xml配置文件配置controller扫描，配置springmvc三大件
4）将xml文件路径告诉springmvc（DispatcherServlet）

1先要创建一个maven项目。

2再者需要添加jar依赖

<?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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.shanglin.edu</groupId>
    <artifactId>springmvc-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--引入spring webmvc的依赖。因为springweb是spring的外部功能，
                        所以一定会依赖springcontext这些功能-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.6.1</version>
            <configuration>
                <source>11</source>
                <target>11</target>
            </configuration>
            </plugin>
            <!--要把tomcat的插件引入进来-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port><!--指定端口号-->
                    <path>/</path><!--指定上下文-->
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3到web.xml进行配置控制器老大DispatcherServlet.(全局只有一个)

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!--引入唯一控制全局的老大，也就是配置一个Servlet-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--方式一：带后缀，比如*.action   *.do  *.aaa
        方式二： /不会拦截.jsp  ,为什么呢，因为没有继承父类的对jsp的拦截
        方式三： /* 拦截所有，包括.jsp-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

4然后添加控制器、文件夹、页面

/**
 * @Description: 以前普通Java类要处理具体的业务逻辑，则必须要实现某个接口，
 * 但现在只需要将他标识为Spring ioc容器当中的一个对象controler，只需要添加一个注解
 * 可以使用requestMapping将URL导向到具体处理业务逻辑的方法里。
 * 请求映射，所以可以将demo标识在上面。里面就是具体的方法映射。
 * 一个请求来了先从根开始匹配，匹配到demo,再匹配到handle01
 * @Author: shanglin
 * @Date: 2020-08-04 22:13
 */
@Controller
@RequestMapping("/demo")
public class DemoController {
    @RequestMapping("/handle01")
    public ModelAndView handle01(){
         Date date = new Date();//服务器时间
        // 返回服务器时间到前端页面
        //　封装了数据和页面信息的ModelAndView
        ModelAndView modelAndView = new ModelAndView();
        // addObject 其实是向请求域中request。setAttribute("data",date);
        modelAndView.addObject("date",date);
        //将视图信息封装然后跳转到对应的页面去展示信息
        modelAndView.setViewName("WEB-INF/jsp/success.jsp");
        return modelAndView;
    }
}

succese.jsp

<html>
<head>
    <title>Title</title>
</head>
<body>
跳转成功，服务器时间：${date}
</body>
</html>

但是WEB-INF/jsp/success.jsp是物理路径的地址，对后期的维护和修改很不方便。所以
需要配置一个视图解释器（就是把前缀、后缀提取出去）
提取到配置文件当中，其实就是Spring的配置文件，它是用于扫描controller。因为SpringIoC本来就是基于Spring的

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
       https://www.springframework.org/schema/mvc/spring-mvc.xsd
        ">

    <!--引入了context再配置下面的信息-->
    <!--开始controller扫描（扫描其下的包的控制器）-->
    <context:component-scan base-package="com.shanglin.edu.controller"/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/><!--前缀-->
        <property name="suffix" value=".jsp"/><!--后缀-->
    </bean>

    <!--自动注册最合适的处理器映射器，处理器适配器（如果不指定，它是去使用默认的）-->
    <mvc:annotation-driven/>

</beans>

上面的代码就可以改为用一个单词就可以，不用写前缀后缀

modelAndView.setViewName("success");

到此，三大件已经OK。

5需要设置在项目的那个地方进行加载

Springmvc虽然已经配置好了文件，但是还需要设置在项目的那个地方进行加载。
因为项目启动的时候肯定会去读取这个配置文件，所以配置文件需要告知项目/框架

6然后就是运行项目

2.1 Spring MVC 请求处理流程

流程说明

第一步：用户发送请求至前端控制器DispatcherServlet（进行拦截，它是整个Spring mvc 的老大。一旦请求Spring mvc去处理，这个老大它不自己去处理这个请求，而是把这个请求转发给具体处理当前请求的handler ）
第二步：DispatcherServlet收到请求调用HandlerMapping处理器映射器（它会去问处理器映射器要处理当前请求的这个handler是谁？）
第三步：处理器映射器根据请求Url找到具体的Handler(后端控制器) ， 生成处理器对象及处理器拦截器(如果有则生成) 一并返回DispatcherServlet（这个处理器映射器可以认为是一个map。这个map 当中的key 就是url 。value就是能够处理这个url 的handler，一旦发现有能够处理url 的handler，这个时候就会返回，返回的其实是一个执行链。这个执行链其实是一环一环的）
第四步：DispatcherServlet调用HandlerAdapter处理器适配器去调用Handler（现在是通过注解的方式，所以一个类可以有多个处理方法，也就是多个handler，适配器根据你handler的情况找到和他匹配的handlerAdapter）
第五步：处理器适配器执行Handler
第六步：Handler执行完成给处理器适配器返回ModelAndView（将结果封装到一个对象中）
第七步：处理器适配器向前端控制器返回ModelAndView， ModelAndView是Spring MVC框架的一个底层对象， 包括Model数据和View视图
第八步：前端控制器请求视图解析器去进行视图解析，根据逻辑视图名来解析真正的视图。（在springmvc.xml配置文件中，它的前面后面要把前缀，后缀给它拼接起来，中间加上这个逻辑视图名如：success，最终找到我们的物理视图）
第九步：视图解析器向前端控制器返回View
第十步：前端控制器进行视图渲染， 就是将模型数据(在ModelAndView对象中) 填充到request域
第十一步：前端控制器向用户响应结果。从request域中取出数据，进行展示。

2.2 Spring MVC 九大组件

HandlerMapping(处理器映射器)
HandlerMapping存储了Handler和URL的映射关系，是用来查找Handler的， 也就是处理器， 具体的表现形式可以是类（这种使用起来不太方便）， 也可以是方法。比如， 标注了@RequestMapping的每个方法都可以看成是一个Handler。Handler负责具体实际的请求处理， 在请求到达后， HandlerMapping的作用便是找到请求相应的处理器Handler和Interceptor.

HandlerAdapter(处理器适配器)
HandlerAdapter是一 个适配器。因为Spring MVC中Handler可以是任意形式的， 只要能处理请求即可。但是把请求交给Servlet的时候， 由于Servlet的方法结构都是do Service(HttpServletRequest req， HttpServletResponse resp) 形式的， 要让固定的Servlet处理方法调用Handler来进行处理， 便是HandlerAdapter的职责。

HandlerExceptionResolver（处理器解析器）
HandlerExceptionResolver用于处理Handler产生的异常情况。它的作用是根据异常设置ModelAndView， 之后交给渲染方法进行渲染， 渲染方法会将ModelAn dView渲染成页面。（用于异常处理）

ViewResolver（视图解析器）
ViewResolver即视图解析器， 用于将String类型的视图名和Locale解析为View类型的视图， 只有一个resolveViewName() 方法。从方法的定义可以看出， Controller层返回的String类型视图名viewName最终会在这里被解析成为View。View是用来渲染页面的， 也就是说， 它会将程序返回的参数和数据填入模板中， 生成html文件。ViewResolver在这个过程主要完成两件事情：
ViewResolver找到渲染所用的模板(第一件大事) 和所用的技术(第二件大事， 其实也就是找到视图的类型， 如JSP) 并填入参数。默认情况下， Spring MVC会自动为我们配置一个InternalResourceViewResolver， 是针对JSP类型视图的。拼接前缀和后缀，找到物理视图

RequestToViewNameTranslator（将请求转换为视图名）
RequestToViewNameTranslator组件的作用是从请求中获取ViewName.因为View Resolver根据ViewName查找View（把请求路径当成逻辑视图名）， 但有的Handler处理完成之后， 没有设置View， 也没有设置ViewName，便要通过这个组件从请求中查找ViewName。

LocaleResolver（国际化）
ViewResolver组件的resolveViewName方法需要两个参数， 一个是视图名， 一个是Locale。LocaleResolver用于从请求中解析出Locale， 比如中国Locale是zh-CN， 用来表示一个区域。这个组件也是i18n的基础。

ThemeResolver（）
ThemeResolver组件是用来解析主题的。主题是样式、图片及它们所形成的显示效果的集合。Spring MVC中一套主题对应一个properties文件， 里面存放着与当前主题相关的所有资源， 如图片、CSS样式等。创建主题非常简单， 只需准备好资源， 然后新建一个“主题名.properties”并将资源设置进去， 放在classpath下， 之后便可以在页面中使用了。Spring MVC中与主题相关的类有ThemeResolver、ThemeSource和Theme。ThemeResolver负责从请求中解析出主题名，ThemeSource根据主题名找到具体的主题， 其抽象也就是Theme， 可以通过Theme来获取主题和具体的资源。

MultipartResolver（多元素解释器）
MultipartResolver用于上传请求， 通过将普通的请求包装成MultipartHttpServletRequest来实现。MultipartHttpServletRequest可以通过getFile() 方法直接获得文件。如果上传多个文件， 还可以调用getFileMap() 方法得到Map这样的结构， MultipartResolver的作用就是封装普通的请求，使其拥有文件上传的功能。

FlashMapManager（）
FlashMap用于重定向时的参数传递， 比如在处理用户订单时候， 为了避免重复提交， 可以处理完post请求之后重定向到一个get请求， 这个get请求可以用来显示订单详情之类的信息。这样做虽然可以规避用户重新提交订单的问题，但是在这个页面上要显示订单的信息，这些数据从哪里来获得呢?因为重定向时么有传递参数这一功能的， 如果不想把参数写进URL(不推荐) ， 那么就可以通过FlashMap来传递。只需要在重定向之前将要传递的数据写入请求(可以通过ServletRequestAttributes.getRequest() 方法获得) 的属性OUTPUT_FLASH_MAP_ATTRIBUTE中， 这样在重定向之后的Handler中Spring就会自动将其设置到Model中， 在显示订单信息的页面上就可以直接从Model中获取数据。FlashMapManager就是用来管理FalshMap的。

SpringMVC的url-parttern的配置原理

<mvc:default-servlet-handler/>
  <mvc:resources  mapping="/resources/**"   location="classpath:/"/>

数据输出机制

web.xml下配置解决EL表达式不能使用问题

@RequestMapping("/handle01")
    public ModelAndView handle01(){
         Date date = new Date();//服务器时间
        // 返回服务器时间到前端页面
        //　封装了数据和页面信息的ModelAndView
        ModelAndView modelAndView = new ModelAndView();
        // addObject 其实是向请求域中request。setAttribute("data",date);
        modelAndView.addObject("date",date);
        //将视图信息封装然后跳转到对应的页面去展示信息
        modelAndView.setViewName("aa");
        // 后台将他放到一个request域中，则前台也可以从request域中取出来。参数要一一对应
        return modelAndView;
    }
    /**
     *SpringMVC在handler方法上传入Map、Model和ModeLMap参数， 并向这些参数中保存数据(放入到请求域) ， 都可以在页面获取到
     它们之间是什么关系?
     运行时的具体类型都是BindingAwareModelMap， 相当于给BindingAwareModelMap中保存的数据都会放在请求域中
     Map(jdk中的接口)    Model(spring的接口)     ModelMap(class， 实现Map接口)
     *BindingAwareModeLMap继承了ExtendedModelMap， ExtendedModelMap继承了ModelMap， 实现了Model接口
     */
     // url: http://localhost:8080/demo/handle11
    @RequestMapping("/handle11")
    public String handle11(ModelMap modelMap){
        Date date = new Date();//服务器时间
        //　封装了数据和页面信息的ModelMap
        modelMap.addAttribute("date",date);
        return "aa";// 返回逻辑视图名
    }
    // url: http://localhost:8080/demo/handle12
    /** 直接声明形参Model集合，封装数据*/
    @RequestMapping("/handle12")
    public String handle12(Model model){
        Date date = new Date();//服务器时间
        //　封装了数据和页面信息的ModelMap
        model.addAttribute("date",date);
        return "aa";// 返回逻辑视图名
    }
    // url: http://localhost:8080/demo/handle13
    /** 直接声明形参Map集合，封装数据*/
    @RequestMapping("/handle13")
    public String handle13(Map<String,Object> map){
        Date date = new Date();//服务器时间
        //　封装了数据和页面信息的ModelMap
        map.put("date",date);
        return "aa";// 返回逻辑视图名
    }

第3节、请求参数绑定(串讲)

请求参数绑定：说白了就是Spring MVC如何接收请求参数
http协议(超文本传输协议)原生servlet接收一个整型参数：
1) String ageStr=request.getParameter(”age”);
2) Integer age=Integer.parseInt(ageStr);

Spring MVC框架对Servlet的封装， 简化了servlet的很多操作
Spring MVC在接收整型参数的时候， 直接在Handler方法中声明形参即可

@RequestMapping("xxx")
public String handle(Integer age) {
    System.out.println(age);
}

参数绑定：取出参数值绑定到handler方法的形参上

默认支持ServletAPI作为方法参数

当需要使用HttpServletRequest、HttpServletResponse、HttpSession等原生servlet对象时， 直接在handler方法中形参声明使用即可。

1先要在pom.xm中进行添加依赖

<!--因为要引入原生的servlet，所以需要添加依赖-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.0.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
    <scope>provided</scope>
</dependency>

<p>测试用例：Spring MVC对原生servlet api的支持</p>
 <a href="/demo/handle02?id=1">点击测试</a>

2直接获取对象 id

/**Spring MVC对原生servlet api的支持  url：/demo/handle02?id=1
     *如果要在Spring MVC中使用servlet原生对象， 比如
     *HttpServletRequest＼HttpServletResponse＼HttpSession， 直接在Handler方法形参中声明使用即可
     */
    @RequestMapping("/handle02")
    public ModelAndView handle02(HttpServletRequest request, HttpServletResponse response, HttpSession session) {
        String id = request.getParameter("id");
        Date date = new Date();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("date",date);
        modelAndView.setViewName("success");
        return modelAndView;
    }

绑定简单类型参数

简单数据类型：八种基本数据类型及其包装类型
参数类型推荐使用包装数据类型， 因为基础数据类型不可以为null
整型：Integer、int
字符串：String
单精度：Float、float
双精度：Double、double
布尔型：Boolean、boolean
说明：对于布尔类型的参数， 请求的参数值为true或false。或者1或0
注意：绑定简单数据类型参数，只需要直接声明形参即可(形参参数名和传递的参数名要保持一致， 建议使用包装类型， 当形参参数名和传递参数名不一致时可以使用@RequestParam注解进行手动映射)

<p>测试用例：SpringMVC接收简单数据类型参数</p>
    <a href="/demo/handle03?ids=1">点击测试</a>

如果是基本数据类型则用其包装类，若其传递的参数名和形参不一致，则需要借助@RequestParam进行映射

/*
*Spring MVC接收简单数据类型参数    url：/demo/handle03?id=1
*注意：接收简单数据类型参数， 直接在handler方法的形参中声明即可， 框架会取出参数值然后绑定到对应参数上
*要求：传递的参数名和声明的形参名称保持一致
       如果不一致，如传过来是ids，接收是id，则可以先取出ids映射给后面的id
*/
 @RequestMapping("/handle03")
 public ModelAndView handle03(@RequestParam("ids") Integer id,Boolean flag) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

绑定Pojo对象及类型参数

public class User {
    private Integer id;
    private String name;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

<p>测试用例：SpringMVC接收pojo类型参数</p>
    <a href="/demo/handle04?id=1&name=zhangsan">点击测试</a>

要求传递的参数名必须和Pojo的属性名保持一致

/**Spring MvC接收pojo类型参数     url：/demo/handle04?id=1&username=zhangsan
     *接收pojo类型参数， 直接形参声明即可， 类型就是Pojo的类型， 形参名无所谓
     *但是要求传递的参数名必须和Pojo的属性名保持一致
     */
    @RequestMapping("/handle04")
    public ModelAndView handle04(User user) {
        Date date = new Date();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("date",date);
        modelAndView.setViewName("success");
        return modelAndView;
    }

Pojo包装对象参数

包装类型 QueryVo

package com.shanglin.edu.pojo;
public class QueryVo {
 private String mail;
 private String phone;
 // 嵌套了另外的Pojo对象
 private User user;
 public String getMail() {
 return mail;
 }
 public void setMail(String mail) {
 this.mail = mail;
 }
 public String getPhone() {
 return phone;
 }
 public void setPhone(String phone) {
 this.phone = phone;
 }
 public User getUser() {
 return user;
 }
 public void setUser(User user) {
 this.user = user;
 }
}

<p>测试用例：SpringMVC接收pojo包装类型参数</p>
    <a href="/demo/handle05?user.id=1&user.name=zhangsan">点击测试</a>

传参参数名和pojo属性保持一致， 如果不能够定位数据项， 那么通过属性名+“.”的方式进一步锁定数据

/*Spring MvC接收pojo包装类型参数   url：/demo/handle05?user.id=1&user.user name=zhang san
     *不管包装Pojo与否， 它首先是一个pojo， 那么就可以按照上述pojo的要求来
     *1、绑定时候直接形参声明即可(QueryVo queryVo) 
     *2、传参参数名和pojo属性保持一致， 如果不能够定位数据项， 那么通过属性名+“."的方式进一步锁定数据
     */
    @RequestMapping("/handle05")
    public ModelAndView handle05(QueryVo queryVo) {
        Date date = new Date();
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("date",date);
        modelAndView.setViewName("success");
        return modelAndView;
    }

绑定日期类型参数（需要配置自定义类型转换器）

1、

<fieldset>
 <p>测试用例：SpringMVC接收日期类型参数</p>
 <a href="/demo/handle06?birthday=2019-10-08">点击测试</a>
</fieldset>

2、将传递过来的字符串日期转换为Date日期格式，是需要自定义类型转换器的

/**
 * 绑定日期类型参数
 * 定义一个SpringMVC的类型转换器，它其实就是一个接口，扩展实现接口的接口，注册你的实现
 * @param birthday
 * @return
 */
 @RequestMapping("/handle06")
 public ModelAndView handle06(Date birthday) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

3、自定义类型转换器（接口的实现）

package com.shanglin.edu.converter;
import org.springframework.core.convert.converter.Converter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 自定义类型转换器
* S：source，源类型
* T：target：目标类型
*/
public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        // 完成字符串向日期的转换
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date parse = simpleDateFormat.parse(source);
            return  parse;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

4、注册自定义类型转换器（将自己实现的扩展告知框架，进行注册。因为是Springmvc的东西，所以在Springmvc.xml注册）

<!--1、自动注册最合适的处理器映射器，处理器适配器（如果不指定，它是去使用默认的，主要是调用handler方法）
        2、下面的自定义类型转换定义好后，要在这里进行关联，因为这里进行1操作。类型转换其实也就发生在绑定这步
        ，也就是调用handler的时候把它的id给关联起来,这样才完成自定义类型转换器的注册-->
    <mvc:annotation-driven   conversion-service="conversionServiceBean"/>

    <!--注册自定义类型转换器，要起一个id-->
    <bean id="conversionServiceBean" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <!--converters是一个集合说明可以是多个-->
        <property name="converters">
            <!--通过set进行注入集合-->
            <set>
                <!--将转换器bean给配置上。class指定刚刚自定义的类型转换器的实现。如果有多个转换器就配置多个bean-->
                <bean class="com.shanglin.edu.converter.DateConverter"></bean>
            </set>
        </property>
    </bean>

第 4 节 对 Restful 风格请求支持

• rest风格请求是什么样的?

• spring mvc对rest风格请求到底提供了怎样的支持

   ** 是一个注解的使用@PathVariable， 可以帮助我们从uri中取出参数**
  

4.1什么是RESTful

Restful是一种web软件架构风格， 它不是标准也不是协议， 它倡导的是一个资源定位及资源操作的风格。

什么是REST：
REST(英文：Representational State Transfer， 简称REST) 描述了一个架构样式的网络系统， 比如web应用程序。它首次出现在2000年Roy Fielding的博士论文中， 他是HTTP规范的主要编写者之一。在目前主流的三种Web服务交互方案中， REST相比于SOAP(Simple Object Access protocol，简单对象访问协议) 以及XML-RPC更加简单明了， 无论是对URL的处理还是对Payload的编码，REST都倾向于用更加简单轻量的方法设计和实现。值得注意的是REST并没有一个明确的标准， 而更像是一种设计的风格。
它本身并没有什么实用性， 其核心价值在于如何设计出符合REST风格的网络接口。
资源 表现层 状态转移

Restful的优点

它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

Restful的特性

资源(Resources) ：网络上的一个实体， 或者说是网络上的一个具体信息。
它可以是一段文本、一张图片、一首歌曲、一种服务， 总之就是一个具体的存在。可以用一个URI(统一资源定位符) 指向它， 每种资源对应一个特定的URI。要获取这个资源， 访问它的URI就可以， 因此URI即为每一个资源的独一无二的识别符。
表现层(Representation) ：把资源具体呈现出来的形式， 叫做它的表现层(Representation) 。比如， 文本可以用txt格式表现， 也可以用HTML格式、XML格式、JSON格式表现， 甚至可以采用二进制格式。
状态转化(State Transfer) ：每发出一个请求， 就代表了客户端和服务器的一次交互过程。
HTTP协议， 是一个无状态协议， 即所有的状态都保存在服务器端。因此， 如果客户端想要操作服务器， 必须通过某种手段， 让服务器端发生”状态转化”(State Transfer) 。而这种转化是建立在表现层
之上的， 所以就是“表现层状态转化”。具体说， 就是HTTP协议里面， 四个表示操作方式的动词：
GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET用来获取资源， POST用来新建资
源， PUT用来更新资源， DELETE用来删除资源。

RESTful的示例：

rest是一个url请求的风格， 基于这种风格设计请求的url
没有rest的话， 原有的url设计 http：//localhost8080/user/queryUserByld.action?id=3(传统的方式，3在？后面)
url中定义了动作(操作) ， 参数具体锁定到操作的是谁

有了rest风格之后

rest中， 认为互联网中的所有东西都是资源， 既然是资源就会有一个唯一的uri标识它， 代表它
http：//localhost8080/user/3 代表的是id为3的那个用户记录(资源) 进行锁定资源
锁定资源之后如何操作它呢? 常规操作就是增删改查
先锁定资源，然后根据请求方式不同，代表要做不同的操作（这个和传统的是相反的）
get查询， 获取资源
post增加， 新建资源
put更新
delete删除资源
rest风格带来的直观体现：就是传递参数方式的变化， 参数可以在url中了（不用再跟一个？）
/account/1 HTTP GET：得到id=1的account
/account/1 HTTP DELETE：删除id=1的account
/account/1 HTTP PUT：更新id=1的account
（上面三个虽然访问地址都一样，但是根据动作的不用而进行不同的操作）

URL：资源定位符， 通过URL地址去定位互联网中的资源(抽象的概念， 比如图片、视频、app服务等)。
RESTful风格URL：互联网所有的事物都是资源，通过url来定义资源，然后通过请求方式不同来定义它的操作。参数是放到url当中的。要求URL中只有表示资源的名称， 没有动词。
RESTful风格资源操作：使用HTTP请求中的method方法put、delete、post、get来操作资源。分别对应添加、删除、修改、查询。不过一般使用时还是post和get。put和delete几乎不使用。
RESTful风格资源表述：可以根据需求对URL定位的资源返回不同的表述(也就是返回数据类型， 比如XML、JSON等数据格式)
Spring MVC支持RESTful风格请求， 具体讲的就是使用@PathVariable注解获取RESTful风格的请求
URL中的路径变量。

示例代码

页面的请求路径中都是差不多了，有的是一样的，那么就需要在后台的handler方法的RequestMethod进行限定
url虽然是一样，但是通过RequestMethod限定了访问的类型了。

1、 请求的参数是包含在url中的（含get请求）

<p>测试用例：SpringMVC对Restful风格url的支持</p>
  <a href="/demo/handle/15">rest_get测试</a>

/* 只能运行get方法通过
 * PathVariable的作用就是从请求路径中取出一个变量id，绑定给后面的id
 * restful get /demo/handle/15
 */
 @RequestMapping(value = "/handle/{id}",method = {RequestMethod.GET})
 public ModelAndView handleGet(@PathVariable("id") Integer id) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

如果出现乱码，则在tomcat文件夹下的conf/servler.xml中设置

<Connector port="8080"  
protocol="HTTP/1.1" 　connectionTimeout="20000" 　
redirectPort="8443" 　
URIEncoding="UTF-8"/>

2、参数不在url中，就和之前的一样即可

<p>测试用例：SpringMVC对Restful风格url的支持</p>
 <form method="post" action="/demo/handle">
    <input type="text" name="username"/>
    <input type="submit" value="提交rest_post请求"/>
</form>

限定只能是post请求才可以进来

/* 只能运行post方法通过
 * restful post /demo/handle
 */
 @RequestMapping(value = "/handle",method = {RequestMethod.POST})
 public ModelAndView handlePost(String username) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

解决乱码问题，在web.xml中添加如下配置

<!--配置Springmvc提供的针对post请求的字符编码过滤器，
     解决request.getParameter()语句取值出现的中文乱码 -->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <!--配置一个过滤器，这个过滤器按utf-8进行编码-->
      <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>

3、put请求、delete请求需要在隐藏域当中进行添加_method

<div>
    <h2>SpringMVC对Restful风格url的支持</h2>
    <fieldset>
      <!--因为在method中，只能写post,get。将参数都放到url当中-->
      <form method="post" action="/demo/handle/15/lisi">
        <input type="hidden" name="_method" value="put"/>
        <input type="submit" value="提交rest_put请求"/>
      </form>
        <form method="post" action="/demo/handle/15">
            <input type="hidden" name="_method" value="delete"/>
            <input type="submit" value="提交rest_delete请求"/>
        </form>
    </fieldset>
</div>

后台Handler方法

/*允许put方法通过
 * restful put /demo/handle/15/lisi
 */
 @RequestMapping(value = "/handle/{id}/{name}",method = {RequestMethod.PUT})
 public ModelAndView handlePut(@PathVariable("id") Integer id,@PathVariable("name") String username) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

 /* 允许delete方法通过
 * restful delete /demo/handle/15
 */
 @RequestMapping(value = "/handle/{id}",method = {RequestMethod.DELETE})
 public ModelAndView handleDelete(@PathVariable("id") Integer id) {
     Date date = new Date();
     ModelAndView modelAndView = new ModelAndView();
     modelAndView.addObject("date",date);
     modelAndView.setViewName("success");
     return modelAndView;
 }

web.xml中配置请求方式过滤器（将特定的post请求转换为put和delete请求）

<!--配置springmvc请求方式转换过滤器，会检查请求参数中是否有_method参数，如果有就
按照指定的请求方式进行转换-->
  <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>

上面是将1、注解、2过滤器、3restful风格的结合。

第5节Ajax Json交互

交互：两个方向
1) 前端到后台：前端ajax发送json格式字符串， 后台直接接收为pojo参数， 使用注解@RequstBody
2) 后台到前端：后台直接返回pojo对象， 前端直接接收为json对象或者字符串， 使用注解@ResponseBody

5.1什么是Json

Json是一种与语言无关的数据交互格式， 就是一种字符串， 只是用特殊符号内表示对象、[内表示数
组、””内是属性或值、：表示后者是前者的值
{”name”：”Michael”} 可以理解为是一个包含name为Michael的对象
[{”name”：”Michael”} ， {”name”：”Jerry”} ] 就表示包含两个对象的数组

5.2@ResponseBody注解

@response Body注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后， 写入到response对象的body区， 通常用来返回JSON数据或者是XML数据。注意：在使用此注解之后不会再走视图处理器， 而是直接将数据写入到输入流中， 他的效果等同于通过response对象输出指定
格式的数据。

5.3分析Spring MVC使用json交互

1、在pom.xml文件中添加所需的依赖

<!--json数据交互所需jar，start-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

2、前端jsp页面（定义了一个按钮）

<script type="text/javascript" src="/js/jquery.min.js"></script>
<div>
   <h2>Ajax json交互</h2>
   <fieldset>
     <input type="button" id="ajaxBtn" value="ajax提交"/>
   </fieldset>
</div>

3、用jQuery框架给按钮绑定单机事件

然后发送ajax请求给到后台。
要指定类型，application/json;charset=utf-8

$(function () {
    $("#ajaxBtn").bind("click",function () {
        // 发送ajax请求
        $.ajax({
            url: '/demo/handle07',
            type: 'POST',
            data: '{"id":"1","name":"李四"}',
            contentType: 'application/json;charset=utf-8',
            dataType: 'json',
            success: function (data) {
                alert(data.name);
            }
        })
    })
})

4、springmvc.xml需要添加对静态文件的过滤

这个静态资源才不会被拦截。

<mvc:resources  location="/WEB-INF/js/" mapping="/js/**"/>

5、后台Handler方法

@RequestMapping("/handle07")
// 添加@ResponseBody之后，不再⾛视图解析器那个流程，而是等同于response直接输出数据
public @ResponseBody User handle07(@RequestBody User user) {
     // 业务逻辑处理，修改name为张三丰
     user.setName("张三丰");
     return user; 
}

必须是post请求，因为post请求才有请求体，数据才能放到RequestBody里面。
返回的数据通过 @ResponseBody去响应

第二部分 Spring MVC 高级技术

第 1 节 拦截器(Inteceptor)使用

1.1监听器、过滤器和拦截器对比

• ·Servlet：处理Request请求和Response响应
• ·过滤器(Filter) ：对Request请求起到过滤的作用， 作用在Servlet之前， 如果配置为/*可以对所有的资源访问(servlet、js/css静态资源等) 进行过滤处理

• ·监听器(Listener) ：实现了javax.servlet.ServletContext Listener接口的服务器端组件， 它随Web应用的启动而启动， 只初始化一次， 然后会一直运行监视， 随Web应用的停止而销毁

     作用一：做一些初始化工作， web应用中spring容器启动ContextLoaderListener<br />         作用二：监听web中的特定事件， 比如HttpSession， ServletRequest的创建和销毁； 变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控，比如统计在线人数，利用HttpSessionLisener等。
  

• ·拦截器(Interceptor) ：是Spring MVC、Struts等表现层框架自己的， 不会拦截jsp/html/css/imagez这些静态资源的访问等， 只会拦截访问的控制器方法(Handler) 。

从配置的角度也能够总结发现：serlvet、filter、listener是配置在web.xml中的， 而interceptor是配置在表现层框架自己的配置文件中的
。在Handler业务逻辑执行之前拦截一次
。在Handler逻辑执行完毕但未跳转页面之前拦截一次
。在跳转页面之后拦截一次

1.2拦截器的执行流程

在运行程序时，拦截器的执行是有一定顺序的，该顺序与配置文件中所定义的拦截器的顺序相关。单个拦截器，在程序中的执行流程如下图所示：

1) 程序先执行preHandle() 方法， 如果该方法的返回值为true， 则程序会继续向下执行处理器中的方法，否则将不再向下执行。
2) 在业务处理器(即控制器Controller类) 处理完请求后， 会执行postHandle(方法， 然后会通过DispatcherServlet向客户端返回响应。
3) 在DispatcherServlet处理完请求后， 才会执行afterCompletion) 方法。

1.3多个拦截器的执行流程

多个拦截器(假设有两个拦截器Interceptor 1和Interceptor 2， 并且在配置文件中， Interceptor 1拦截器配置在前)，在程序中的执行流程如下图所示：

  ![](https://cdn.nlark.com/yuque/0/2020/png/2397310/1603685371034-7ecf3ccd-edbd-4aff-b9f6-c8e14dcdfc8d.png#height=386&id=yATkg&originHeight=523&originWidth=644&originalType=binary&ratio=1&size=0&status=done&style=none&width=475)![image.gif](https://cdn.nlark.com/yuque/0/2020/gif/2397310/1603685380401-9cfa1aa0-f321-4085-9c0f-7b4dcbe745a7.gif#height=1&id=o4CxN&name=image.gif&originHeight=1&originWidth=1&originalType=binary&ratio=1&size=43&status=done&style=none&width=1)

从图可以看出， 当有多个拦截器同时工作时， 它们的pre Handle) 方法会按照配置文件中拦截器的配置
顺序执行， 而它们的post Handle(方法和after Completion() 方法则会按照配置顺序的反序执行。

插播一个（个人不喜欢Ctrl+insert快捷键，修改为ctrl+alt+Q）

示例代码

1、自定义Spring MVC拦截器

package com.shanglin.edu.intercepter;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
 * @Description: 自定义springmvc拦截器
 * @Author: shanglin
 * @Date: 2020-08-09 8:21
 */
public class MyIntercepter01 implements HandlerInterceptor {
    /**会在handler方法业务逻辑执行之前执行
     * 往往是在这里进行权限的校验
     * @param request
     * @param response
     * @param handler
     * @return 返回值boolean代表是否放行，true代表放行，false代表中止
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepter01 preHandle......");
        return true;
    }
    /** 会在handler方法业务逻辑执行之后尚未跳转页面时执行
     * @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.printf("MyIntercepter01 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.printf("MyIntercepter01 afterCompletion......");
    }
}

2、注册SpringMVC拦截器
（serlvet、filter、listener是配置在web.xml中的， 而interceptor是配置在表现层框架springmvc.xml自己的配置文件中的）

<!--表示可以拦截多个(对拦截器进行注册)-->
    <mvc:interceptors>
        <!--拦截所有的handler-->
        <!--<bean class="com.shanglin.edu.intercepter.MyIntercepter01"/>-->
        <mvc:interceptor>
            <!--配置当前拦截器的url拦截规则，**代表当前目录下及其子目录下的所有url-->
            <mvc:mapping path="/**"/> <!--先拦截所有-->
         <!--   <mvc:exclude-mapping path="/demo/**"/>--><!--排除不需要拦截的-->
            <bean class="com.shanglin.edu.intercepter.MyIntercepter01"/><!--规则配置好后，还需定义上拦截器-->
        </mvc:interceptor>
        <!--如果有多个拦截器，则继续配置新加的拦截器进行注册-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.shanglin.edu.interceptor.MyIntercepter02"/>
        </mvc:interceptor>
    </mvc:interceptors>

第 2 节 处理multipart形式的数据

文件上传 ：原生servlet处理上传的文件数据的，springmvc又是对serlvet的封装

1、首先引入所需jar包

<!--文件上传所需jar坐标-->
<dependency>
 <groupId>commons-fileupload</groupId>
 <artifactId>commons-fileupload</artifactId>
 <version>1.3.1</version>
</dependency>

2、springmvc.xml中配置文件上传解析器(否则上传是空的)

Springmvc是根据这个id去找这个bean的。

<!--配置文件上传解析器，id是固定的multipartResolver（必须是这样写的）-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
 <!--设置上传文件大小，单位字节-->
 <property name="maxUploadSize" value="1000000000"/>
</bean>

3、前端Form

%--
 1 method="post"
 2 enctype="multipart/form-data"
 3 type="file"
--%> 
<div>
    <h2>文件上传解析器</h2>
    <fieldset>
        <form method="post" enctype="multipart/form-data" action="/demo/upload">
            <input type="file" name="uploadFile"/>
            <input type="submit" value="上传"/>
        </form>
    </fieldset>
</div>

4、后台接收Handler

/**文件上传
     * @param uploadFile
     * @param request
     * @return
     * @throws IOException
     */
    @RequestMapping("upload")
    public String upload(MultipartFile uploadFile, HttpServletRequest request) throws IOException {
        // 文件原名，如xxx.jpg
        String originalFilename = uploadFile.getOriginalFilename();
        // 获取文件的扩展名,如jpg
        String extendName = originalFilename.substring(originalFilename.lastIndexOf(".") +1,originalFilename.length());
        String uuid = UUID.randomUUID().toString();
        // 新的文件名字
        String newName = uuid + "." + extendName;
        // 存储到指定的文件夹uploads下面（传入是相对路径名，返回的是真实的路径）
        String realPath =
                request.getSession().getServletContext().getRealPath("/uploads");
        // 解决文件夹存放文件数量限制，按日期存放
        String datePath = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        File floder = new File(realPath + "/" + datePath);
        if(!floder.exists()) {
            floder.mkdirs();
        }
        // 存储文件到目录
        uploadFile.transferTo(new File(floder,newName));
        return "success";
    }

5、上传成功之后，会在webapp下面生成文件夹及文件的

、

第 3 节 在控制器中处理异常

可以对全局的异常进行处理

package com.shanglin.edu.controller;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletResponse;
/**
 * @Description:
 * @Author: shanglin
 * @Date: 2020-08-09 10:45
 */
@ControllerAdvice //添加这个注解可以让我们优雅的捕获所有Controller对象handler方法抛出的异常
public class GlobalExceptionResolver {
    @ExceptionHandler(ArithmeticException.class) //对handler出现异常进行处理。括号内的是处理具体的异常
    public ModelAndView handleException(ArithmeticException exception, HttpServletResponse response){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("msg",exception.getMessage());
        modelAndView.setViewName("error"); // 跳到error.jsp页面中
        return modelAndView;
    }
    ...还可以配置其他的具体异常
}

第 4 节 基于Flash属性的跨重定向请求数据传递

重定向时请求参数会丢失，我们往往需要重新携带请求参数，我们可以进行手动参数拼接如下： 属于get方法

return  "redirect：handle01?name="+name；

但是上述拼接参数的方法属于get请求， 1、携带参数长度有限制， 2、参数安全性也不高， 此时， 我们可以使用Spring MVC提供的flash属性机制， 向上下文中添加flash属性， 框架会在session中记录该属性值， 当跳转到页面之后框架会自动删除flash属性， 不需要我们手动删除， 通过这种方式进行重定向参数传递，参数长度和安全性都得到了保障，如下：

1、需要重定向（要声明RedirectAttributes，它专门用于重定向属性设置的）

/**
*Spring MVC重定向时参数传递的问题
*转发：A找B借钱400，B没有钱但是悄悄的找到c借了400块钱给A，url不会变，参数也不会丢失，一个请求
*重定向：A找B借钱400，B说我没有钱，你找别人借去，那么A又带着400块的借钱需求找到C
*url会变， 参数会丢失需要重新携带参数， 两个请求
*/
@RequestMapping("/handleRedirect")
 public String handleRedirect(String name,RedirectAttributes redirectAttributes) {
     //return "redirect:handle01?name=" + name; // 拼接参数安全性、参数长度都有局限
     // addFlashAttribute方法设置了一个flash类型属性，该属性会被暂存到session中，
     //在跳转到页面之后该属性销毁。 如果是addAttribute等同于拼接的形式
     redirectAttributes.addFlashAttribute("name",name);
     return "redirect:handle08";
 }

2、跳转到handle08这个方法中，*通过@ModelAttribute取出属性

/**通过@ModelAttribute取出属性，给到后面的参数
     * @param name
     * @return
     */
    @RequestMapping("/handle08")
    public ModelAndView handle08(@ModelAttribute("name") String name){
    ...
    }