title: SpringMvcDay2
tags:- 工程课基础- SpringMVC- SSM- 开发框架
description: SpringMvcDay2完结篇幅，细学了SpringMVC
cover: https://w.wallhaven.cc/full/57/wallhaven-57o9j5.png
abbrlink: 19231
date: 2022-07-18 22:34:16

SpringMVC_day2

SSM整合

前面我们已经把Mybatis、Spring和SpringMVC三个框架进行了学习，接下来就介绍如何整合这三部分：

创建一个Maven的web工程

pom.xml添加SSM需要的依赖jar包
编写Web项目的入口配置类，实现AbstractAnnotationConfigDispatcherServletInitializer，重写以下方法

getRootConfigClasses() ：返回Spring的配置类->需要SpringConfig配置类

getServletConfigClasses() ：返回SpringMVC的配置类->需要SpringMvcConfig配置类

getServletMappings() : 设置SpringMVC请求拦截路径规则

getServletFilters() ：设置过滤器，解决POST请求中文乱码问题
SpringConfig
标识该类为配置类 @Configuration

扫描Service所在的包 @ComponentScan

在Service层要管理事务 @EnableTransactionManagement

读取外部的properties配置文件 @PropertySource
整合Mybatis需要引入Mybatis相关配置类 @Import
- 第三方数据源配置类 JdbcConfig
构建DataSource数据源，DruidDataSouroce,需要注入数据库连接四要素， @Bean，@Value

构建平台事务管理器，DataSourceTransactionManager,@Bean

Mybatis配置类 MybatisConfig

构建SqlSessionFactoryBean并设置别名扫描与数据源，@Bean

构建MapperScannerConfigurer并设置DAO层的包扫描
SpringMvcConfig

标识该类为配置类 @Configuration

扫描Controller所在的包 @ComponentScan

开启SpringMVC注解支持 @EnableWebMvc
功能模块

创建数据库表

根据数据库表创建对应的模型类

通过Dao层完成数据库表的增删改查(接口+自动代理)

编写Service层[Service接口+实现类]

@Service

@Transactional

整合Junit对业务层进行单元测试

@RunWith

@ContextConfiguration

@Test

编写Controller层

接收请求 @RequestMapping @GetMapping @PostMapping @PutMapping @DeleteMapping

接收数据简单、POJO、嵌套POJO、集合、数组、JSON数据类型

@RequestParam

@PathVariable

@RequestBody

转发业务层

@Autowired

响应结果

@ResponseBody

整合配置

SpringMVC：

@Configuration
@ComponentScan({"com.itheima.service"})
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MyBatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

Jdbc：

public class JdbcConfig {@Value("${jdbc.driver}")private String driver;@Value("${jdbc.url}")private String url;@Value("${jdbc.username}")private String username;@Value("${jdbc.password}")private String password;
@Beanpublic DataSource dataSource() {DruidDataSource dataSource = new DruidDataSource();dataSource.setDriverClassName(driver);dataSource.setUrl(url);dataSource.setUsername(username);dataSource.setPassword(password);return dataSource;}
@Beanpublic PlatformTransactionManager transactionManager(DataSource dataSource) {DataSourceTransactionManager ds = new DataSourceTransactionManager();ds.setDataSource(dataSource);return ds;}
}

Mybatis：

public class MyBatisConfig {@Beanpublic SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();factoryBean.setDataSource(dataSource);factoryBean.setTypeAliasesPackage("com.itheima.domain");return factoryBean;}
@Beanpublic MapperScannerConfigurer mapperScannerConfigurer() {MapperScannerConfigurer msc = new MapperScannerConfigurer();msc.setBasePackage("com.itheima.dao");return msc;}
}

jdbc.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db
jdbc.username=root
jdbc.password=root

SpringMVC：

@Configuration
@ComponentScan("com.itheima.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

ServletWebConfig：

public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer {//加载Spring配置类protected Class<?>[] getRootConfigClasses() {return new Class[]{SpringConfig.class};}
//加载SpringMVC配置类 protected Class<?>[] getServletConfigClasses() {return new Class[]{SpringMvcConfig.class};}
//设置SpringMVC请求地址拦截规则protected String[] getServletMappings() {return new String[]{"/"};}
//设置post请求中文乱码过滤器@Overrideprotected Filter[] getServletFilters() {CharacterEncodingFilter filter = new CharacterEncodingFilter();filter.setEncoding("utf-8");return new Filter[]{filter};}
}

功能模块开发

pojo:

package com.itheima.pojo;

public class Book {private Integer id;private String type;private String name;private String description;
// getter setter ..
}

ServceAndServiceImpl:

@Transactional
public interface BookService {/*** 保存 * @param book * @return */public boolean save(Book book);
/*** 修改 * @param book * @return */public boolean update(Book book);
/*** 按id删除 * @param id * @return */public boolean delete(Integer id);
/*** 按id查询 * @param id * @return */public Book getById(Integer id);
/*** 查询全部 * @return*/public List<Book> getAll();
}
// -----------------------
@Service
public class BookServiceImpl implements BookService {@Autowiredprivate BookDao bookDao;public boolean save(Book book) {
//        bookDao.save(book);
//                Result result = new Result(1,20021,"ss");return true;}
public boolean update(Book book) {bookDao.update(book);return true;}
public boolean delete(Integer id) {bookDao.delete(id);return true;}
public Book getById(Integer id) {return bookDao.getById(id);}
public List<Book> getAll() {return bookDao.getAll();}
}

Controller:RestFul

@Controller
@RequestMapping("/books")
public class BookController {@Autowiredprivate BookService bookService;
@PostMappingpublic boolean save(@RequestBody Book book) {return bookService.save(book);}
@PutMappingpublic boolean update(@RequestBody Book book) {return bookService.update(book);}
@DeleteMapping("/{id}")public boolean delete(@PathVariable Integer id) {return bookService.delete(id);}
@GetMapping("/{id}")public Book getById(@PathVariable Integer id) {return bookService.getById(id);}@GetMappingpublic List<Book> getAll(){return bookService.getAll();}
}

Dao:

@Component
public interface BookDao {
@Insert("insert into tbl_book (type,name,description) values(#{type},# {name},#{description})")public void save(Book book);
@Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")public void update(Book book);
@Delete("delete from tbl_book where id = #{id}")public void delete(Integer id);
@Select("select * from tbl_book where id = #{id}")public Book getById(Integer id);
@Select("select * from tbl_book")public List<Book> getAll();
}

bookDao在Service中注入的会提示一个红线提示，为什么呢?

BookDao是一个接口，没有实现类，接口是不能创建对象的，所以最终注入的应该是代理对象

代理对象是由Spring的IOC容器来创建管理的

IOC容器又是在Web服务器启动的时候才会创建

IDEA在检测依赖关系的时候，没有找到适合的类注入，所以会提示错误提示

但是程序运行的时候，代理对象就会被创建，框架会使用DI进行注入，所以程序运行无影响

统一结果封装

表现层与前端数据传输协议

在Controller层增删改返回给前端的是boolean类型数据

在Controller层查询单个返回给前端的是对象

在Controller层查询所有返回给前端的是集合对象

目前我们就已经有三种数据类型返回给前端，如果随着业务的增长，我们需要返回的数据类型会越来

越多，因此我们需要提供一种统一的数据类型，来供前端使用

为了封装返回的结果数据:创建结果模型类，封装数据到data属性中

为了封装返回的数据是何种操作及是否操作成功:封装操作结果到code属性中

操作失败后为了封装返回的错误信息:封装特殊消息到message(msg)属性中

根据分析，我们可以设置统一数据返回结果类：

public class Result {private Object data;private Integer code;private String msg;
}
// Result类名及类中的字段并不是固定的，可以根据需要自行增减提供若干个构造方法，方便操作

表现层与前端数据传输协议实现

对于结果封装，我们应该是在表现层进行处理，所以我们把结果类放在controller包下，当然你也可以放在domain包，这个都是可以的

Result：

public class Result {//描述统一格式中的数据private Object data;//描述统一格式中的编码，用于区分操作，可以简化配置0或1表示成功失败private Integer code;//描述统一格式中的消息，可选属性private String msg;//构造方法是方便对象的创建public Result(Integer code, Object data) {this.data = data;this.code = code;}//构造方法是方便对象的创建public Result(Integer code, Object data, String msg) {this.data = data;this.code = code;this.msg = msg;}
}

定义返回码Code类：

 //状态码
public class Code {public static final Integer SAVE_OK = 20011;public static final Integer DELETE_OK = 20021;public static final Integer UPDATE_OK = 20031;public static final Integer GET_OK = 20041;public static final Integer SAVE_ERR = 20010;public static final Integer DELETE_ERR = 20020;public static final Integer UPDATE_ERR = 20030;public static final Integer GET_ERR = 20040;
}

修改Controller类的返回值:

//统一每一个控制器方法返回值
@RestController
@RequestMapping("/books")
public class BookController {@Autowiredprivate BookService bookService;
@PostMappingpublic Result save(@RequestBody Book book) {}
boolean flag = bookService.save(book); return new
Result(flag ?Code.SAVE_OK:Code.SAVE_ERR, flag);}
@PutMappingpublic Result update(@RequestBody Book book) {boolean flag = bookService.update(book);return new Result(flag ? Code.UPDATE_OK : Code.UPDATE_ERR, flag);}
@DeleteMapping("/{id}")public Result delete(@PathVariable Integer id) {boolean flag = bookService.delete(id);return new Result(flag ? Code.DELETE_OK : Code.DELETE_ERR, flag);}
@GetMapping("/{id}")public Result getById(@PathVariable Integer id) {Book book = bookService.getById(id);Integer code = book != null ? Code.GET_OK : Code.GET_ERR;String msg = book != null ? "" : "数据查询失败，请重试！";return new Result(code, book, msg);}
@GetMappingpublic Result getAll() {List<Book> bookList = bookService.getAll();Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;String msg = bookList != null ? "" : "数据查询失败，请重试！";return new Result(code, bookList, msg);
}

统一异常处理

我们先来看下异常的种类及出现异常的原因:

框架内部抛出的异常：因使用不合规导致

数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）

业务层抛出的异常：因业务逻辑书写错误导致（例如：遍历业务书写操作，导致索引异常等）

表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）

工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放等）

各个层级均出现异常，异常处理代码书写在哪一层?

所有的异常均抛出到表现层进行处理

异常的种类很多，表现层如何将所有的异常都处理到呢?

异常分类

表现层处理异常，每个方法中单独书写，代码书写量巨大且意义不强，如何解决?

AOP

对于上面这些问题及解决方案，SpringMVC已经为我们提供了一套解决方案:

异常处理器:

集中的、统一的处理项目中出现的异常

异常处理器：

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {//除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常@ExceptionHandler(Exception.class)public void doException(Exception ex){System.out.println("111");}
}

@RestControllerAdvice：

名称	@RestControllerAdvice
类型	类注解
位置	Rest风格开发的控制器增强类定义上方
作用	为Rest风格开发的控制器类做增强

说明 : 此注解自带@ResponseBody注解与@Component注解，具备对应的功能

@ExceptionHandler：

名称	@ExceptionHandler
类型	方法注解
位置	专用于异常处理的控制器方法上方
作用	设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行,并转入当前方法执行

说明：此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

项目异常处理方案

异常分类

业务异常（BusinessException）

规范的用户行为产生的异常 > - 用户在页面输入内容的时候未按照指定格式进行数据填写，如在年龄框输入的是字符串

不规范的用户行为操作产生的异常

如用户故意传递错误数据

系统异常（SystemException）

项目运行过程中可预计但无法避免的异常 > - 比如数据库或服务器宕机

其他异常（Exception）

编程人员未预期到的异常，如:用到的文件不存在

将异常分类以后，针对不同类型的异常，要提供具体的解决方案:

异常解决方案

业务异常（BusinessException）
- 发送对应消息传递给用户，提醒规范操作
  - 大家常见的就是提示用户名已存在或密码格式不正确等
系统异常（SystemException）
- 发送固定消息传递给用户，安抚用户
  - 系统繁忙，请稍后再试
  - 系统正在维护升级，请稍后再试
  - 系统出问题，请联系系统管理员等
- 发送特定消息给运维人员，提醒维护
  - 可以发送短信、邮箱或者是公司内部通信软件
- 记录日志
  - 发消息和记录日志对用户来说是不可见的，属于后台程序
其他异常（Exception）
- 发送固定消息传递给用户，安抚用户
- 发送特定消息给编程人员，提醒维护（纳入预期范围内）
  - 一般是程序没有考虑全，比如未做非空校验等
- 记录日志

异常解决方案的具体实现

思路:

1.先通过自定义异常，完成BusinessException和SystemException的定义

2.将其他异常包装成自定义异常类型

3.在异常处理器类中对不同的异常进行处理

自定义异常类：

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class SystemException extends RuntimeException {private Integer code;
public Integer getCode() {return code;}
public void setCode(Integer code) {this.code = code;}
public SystemException(Integer code, String message) {super(message);this.code = code;}
public SystemException(Integer code, String message, Throwable cause) {super(message, cause);this.code = code;}
}

//自定义异常处理器，用于封装异常信息，对异常进行分类
public class BusinessException extends RuntimeException {private Integer code;
public Integer getCode() {return code;}
public void setCode(Integer code) {this.code = code;}
public BusinessException(Integer code, String message) {super(message);this.code = code;}
public BusinessException(Integer code, String message, Throwable cause) {super(message, cause);this.code = code;}
}

说明:

让自定义异常类继承RuntimeException的好处是，后期在抛出这两个异常的时候，就不用在try...catch...或throws了
自定义异常类中添加code属性的原因是为了更好的区分异常是来自哪个业务的

将其他异常包成自定义异常

具体的包装方式有：
- 方式一: try{}catch(){}在catch中重新throw我们自定义异常即可。
- 方式二:直接throw自定义异常即可

上面为了使code看着更专业些，我们在Code类中再新增需要的属性

//状态码
public class Code {public static final Integer SAVE_OK = 20011;public static final Integer DELETE_OK = 20021;public static final Integer UPDATE_OK = 20031;public static final Integer GET_OK = 20041;public static final Integer SAVE_ERR = 20010;public static final Integer DELETE_ERR = 20020;public static final Integer UPDATE_ERR = 20030;public static final Integer GET_ERR = 20040;public static final Integer SYSTEM_ERR = 50001;public static final Integer SYSTEM_TIMEOUT_ERR = 50002;public static final Integer SYSTEM_UNKNOW_ERR = 59999;public static final Integer BUSINESS_ERR = 60002;
}

处理器类中处理自定义异常：

//@RestControllerAdvice用于标识当前类为REST风格对应的异常处理器
@RestControllerAdvice
public class ProjectExceptionAdvice {//除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常@ExceptionHandler(SystemException.class)public Result doSystemException(SystemException ex) {//记录日志// 发送消息给运维// 发送邮件给开发人员,ex对象发送给开发人员return new Result(ex.getCode(), null, ex.getMessage());}@ExceptionHandler(BusinessException.class)public Result doBusinessException(BusinessException ex) {return new Result(ex.getCode(), null, ex.getMessage());}//除了自定义的异常处理器，保留对Exception类型的异常处理，用于处理非预期的异常@ExceptionHandler(Exception.class) public Result doOtherException(Exception ex){//记录日志// 发送消息给运维// 发送邮件给开发人员,ex对象发送给开发人员return new Result(Code.SYSTEM_UNKNOW_ERR,null,"系统繁忙，请稍后再试！");}
}

前后台协议联调

列表功能

需求:页面加载完后发送异步请求到后台获取列表数据进行展示。

1.找到页面的钩子函数，created()

2.created()方法中调用了this.getAll()方法

3.在getAll()方法中使用axios发送异步请求从后台获取数据

4.访问的路径为http://localhost/books

5.返回数据

getAll() {
//发送ajax请求
axios.get("/books").then((res)=>{ this.dataList = res.data.data;});
}

添加功能

需求:完成图片的新增功能模块

1.找到页面上的新建按钮，按钮上绑定了@click="handleCreate()"方法

2.在method中找到handleCreate方法，方法中打开新增面板

3.新增面板中找到确定按钮,按钮上绑定了@click="handleAdd()"方法

4.在method中找到handleAdd方法

5.在方法中发送请求和数据，响应成功后将新增面板关闭并重新查询数据

handleCreate() { this.dialogFormVisible = true;
}
handleAdd () { //发送ajax请求//this.formData是表单中的数据，最后是一个json数据 axios.post("/books",this.formData).then((res)=>{this.dialogFormVisible = false;this.getAll();});
}

添加功能状态处理

需求:新增成功是关闭面板，重新查询数据，那么新增失败以后该如何处理?

1.在handlerAdd方法中根据后台返回的数据来进行不同的处理

2.如果后台返回的是成功，则提示成功信息，并关闭面板

3.如果后台返回的是失败，则提示错误信息

修改前端界面

handleAdd(){//发送ajax请求 axios.post("/books",this.formData).then((res)=>{//如果操作成功，关闭弹层，显示数据 if(res.data.code==20011){this.dialogFormVisible=false;this.$message.success("添加成功");}else if(res.data.code==20010){this.$message.error("添加失败");}else{this.$message.error(res.data.msg);}}).finally(()=>{this.getAll();});}
}

后台返回操作结果，将Dao层的增删改方法返回值从void改成int

@Component
public interface BookDao {@Insert("insert into tbl_book (type,name,description) values(#{type},# {name},#{description})")public int save(Book book);@Update("update tbl_book set type = #{type}, name = #{name}, description = #{description} where id = #{id}")public int update(Book book);@Delete("delete from tbl_book where id = #{id}")public int delete(Integer id);@Select("select * from tbl_book where id = #{id}")public Book getById(Integer id);@Select("select * from tbl_book")public List<Book> getAll();
}

在BookServiceImpl中，增删改方法根据DAO的返回值来决定返回true/false

@Service
public class BookServiceImpl implements BookService {@Autowiredprivate BookDao bookDao;
public boolean save(Book book) {return bookDao.save(book) > 0;}public boolean update(Book book) {return bookDao.update(book) > 0;}public boolean delete(Integer id) {return bookDao.delete(id) > 0;}
public Book getById(Integer id) {if (id == 1) {throw new BusinessException(Code.BUSINESS_ERR, "请不要使用你的技术挑战 我的耐性!");}return bookDao.getById(id);}public List<Book> getAll() {return bookDao.getAll();}
}

新增成功后，再次点击新增按钮会发现之前的数据还存在，这个时候就需要在新增的时候将表单内容清空

resetForm(){this.formData = {}; }handleCreate() { this.dialogFormVisible = true;this.resetForm();
}

修改功能

需求:完成图书信息的修改功能

1.找到页面中的编辑按钮，该按钮绑定了@click="handleUpdate(scope.row)"

2.在method的handleUpdate方法中发送异步请求根据ID查询图书信息

3.根据后台返回的结果，判断是否查询成功

如果查询成功打开修改面板回显数据，如果失败提示错误信息

4.修改完成后找到修改面板的确定按钮，该按钮绑定了@click="handleEdit()"

5.在method的handleEdit方法中发送异步请求提交修改数据

6.根据后台返回的结果，判断是否修改成功

如果成功提示错误信息，关闭修改面板，重新查询数据，如果失败提示错误信息

scope.row代表的是当前行的行数据，也就是说,scope.row就是选中行对应的json数据

修改handleUpdate方法

axios.get("/books/"+row.id).then((res)=>{

修改handleEdit方法

axios.put("/books",this.formData).then((res)=>{

删除功能

需求:完成页面的删除功能。

1.找到页面的删除按钮，按钮上绑定了@click="handleDelete(scope.row)"

2.method的handleDelete方法弹出提示框

3.用户点击取消,提示操作已经被取消。

4.用户点击确定，发送异步请求并携带需要删除数据的主键ID

5.根据后台返回结果做不同的操作

如果返回成功，提示成功信息，并重新查询数据

如果返回失败，提示错误信息，并重新查询数据

handleDelete(row){//1.弹出提示框 this.$confirm("此操作永久删除当前数据，是否继续？","提示",{type:'info'}).then(()=>{//2.做删除业务 axios.delete("/books/"+row.id).then((res)=>{if(res.data.code==20021){this.$message.success("删除成功");}else{this.$message.error("删除失败");}}).finally(()=>{this.getAll();});}).catch(()=>{//3.取消删除 this.$message.info("取消删除操作");});
}

拦截器

拦截器概念
入门案例
拦截器参数
拦截器工作流程分析

拦截器概念

(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的访问进行增强

拦截器开发

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

public class ProjectInterceptor implements HandlerInterceptor {//原始方法调用前执行的内容public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle...");return true;}
//原始方法调用后执行的内容public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle...");}
//原始方法调用完成后执行的内容public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("afterCompletion...");}
}

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

配置拦截器类

@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");}
}

SpringMVC添加SpringMvcSupport包扫描

@Configuration
@ComponentScan({"com.itheima.controller", "com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

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

@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，则代表拦截，后面的就不会再执行了。

简化pringMvcSupport的编写

@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，则直接跳过后面方法的执行

拦截器参数

前置处理法

原始方法之前运行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拦截

拦截器链配置

目前，我们在项目中只添加了一个拦截器，如果有多个，该如何配置?配置多个后，执行顺序是什么?

配置多个拦截器

创建拦截器类，实现接口，并重写接口中的方法

@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");}
}