SpringMvc介绍。

目录

1、SpringMvc概述

1、基本介绍

2、工作流程 

3、bean加载控制

 二、请求

1、请求映射路径

2、请求方式

3、请求参数

4、请求参数（传递json数据）

5、日期类型参数传递

三、响应

四、REST风格

1、REST简介

2、RESTful入门案例

3、RESTful快速开发

五、拦截器

1、拦截器概念

2、拦截器开发

3、拦截器参数

4、拦截器链配置

1、SpringMvc概述

1、基本介绍

▶ 基本概念

  SpringMVC是一种基于Java实现MVC模型的轻量级Web框架

▷ 优点

  ● 使用简单、开发便捷(相比于Servlet)
  ● 灵活性强

▷ 当前WEB程序的工作流程:

● 三层架构

 ○ web程序通过浏览器访问前端页面，发送异步请求到后端服务器

 ○ 后台服务器采用三层架构进行功能开发
 ○表现层负责接收请求和数据然后将数据转交给业务层
 ○ 业务层负责调用数据层完成数据库表的增删改查，并将结果返给表现层
 ○ 表现层将数据转换成json格式返回给前端

 ○前端页面将数据进行解析最终展示给用户。

▷ 表现层与数据层的技术选型:

● 数据层采用Mybatis框架
● 变现层采用SpringMVC框架，SpringMVC主要负责的内容有:
  ○controller如何接收请求和数据
  ○ 如何将请求和数据转发给业务层
  ○ 如何将响应数据转换成json发回到前端

▶ 程序流程

1.浏览器发送请求到Tomcat服务器

2.Tomcat服务器接收到请求后，会将请求交给SpringMVC中的DispatcherServlet[前端控制器]来处理请求

3.DispatcherServlet不真正处理请求，只是按照对应的规则将请求分发到对应的Bean对象

4.Bean对象是有我们自己编写来处理不同的请求，每个Bean中可以处理一个或多个不同的请求url

5.DispatcherServlet和Bean对象都需要交给Spring容器来进行管理

▶ 知识点

@Controller

@RequestMapping

@ResponseBody

▶ 入门案例

● AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类

● AbstractDispatcherServletInitializer提供三个接口方法供用户实现

  ○ createServletApplicationContext()方法，创建Servlet容器时，加载SpringMVC对应bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围

   

    

     

      

     
     

      

       protected WebApplicationContext 
       createServletApplicationContext
       () {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       AnnotationConfigWebApplicationContext 
       ctx 
       = 
       new 
       AnnotationConfigWebApplicationContext();  
      
     
    

     

      

     
     

      

           ctx.register(SpringMvcConfig.class);     
      
     
    

     

      

     
     

      
    
       return ctx; 
      
     
    

     

      

     
     

      

       }
      
     
   

  ○ createRootApplicationContext()方法，如果创建Servlet容器时需要加载非SpringMVC对的bean，使用当前方法进行，使用方式同createServletApplicationContext()

   

    

     

      

     
     

      

       protected WebApplicationContext 
       createRootApplicationContext
       () {     
      
     
    

     

      

     
     

      
    
       return 
       null; 
      
     
    

     

      

     
     

      

       }
      
     
   

○ getServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所请求，任意请求都将转入到SpringMVC进行处理

   

    

     

      

     
     

      

       protected String[] getServletMappings() {
      
     
    

     

      

     
     

      
    
       return 
       new 
       String[]{
       "/"};
      
     
    

     

      

     
     

      

       }
      
     
   

2、工作流程 

▶ 启动服务器初始化过程

1. 服务器启动，执行ServletContainersInitConfig类，初始化web容器

2. 执行createServletApplicationContext方法，创建了WebApplicationContext对象

   ● 该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器

3. 加载SpringMvcConfig配置类

4. 执行@ComponentScan加载对应的bean

   ● 扫描指定包下所有类上的注解，如Controller类上的@Controller注解

5. 加载UserController，每个@RequestMapping的名称对应一个具体的方法

   ● 此时就建立了 `/save` 和 save方法的对应关系

6. 执行getServletMappings方法，定义所有的请求都通过SpringMVC

   ● `/`代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求

▶ 单次请求过程

1. 发送请求localhost/save
2. web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理
   ● 因为符合上面第六步设置的请求路径，所以该请求会交给SpringMVC来处理
3. 解析请求路径/save
4. 由/save匹配执行对应的方法save(）
   ● 上面的第五步已经将请求路径和方法建立了对应关系，通过/save就能找到对应的save方法
5. 执行save()
6. 检测到有@ResponseBody直接将save()方法的返回值作为响应求体返回给请求方

3、bean加载控制

▶ Controller加载控制与业务bean加载控制

● SpringMVC相关bean（表现层bean）

● Spring控制的bean

  ○ 业务bean（Service）

  ○ 功能bean（DataSource等）

●SpringMVC相关bean加载控制

  ○ SpringMVC加载的bean对应的包均在com.itheima.controller包内

● Spring相关bean加载控制

  ○ 方式一：Spring加载的bean设定扫描范围为com.itheima，排除掉controller包内的bean

  ○ 方式二：Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等

  ○ 方式三：不区分Spring与SpringMVC的环境，加载到同一个环境中

▶ 知识点

▶ bean的加载格式

   

    

     

      

     
     

      

       public 
       class 
       ServletContainersInitConfig 
       extends 
       AbstractDispatcherServletInitializer {     
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       protected WebApplicationContext 
       createServletApplicationContext
       () {         
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
       
       AnnotationConfigWebApplicationContext 
       ctx 
       = 
       new 
       AnnotationConfigWebApplicationContext();        
      
     
    

     

      

     
     

      

               ctx.register(SpringMvcConfig.class);        
      
     
    

     

      

     
     

      
        
       return ctx;    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           }    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       protected WebApplicationContext 
       createRootApplicationContext
       () {         
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
       
       AnnotationConfigWebApplicationContext 
       ctx 
       = 
       new 
       AnnotationConfigWebApplicationContext();        
      
     
    

     

      

     
     

      

               ctx.register(SpringConfig.class);        
      
     
    

     

      

     
     

      
        
       return ctx;    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           }    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       protected String[] getServletMappings() {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
        
       return 
       new 
       String[]{
       "/"};    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▶ 简化开发

   

    

     

      

     
     

      

       public 
       class 
       ServletContainersInitConfig 
       extends 
       AbstractAnnotationConfigDispatcherServletInitializer{    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               
       protected Class<?>[] getServletConfigClasses() {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

                      
       return 
       new 
       Class[]{SpringMvcConfig.class};    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               }    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               
       protected String[] getServletMappings() {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

                       
       return 
       new 
       String[]{
       "/"};    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               }    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               
       protected Class<?>[] getRootConfigClasses() {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

                       
       return 
       new 
       Class[]{SpringConfig.class};    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

 二、请求

1、请求映射路径

2、请求方式

▶ Get请求

  ● 普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/commonParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       commonParam
       (String name ,int age){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 name ==> "+name);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 age ==> "+age);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'common param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ post请求

 ● 普通参数：form表单post请求传参，表单参数名与形参变量名相同，定义形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/commonParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       commonParam
       (String name ,int age){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 name ==> "+name);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 age ==> "+age);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'common param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ Post请求中文乱码处理

 ● 为web容器添加过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器

   

    

     

      

     
     

      

       public 
       class 
       ServletContainersInitConfig 
       extends 
       AbstractAnnotationConfigDispatcherServletInitializer{    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       // 配字符编码过滤器    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       protected Filter[] getServletFilters() {        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
        
       CharacterEncodingFilter 
       filter 
       = 
       new 
       CharacterEncodingFilter();        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               filter.setEncoding(
       "utf-8");        
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
        
       return 
       new 
       Filter[]{filter};    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

3、请求参数

▶ 普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/commonParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody 
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       commonParam
       (String name ,int age){     
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 name ==> "+name);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 age ==> "+age);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'common param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 普通参数：请求参数名与形参变量名不同，使用@RequestParam绑定参数关系

   

    

     

      

     
     

      

       @RequestMapping("/commonParamDifferentName")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       commonParamDifferentName
       (@RequestParam("name")String userName , int age){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 userName ==> "+userName);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "普通参数传递 age ==> "+age);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'common param different name'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ @RequestParam

▶ POJO参数：请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/pojoParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       pojoParam
       (User user){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "pojo参数传递 user ==> "+user);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'pojo param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 嵌套POJO参数：POJO对象中包含POJO对象

▶ 嵌套POJO参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数

   

    

     

      

     
     

      

       @RequestMapping("/pojoContainPojoParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       pojoContainPojoParam
       (User user){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "pojo嵌套pojo参数传递 user ==> "+user);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'pojo contain pojo param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 数组参数：请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/arrayParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       arrayParam
       (String[] likes){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "数组参数传递 likes ==> "+ Arrays.toString(likes));    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'array param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系

   

    

     

      

     
     

      

       @RequestMapping("/listParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       listParam
       (@RequestParam List<String> likes){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "集合参数传递 likes ==> "+ likes);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'list param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

4、请求参数（传递json数据）

▶ 接收请求中的json数据

▷ ①：添加json数据转换相关坐标

   

    

     

      

     
     

      

       <dependency>  
      
     
    

     

      

     
     

      
    
       <groupId>com.fasterxml.jackson.core
       </groupId>  
      
     
    

     

      

     
     

      
    
       <artifactId>jackson-databind
       </artifactId>  
      
     
    

     

      

     
     

      
    
       <version>2.9.0
       </version>
      
     
    

     

      

     
     

      

       </dependency>
      
     
   

▷ ②：设置发送json数据（请求body中添加json数据）

▷ ③：开启自动转换json数据的支持 

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       @ComponentScan("com.itheima.controller")
      
     
    

     

      

     
     

      

       @EnableWebMvc
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcConfig {
      
     
    

     

      

     
     

      

       }
      
     
   

   注意事项：@EnableWebMvc注解功能强大，该注解整合了多个功能，此处仅使用其中一部分功能，即json数据进行自动类型转换。

▷ ④：设置接收json数据

   

    

     

      

     
     

      

       @RequestMapping("/listParamForJson")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       listParamForJson
       (@RequestBody List<String> likes){                 
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "list common(json)参数传递 list ==> "+likes);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'list common for json param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ @EnableWebMvc

▶ @RequestBody

▶ POJO参数：json数据与形参对象属性名相同，定义POJO类型形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/pojoParamForJson")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       pojoParamForJson
       (@RequestBody User user){     
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "pojo(json)参数传递 user ==> "+user);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'pojo for json param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ POJO集合参数：json数组数据与集合泛型属性名相同，定义List类型形参即可接收参数

   

    

     

      

     
     

      

       @RequestMapping("/listPojoParamForJson")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       listPojoParamForJson
       (@RequestBody List<User> list){     
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "list pojo(json)参数传递 list ==> "+list);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'list pojo for json param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ @RequestBody与@RequestParam区别

● 区别

 ○ @RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】

 ○ @RequestBody用于接收json数据【application/json】

● 应用

 ○ 后期开发中，发送json格式数据为主，@RequestBody应用较广

 ○ 如果发送非json格式数据，选用@RequestParam接收请求参数

5、日期类型参数传递

▶ 参数传递

 ● 日期类型数据基于系统不同格式也不尽相同

  ○ 2088-08-18

  ○ 2088/08/18

  ○ 08/18/2088

 ● 接收形参时，根据不同的日期格式设置不同的接收方式

   

    

     

      

     
     

      

       @RequestMapping("/dataParam")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       dataParam
       (Date date,
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

                       
       @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,                                         
       @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss")Date date2){   
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               System.out.println(
       "参数传递 date ==> "+date);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               System.out.println(
       "参数传递 date(yyyy-MM-dd) ==> "+date1);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               System.out.println(
       "参数传递 date(yyyy/MM/dd HH:mm:ss) ==> "+date2);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

               
       return 
       "{'module':'data param'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

http://localhost/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08

▶ @DateTimeFormat

▶ 类型转换器

● Converter接口

   

    

     

      

     
     

      

       public 
       interface 
       Converter<S, T> {    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       @Nullable    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           T 
       convert
       (S var1);
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

  ○ 请求参数年龄数据（String→Integer）

  ○ json数据转对象（json → POJO）

  ○ 日期格式转换（String → Date）

● @EnableWebMvc功能之一：根据类型匹配对应的类型转换器

三、响应

▶ 响应页面（了解）

   

    

     

      

     
     

      

       @RequestMapping("/toPage")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       toPage
       (){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "page.jsp";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 响应文本数据（了解）

   

    

     

      

     
     

      

       @RequestMapping("/toText")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       toText
       (){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "response text";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 响应json数据（对象转json）

   

    

     

      

     
     

      

       @RequestMapping("/toJsonPOJO")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public User 
       toJsonPOJO
       (){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       User 
       user 
       = 
       new 
       User();    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user.setName(
       "赵云");    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user.setAge(
       41);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return user;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▶ 响应json数据（对象集合转json数组）

   

    

     

      

     
     

      

       @RequestMapping("/toJsonList")
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public List<User> 
       toJsonList
       (){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       User 
       user1 
       = 
       new 
       User();    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user1.setName(
       "赵云");    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user1.setAge(
       41);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       User 
       user2 
       = 
       new 
       User();    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user2.setName(
       "master 赵云");    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           user2.setAge(
       40);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           List<User> userList = 
       new 
       ArrayList<User>();    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           userList.add(user1);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           userList.add(user2);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return userList;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▶ @ResponseBody

▶ HttpMessageConverter接口

   

    

     

      

     
     

      

       public 
       interface 
       HttpMessageConverter<T> {    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       boolean 
       canRead
       (Class<?> clazz, @Nullable MediaType mediaType);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       boolean 
       canWrite
       (Class<?> clazz, @Nullable MediaType mediaType);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           List<MediaType> 
       getSupportedMediaTypes
       ();    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           T 
       read
       (Class<? extends T> clazz, HttpInputMessage inputMessage)          
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
        
       throws IOException, HttpMessageNotReadableException;    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       void 
       write
       (T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)          
      
     
    

     

      

     
     

      
        
       throws IOException, HttpMessageNotWritableException; 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

四、REST风格

 1、REST简介

▶ 基本介绍

  REST（Representational State Transfer），表现形式状态转换

● 传统风格资源描述形式       

  ○ http://localhost/user/getById?id=1     

  ○ http://localhost/user/saveUser

● REST风格描述形式     

  ○ http://localhost/user/1     

  ○ http://localhost/user

● 优点：

  ○ 隐藏资源的访问行为，无法通过地址得知对资源是何种操作

  ○ 书写简化

▶ 风格简介

   上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users、books、accounts…… 

2、RESTful入门案例

▶ ①：设定http请求动作（动词）

   

    

     

      

     
     

      

       @RequestMapping(value = "/users", method = RequestMethod.POST)
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       save
       (@RequestBody User user){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "user save..." + user);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'user save'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @RequestMapping(value = "/users" ,method = RequestMethod.PUT)
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       public String 
       update
       (@RequestBody User user){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "user update..."+user);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'user update'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▶ ②：设定请求参数（路径变量）

   

    

     

      

     
     

      

       @RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE) 
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       @ResponseBody
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       public String 
       delete
       (@PathVariable Integer id){    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           System.out.println(
       "user delete..." + id);    
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      
    
       return 
       "{'module':'user delete'}";
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

       }
      
     
   

▶ @RequestMapping

▶ @PathVariable

▶ @RequestBody，@RequestParam，@PathVariable 三者区别

● 区别

  ○ @RequestParam用于接收url地址传参或表单传参

  ○ @RequestBody用于接收json数据

  ○ @PathVariable用于接收路径参数，使用{参数名称}描述路径参数

● 应用

  ○ 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广

  ○ 如果发送非json格式数据，选用@RequestParam接收请求参数

  ○ 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求径变量，通常用于传递id值

3、RESTful快速开发

▶ 快速开发

▶ @RestController

▶ @GetMapping  @PostMapping  @PutMapping  @DeleteMapping

▶ 基于RESTful页面数据交互

①：制作SpringMVC控制器，并通过PostMan测试接口功能

②：设置对静态资源的访问放行

③：前端页面通过异步提交访问后台控制器

五、拦截器

 1、拦截器概念

▶ 基本介绍

(1)浏览器发送一个请求会先到Tomcat的web服务器

(2)Tomcat服务器接收到请求以后，会去判断请求的是静态资源还是动态资源

(3)如果是静态资源，会直接到Tomcat的项目部署目录下去直接访问

(4)如果是动态资源，就需要交给项目的后台代码进行处理

(5)在找到具体的方法之前，我们可以去配置过滤器(可以配置多个)，按照顺序进行执行

(6)然后进入到到中央处理器(SpringMVC中的内容)，SpringMVC会根据配置的规则进行拦截

(7)如果满足规则，则进行处理，找到其对应的controller类中的方法进行执行,完成后返回结果

(8)如果不满足规则，则不进行处理

(9)这个时候，如果我们需要在每个Controller方法执行的前后添加业务，具体该如何来实现?

这个就是拦截器要做的事。

▷ 拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
● 作用:
  ○ 在指定的方法调用前后执行预先设定的代码
  ○ 阻止原始方法的执行
  ○ 总结：拦截器就是用来做增强

▶ 拦截器和过滤器之间的区别是什么?

 ● 归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
 ● 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

 2、拦截器开发

▶ 步骤1 : 创建拦截器类

  让类实现HandlerInterceptor接口，重写接口中的三个方法。

   

    

     

      

     
     

      

       @Component
      
     
    

     

      

     
     

      

       //定义拦截器类，实现HandlerInterceptor接口
      
     
    

     

      

     
     

      

       //注意当前类必须受Spring容器控制
      
     
    

     

      

     
     

      

       public 
       class 
       ProjectInterceptor 
       implements 
       HandlerInterceptor {
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       //原始方法调用前执行的内容
      
     
    

     

      

     
     

      

           
       public 
       boolean 
       preHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "preHandle...");
      
     
    

     

      

     
     

      

               
       return 
       true;
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       //原始方法调用后执行的内容
      
     
    

     

      

     
     

      

           
       public 
       void 
       postHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "postHandle...");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       //原始方法调用完成后执行的内容
      
     
    

     

      

     
     

      

           
       public 
       void 
       afterCompletion
       (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "afterCompletion...");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

注意: 拦截器类要被SpringMVC容器扫描到。

▶步骤2 : 配置拦截器类

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcSupport 
       extends 
       WebMvcConfigurationSupport {
      
     
    

     

      

     
     

      

           
       @Autowired
      
     
    

     

      

     
     

      

           
       private ProjectInterceptor projectInterceptor;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       protected 
       void 
       addResourceHandlers
       (ResourceHandlerRegistry registry) {
      
     
    

     

      

     
     

      

               registry.addResourceHandler(
       "/pages/**").addResourceLocations(
       "/pages/");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       protected 
       void 
       addInterceptors
       (InterceptorRegistry registry) {
      
     
    

     

      

     
     

      

               
       //配置拦截器
      
     
    

     

      

     
     

      

               registry.addInterceptor(projectInterceptor).addPathPatterns(
       "/books" );
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▶步骤3 : SpringMVC添加SpringMvcSupport包扫描

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       @ComponentScan({"com.itheima.controller","com.itheima.config"})
      
     
    

     

      

     
     

      

       @EnableWebMvc
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcConfig{
      
     
    

     

      

     
     

      

          
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 步骤4 : 运行程序测试

使用PostMan发送`http://localhost/books`

如果发送`http://localhost/books/100`会发现拦截器没有被执行，原因是拦截器的`addPathPatterns`方法配置的拦截路径是`/books`,我们现在发送的是`/books/100`，所以没有匹配上，因此没有拦截，拦截器就不会执行。

▶ 步骤5 : 修改拦截器拦截规则

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcSupport 
       extends 
       WebMvcConfigurationSupport {
      
     
    

     

      

     
     

      

           
       @Autowired
      
     
    

     

      

     
     

      

           
       private ProjectInterceptor projectInterceptor;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       protected 
       void 
       addResourceHandlers
       (ResourceHandlerRegistry registry) {
      
     
    

     

      

     
     

      

               registry.addResourceHandler(
       "/pages/**").addResourceLocations(
       "/pages/");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       protected 
       void 
       addInterceptors
       (InterceptorRegistry registry) {
      
     
    

     

      

     
     

      

               
       //配置拦截器
      
     
    

     

      

     
     

      

               registry.addInterceptor(projectInterceptor).addPathPatterns(
       "/books",
       "/books/*" );
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

这个时候，如果再次访问`http://localhost/books/100`，拦截器就会被执行。拦截器中的`preHandler`方法，如果返回true,则代表放行，会执行原始Controller类中要请求的方法，如果返回false，则代表拦截，后面的就不会再执行了。

▶ 步骤6 : 简化SpringMvcSupport的编写

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       @ComponentScan({"com.itheima.controller"})
      
     
    

     

      

     
     

      

       @EnableWebMvc
      
     
    

     

      

     
     

      

       //实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcConfig 
       implements 
       WebMvcConfigurer {
      
     
    

     

      

     
     

      

           
       @Autowired
      
     
    

     

      

     
     

      

           
       private ProjectInterceptor projectInterceptor;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       public 
       void 
       addInterceptors
       (InterceptorRegistry registry) {
      
     
    

     

      

     
     

      

               
       //配置多拦截器
      
     
    

     

      

     
     

      

               registry.addInterceptor(projectInterceptor).addPathPatterns(
       "/books",
       "/books/*");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 拦截器的执行流程

当有拦截器后，请求会先进入preHandle方法，

​    如果方法返回true，则放行继续执行后面的handle[controller的方法]和后面的方法

​    如果返回false，则直接跳过后面方法的执行。

3、拦截器参数

▶ 前置处理方法

原始方法之前运行preHandle

   

    

     

      

     
     

      

       public 
       boolean 
       preHandle
       (HttpServletRequest request,
      
     
    

     

      

     
     

      

                                HttpServletResponse response,
      
     
    

     

      

     
     

      

                                Object handler) 
       throws Exception {
      
     
    

     

      

     
     

      

           System.out.println(
       "preHandle");
      
     
    

     

      

     
     

      

           
       return 
       true;
      
     
    

     

      

     
     

      

       }
      
     
   

 ● request:请求对象
 ● response:响应对象
 ● handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装

使用request对象可以获取请求数据中的内容，如获取请求头的`Content-Type`

   

    

     

      

     
     

      

       public 
       boolean 
       preHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler) 
       throws Exception {
      
     
    

     

      

     
     

      

           
       String 
       contentType 
       = request.getHeader(
       "Content-Type");
      
     
    

     

      

     
     

      

           System.out.println(
       "preHandle..."+contentType);
      
     
    

     

      

     
     

      

           
       return 
       true;
      
     
    

     

      

     
     

      

       }
      
     
   

使用handler参数，可以获取方法的相关信息

   

    

     

      

     
     

      

       public 
       boolean 
       preHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler) 
       throws Exception {
      
     
    

     

      

     
     

      

           
       HandlerMethod 
       hm 
       = (HandlerMethod)handler;
      
     
    

     

      

     
     

      

           
       String 
       methodName 
       = hm.getMethod().getName();
       //可以获取方法的名称
      
     
    

     

      

     
     

      

           System.out.println(
       "preHandle..."+methodName);
      
     
    

     

      

     
     

      

           
       return 
       true;
      
     
    

     

      

     
     

      

       }
      
     
   

▶ 后置处理方法

原始方法运行后运行，如果原始方法被拦截，则不执行  

   

    

     

      

     
     

      

       public 
       void 
       postHandle
       (HttpServletRequest request,
      
     
    

     

      

     
     

      

                              HttpServletResponse response,
      
     
    

     

      

     
     

      

                              Object handler,
      
     
    

     

      

     
     

      

                              ModelAndView modelAndView) 
       throws Exception {
      
     
    

     

      

     
     

      

           System.out.println(
       "postHandle");
      
     
    

     

      

     
     

      

       }
      
     
   

前三个参数和上面的是一致的。

modelAndView : 如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整。因为现在都是返回json数据，所以该参数的使用率不高。

▶ 完成处理方法

拦截器最后执行的方法，无论原始方法是否执行

   

    

     

      

     
     

      

       public 
       void 
       afterCompletion
       (HttpServletRequest request,
      
     
    

     

      

     
     

      

                                   HttpServletResponse response,
      
     
    

     

      

     
     

      

                                   Object handler,
      
     
    

     

      

     
     

      

                                   Exception ex) 
       throws Exception {
      
     
    

     

      

     
     

      

           System.out.println(
       "afterCompletion");
      
     
    

     

      

     
     

      

       }
      
     
   

前三个参数与上面的是一致的。

ex : 如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理，因为我们现在已经有全局异常处理器类，所以该参数的使用率也不高。

这三个方法中，最常用的是preHandle,在这个方法中可以通过返回值来决定是否要进行放行，我们可以把业务逻辑放在该方法中，如果满足业务则返回true放行，不满足则返回false拦截。

4、拦截器链配置

▶ 配置多个拦截器

▷ 步骤1 : 创建拦截器类

实现接口，并重写接口中的方法

   

    

     

      

     
     

      

       @Component
      
     
    

     

      

     
     

      

       public 
       class 
       ProjectInterceptor2 
       implements 
       HandlerInterceptor {
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       public 
       boolean 
       preHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "preHandle...222");
      
     
    

     

      

     
     

      

               
       return 
       false;
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       public 
       void 
       postHandle
       (HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "postHandle...222");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       public 
       void 
       afterCompletion
       (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) 
       throws Exception {
      
     
    

     

      

     
     

      

               System.out.println(
       "afterCompletion...222");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▷ 步骤2 : 配置拦截器类

   

    

     

      

     
     

      

       @Configuration
      
     
    

     

      

     
     

      

       @ComponentScan({"com.itheima.controller"})
      
     
    

     

      

     
     

      

       @EnableWebMvc
      
     
    

     

      

     
     

      

       //实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
      
     
    

     

      

     
     

      

       public 
       class 
       SpringMvcConfig 
       implements 
       WebMvcConfigurer {
      
     
    

     

      

     
     

      

           
       @Autowired
      
     
    

     

      

     
     

      

           
       private ProjectInterceptor projectInterceptor;
      
     
    

     

      

     
     

      

           
       @Autowired
      
     
    

     

      

     
     

      

           
       private ProjectInterceptor2 projectInterceptor2;
      
     
    

     

      

     
     

      
 
      
     
    

     

      

     
     

      

           
       @Override
      
     
    

     

      

     
     

      

           
       public 
       void 
       addInterceptors
       (InterceptorRegistry registry) {
      
     
    

     

      

     
     

      

               
       //配置多拦截器
      
     
    

     

      

     
     

      

               registry.addInterceptor(projectInterceptor).addPathPatterns(
       "/books",
       "/books/*");
      
     
    

     

      

     
     

      

               registry.addInterceptor(projectInterceptor2).addPathPatterns(
       "/books",
       "/books/*");
      
     
    

     

      

     
     

      

           }
      
     
    

     

      

     
     

      

       }
      
     
   
  

   
  

▷ 步骤3 : 运行程序，观察顺序

 

拦截器执行的顺序是和配置顺序有关。先进后出。

● 当配置多个拦截器时，形成拦截器链
● 拦截器链的运行顺序参照拦截器添加顺序为准
● 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
● 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

 ● preHandle ：与配置顺序相同，必定运行

 ● postHandle : 与配置顺序相反，可能不运行

 ● afterCompletion : 与配置顺序相反，可能不运行。