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 : 与配置顺序相反，可能不运行。