SpringMVC基础知识2

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;
​
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
​
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager ds = new DataSourceTransactionManager();
        ds.setDataSource(dataSource);
        return ds;
    }
}

Mybatis：

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setTypeAliasesPackage("com.itheima.domain");
        return factoryBean;
    }
​
    @Bean
    public 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请求中文乱码过滤器
    @Override
    protected 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 {
        @Autowired
        private 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 {
    @Autowired
    private BookService bookService;
​
    @PostMapping
    public boolean save(@RequestBody Book book) {
        return bookService.save(book);
    }
​
    @PutMapping
    public 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);
    }
    @GetMapping
    public 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 {
        @Autowired
        private BookService bookService;
​
        @PostMapping
        public Result save(@RequestBody Book book) {
        }
​
        boolean flag = bookService.save(book); return new
​
        Result(flag ?Code.SAVE_OK:Code.SAVE_ERR, flag);
    }
​
    @PutMapping
    public 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);
    }
​
    @GetMapping
    public 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);
}

统一异常处理

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

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

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

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

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

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

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

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

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

异常分类

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

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

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

简化pringMvcSupport的编写

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

拦截器参数

前置处理法

原始方法之前运行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 {
    @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");
    }
}

配置拦截器类

@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", "/book s/*");
    }
}

拦截器执行的顺序是和配置顺序有关。就和前面所提到的运维人员进入机房的案例，先进后出。

• 当配置多个拦截器时，形成拦截器链

• 拦截器链的运行顺序参照拦截器添加顺序为准

• 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行

• 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

---

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

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

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

这个顺序不太好记，最终只需要把握住一个原则即可:以最终的运行结果为准