天津大学生专业做网站/seo评测论坛

目录

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")@ResponseBodypublic 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")@ResponseBodypublic 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")@ResponseBodypublic 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")@ResponseBodypublic String pojoParam(User user){    System.out.println("pojo参数传递 user ==> "+user);    return "{'module':'pojo param'}";}

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

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

@RequestMapping("/pojoContainPojoParam")@ResponseBodypublic String pojoContainPojoParam(User user){    System.out.println("pojo嵌套pojo参数传递 user ==> "+user);    return "{'module':'pojo contain pojo param'}";}

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

@RequestMapping("/arrayParam")@ResponseBodypublic String arrayParam(String[] likes){    System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));    return "{'module':'array param'}";}

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

@RequestMapping("/listParam")@ResponseBodypublic 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")@ResponseBodypublic 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")@ResponseBodypublic String pojoParamForJson(@RequestBody User user){     System.out.println("pojo(json)参数传递 user ==> "+user);    return "{'module':'pojo for json param'}";}

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

@RequestMapping("/listPojoParamForJson")@ResponseBodypublic 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")@ResponseBodypublic 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")@ResponseBodypublic String toText(){    return "response text";}

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

@RequestMapping("/toJsonPOJO")@ResponseBodypublic User toJsonPOJO(){    User user = new User();    user.setName("赵云");    user.setAge(41);    return user;}

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

@RequestMapping("/toJsonList")@ResponseBodypublic 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)@ResponseBodypublic String save(@RequestBody User user){    System.out.println("user save..." + user);    return "{'module':'user save'}";}@RequestMapping(value = "/users" ,method = RequestMethod.PUT)@ResponseBodypublic String update(@RequestBody User user){    System.out.println("user update..."+user);    return "{'module':'user update'}";}

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

@RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE) @ResponseBodypublic 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 {@Autowiredprivate ProjectInterceptor projectInterceptor;@Overrideprotected void addResourceHandlers(ResourceHandlerRegistry registry) {registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");}@Overrideprotected 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 {@Autowiredprivate ProjectInterceptor projectInterceptor;@Overrideprotected void addResourceHandlers(ResourceHandlerRegistry registry) {registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");}@Overrideprotected 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 {@Autowiredprivate ProjectInterceptor projectInterceptor;@Overridepublic 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 {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle...222");return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle...222");}@Overridepublic 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 {@Autowiredprivate ProjectInterceptor projectInterceptor;@Autowiredprivate ProjectInterceptor2 projectInterceptor2;@Overridepublic void addInterceptors(InterceptorRegistry registry) {//配置多拦截器registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");registry.addInterceptor(projectInterceptor2).addPathPatterns("/books","/books/*");}
}

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

 

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

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

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

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

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