README.md · geniusdz/SpringMVC

## 一、SpringMVc概述

* Spring MVC是由Spring官方提供的基于MVC设计理念的web框架。
* SpringMVc是基于Servlet封装的用于实现MVC控制的框架，实现前端和服务端的交互。
### 1.1 SpringMVC优势
* ·严格遵守了MVC分层思想
* ·采用了松耦合、插件式结构;相比较于我们封装的BaseServlet以及其他的一些MVC框架来说更灵活、更具扩展性
* . SpringMVC是基于Spring的扩展、提供了一套完善的MVC注解
* SpringMVc在数据绑定、视图解析都提供了多种处理方式，可灵活配置. SpringMVC对RESTful URL设计方法提供了良好的支持
### 1.2 SpringMVC本质工作
* ·接收并解析请求
* ·处理请求
* ·数据渲染、响应请求

## 二、SpringMVC部署

### 2.1基于Maven创建一个web工程
### 2.2添加spring依赖
* spring-context,spring-aspects,spring-jdbc,spring-web,spring-webmvc,spring-junit

### 2.3创建springmvc配置文件（spring-servlet.xml）

### 2.4 在web.xml中配置SpringMVC的前端控制器
* SpringMVC提供了一个名为DispatcherServlet的类（SpringMVC中央处理器，也就是前端控制器），用于拦截用户请求交由SpringMVC处理

## 三、SpringMVC框架使用 
* 在SpringMVC中，我们把接受用户请求、处理用户请求的类称为Controller 
### 3.1创建控制器 
#### 3.1.1创建控制器类 创建一个controllers包（包需要在Spring注解扫描的范围内）
* 创建一个类（无需做任何继承和实现） 
* 在类上添加@Controller注解 
* 声明此类为SpringMVC的控制器 
* 在类上添加@RequestMapping（“url”）声明此控制器类的请求url 
#### 3.1.2在控制器类中定义处理请求的方法
在一个控制器类中可以定义多个方法处理不同请求 
* 在每个方法上添加@RequestMapping（“url”）用于声明当前方法请求的url 
#### 3.1.3访问

* http://localhost:8080/spring-mvc/book/add
### 3.2静态资源
#### 3.2.1 /*和/的区别
* 前端控制器（web.xml）中
* /*表示拦截所有的http请求，包括.jsp的请求，都作为控制器类的请求路径来处理
* /表示拦截所有的http请求，不包括.jsp的请求，但不放行静态资源（html，css，js，图片）
#### 3.2.2 配置放行静态资源(spring-servlet.xml)
*     <mvc:resources mapping="/css/**" location="/css/"/>
*     <mvc:resources mapping="/pages/**" location="/pages/"/>

### 3.3前端提交数据到控制器
#### 3.3.1创建前端页面
* book-add.jsp表单的action属性设置控制器类的url和对应方法的url的组合路径
#### 3.3.2 前端页面提交数据
* -表单提交：输入框提供name属性，SpringMVC控制器是通过name属性取值的
* -URL提交：<a href="book/add?bookName=Java"/>
* -AJAX提交：请求行，请求头，请求体都可以用来传值

### 3.4控制器接受前端传的数据

* 接受不考虑方式，只看http协议中内容

#### 3.4.1请求行传值

* 表单提交
* URL提交
* $.ajax()请求的url传值
* $.post()/$.get()中的{}传值

**`@RequestParam`**注解用于接收请求行传递的数据

* 前端提交数据

```html

<form action="book/add" method="post">
    <p>图书名称：<input type="text" name="bookName"/></p>
    <p>图书价格：<input type="text" name="bookPrice"/></p>
    <p>图书作者：<input type="text" name="bookAuthor"/></p>
    <p><input type="submit" value="提交"/></p>
</form>
```

* 控制器接收数据

```java
//接收请求行数据
@RequestMapping("/add")
public void addBook(@RequestParam("bookName") String a,
                    @RequestParam("bookPrice") String b,
                    @RequestParam("bookAuthor") String c){
    System.out.println(a+b+c);
}
```
``注意 如果控制器方法中接收数据的参数名与请求行传值的key一致，则@RequestParam注解可省略``

#### 3.4.2请求头传值

* ajax封装请求头数据

```javascript
$.ajax({
    ...,
    headers: {},
    ...
})
```
**`@RequestHeader`**注解用于接收请求头传递的数据
* 前端
```html
<input type="button" value="AJAX提交" id="btn01"/>

* ajax封装的请求体数据

```javascript
$.ajax({
    ...,
    contentType: "application/json",
    data: {bookName: 'Java', bookPrice: 3333},
    ...
})
```
**`@RequestBody`**注解用于接收请求体传递的数据
* @RequestBody将前端请求体提交的JSON格式数据转换成Java对象，依赖jackson包
```html
<input type="button" value="AJAX提交" id="btn01"/>

* @RequestBody将前端请求体提交的JSON格式数据转换成Java对象，依赖jackson包
* 导入jackson依赖
```xml
<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.1</version>
</dependency>
```
* 控制器
```java
    @RequestMapping("/update")
    public void updateBook(@RequestBody Book book){
        System.out.println(book);
    }
```

### 3.5控制器响应前端请求
#### 3.5.1控制器响应同步请求
>同步请求：from，超链接
* 处理同步请求的方法的返回类型定义为String或者ModelAndView,以实现页面的跳转
* * 返回类型为String
*   请求跳转（转发）
```java
@RequestMapping("/add")
    public String addBook(@RequestParam("bookName") String a,
                        @RequestParam("bookPrice") String b,
                        @RequestParam("bookAuthor") String c){
        System.out.println(a+b+c);
        return "/tips.jsp";
    }
```
重定向
```java
@RequestMapping("/add")
    public String addBook(@RequestParam("bookName") String a,
                        @RequestParam("bookPrice") String b,
                        @RequestParam("bookAuthor") String c){
        System.out.println(a+b+c);
        return "redirect:/tips.jsp";
    }
```
* * 返回类型ModelAndView
* 转发
```java
@RequestMapping("/add")
    public ModelAndView addBook(@RequestParam("bookName") String a,
                                @RequestParam("bookPrice") String b,
                                @RequestParam("bookAuthor") String c){
        System.out.println(a+b+c);
        ModelAndView modelAndView = new ModelAndView("/tips.jsp");
        return modelAndView;
    }
```
* 重定向
* ModelAndView modelAndView = new ModelAndView("redirect:/tips.jsp");

#### 3.5.2控制器响应异步请求
>异步请求：AJAX请求

**使用response中的输出流进行响应**
* 控制器方法的返回类型为 `void`
* 控制器方法添加HttpSevletResponse response参数
* 在方法中通过response获取输出流，使用流响应ajax请求
```java
@RequestMapping("/update")
public void updateBook(@RequestBody Book book, HttpServletResponse response) throws IOException {
        System.out.println(book);
        //使用ObjectMapper将对象转换为JSON格式字符串
        String s = new ObjectMapper().writeValueAsString(book);

response.setCharacterEncoding("utf-8");
        response.setContentType("application/json");
        PrintWriter out= response.getWriter();
        out.println(s);
        out.flush();
        out.close();
        }
```
**直接在控制器方法返回响应的对象（Spring提供的方法）**
* 控制器方法的返回类型设置为响应给ajax请求的对象类型
* 在控制器方法前添加 `@ResponseBody`注解，将返回的对象转换成JSON格式，响应给AJAX请求
* 如果一个控制器类中的所有方法都是响应ajax请求，则可以直接在控制器类前添加@ResponseBody注解
```java
    @RequestMapping("/update")
    @ResponseBody
    public List<Book> updateBook(){

List<Book> books=new ArrayList<Book>();
        books.add(new Book(1,"zz","dd","2"));
        books.add(new Book(2,"C++","C","3"));
        return books;
    }
```

#### 3.5.3控制器响应同步请求的数据传递(不要设置重定向)
>对于同步请求的转发响应，我们可以传递参数到转发的页面
##### 返回类型为String:
* 1.在控制器方法中定义一个Model类型的参数
* 2.在return页面之前，向model中添加键值对，添加的键值对就会被传递到转发的页面
```java
    @RequestMapping("/add")
    public String addBook(String bookName, String bookAuthor, String bookPrice, Model model){

model.addAttribute("key1","value1");
        model.addAttribute("book",new Book(1,"zz","dd","2"));
        return "/tips.jsp";
    }
```
* 除了使用Model对象，还可以直接使用HttpServletRequest对象
```java
    @RequestMapping("/add")
    public String addBook(String bookName, String bookAuthor, String bookPrice, HttpServletRequest request){

request.setAttribute("key1","value1");
        request.setAttribute("book",new Book(1,"zz","dd","2"));
        return "/tips.jsp";
    }
```
>前端接收值： ```${key1}<hr>${book}```

##### 返回类型为ModelAndView
```java
    @RequestMapping("/add2")
    public ModelAndView addBook2(String bookName, String bookAuthor, String bookPrice){

ModelAndView modelAndView = new ModelAndView("redirect:/tips.jsp");
        modelAndView.addObject("key1","value1");
        modelAndView.addObject("book",new Book(1,"zz","dd","2"));
        return modelAndView;
    }
```
### 3.6解决中文乱码问题
#### 3.6.1前端页面
* JSP页面
```html
<%@ page contentType="text/html;charset=UTF-8" language="java" pageEncoding="UTF-8" %>
```
* Html页面
```html
<meta charset="UTF-8">
```
#### 3.6.2服务器编码(解决请求行乱码，特别是get方式)
* tomcat/conf/server.xml
```xml
 <Connector port="8080" protocol="HTTP/1.1"
            connectionTimeout="20000"
            redirectPort="8443" URIEncoding="UTF-8"/>

```
* 或者，选择项目部署的tomcat，在配置项VM options文本框中输入-Dfile.encoding=UTF-8,点击Apply或OK即可。
#### 3.6.3设置SpringMVC的编码方式（类似servlet中编码过滤器）
* 在web.xml中配置SpringMVC编码过滤器的编码方式
```xml
<filter>
    <filter-name>EncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
<filter-name>EncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
```
## 四、SpringMVC请求处理流程
### 4.1请求处理流程
> SpringMVC通过前端控制器DispatcherServlet拦截并处理用户请求

![](img.png)
### 4.2SpringMVC核心组件
1. DispatcherServlet 前端控制器，由SpringMVC提供，无需工程师开发
* 作用：接收请求，协同各组件工作、响应请求
2. HandlerMapping 处理器映射，也由SpringMVC提供
* 作用：负责根据用户请求的URL找到对应的Handler
* 可配置：SpringMVC提供了多个处理器映射的实现，可以根据需求进行配置
3. HandlerAdapter 处理器适配器，也由SpringMVC提供
* 作用：按照处理器映射器解析的用户请求的，调用链通过适配器模式完成Handler的调用
4. Handler 处理器/控制器，由工程师根据业务需求进行开发的
* 作用：处理请求
5. ModelAndView 视图模型
* 作用：用于封装处理器返回的数据以及相应的视图
* ModelAndView=Model+View
6. ViewResolver 视图解析器
* 作用：对ModelAndView进行解析
* 可配置：SpringMVC提供了多个视图解析器
7. View 视图
* 作用：完成数据渲染

### 4.3处理器映射器
>不同的处理器映射器对URL处理的方式也不相同，使用对应的处理器映射器之后我们的前端请求规则也需要发生相应的变化
* Spring提供的处理器映射器
> * BeanNameUrlHandlerMapping 根据控制器的ID访问控制器
> * SimpleUrlHandlerMapping  根据控制器配置的URL访问(默认)
> * S
1. 配置处理器映射器：
* 在SpringMVC的配置文件中通过bean标签声明处理器映射器
* 配置BeanNameUrlHandlerMapping
```xml
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
        
    </bean>
```
* 配置SimpleUrlHandlerMapping(通常使用注解)
```xml
@RequestMapping("/book")
public class BookController {
}

</bean>
```
* 或者在配置文件中配置
```xml
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="/aaa">bookController</prop>
                <prop key="/bbb">studentController</prop>
            </props>
        </property>
    </bean>
```

### 4.3视图解析器
>Spring也提供了多个视图解析器
> * UrlBasedViewResolver 
* 添加JSTL的依赖
```xml
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
```
* 配置视图解析器
```xml
    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
```
> * InternalResourceViewResolver
```xml
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
```
## 五、日期格式处理
### 5.1在控制器中使用对象接收数据
前端
```html
<form action="test/add" method="post">
    <label>图书名称：<input type="text" name="bookName"/></label><br/>
    <label>图书作者：<input type="text" name="bookAuthor"/></label><br/>
    <label>图书价格：<input type="text" name="bookPrice"/></label><br/>
    <label>出版时间：<input type="text" name="publishTime"/></label><br/>
    <p><input type="submit" value="提交"/></p>
</form>
```
后端
```java
@Controller
@RequestMapping("/test")
public class TestController {

@RequestMapping("/add")
    //表单提交的多个数据，在控制器方法中可以使用对象接收
    // 但是提交的数据的key必须要与对象的属性名一致
    public String addBook(Book book){

return "tips";
    }
}
```
tips.jsp
```html
<body>
tips
<hr>
${key1}
<hr>
${book}
</body>
</html>
```
### 5.2 日期格式处理
> 如果前端需要输入日期格式，在控制器中转换为Date对象，SpringMVC要求前端输入的日期格式必须为 `yyyy/MM/dd`
#### 5.2.1 自定义日期格式转换器
```java
/**
 * 1.创建一个类实现Converter接口，泛型指定从什么类型转为什么类型
 * 2.实现convert转换方法
 */
public class MyDateConverter implements Converter<String, Date> {

SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");

public Date convert(String s) {
        Date date=null;
        try {
            date=sdf.parse(s);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}
```
#### 5.2.2配置自定义转换器
```xml
    <mvc:annotation-driven conversion-service="converterFactory"/>
        
    <bean id="converterFactory" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.qfedu.utils.MyDateConverter"/>
            </set>
        </property>
    </bean>
```
## 六、文件上传
### 6.1 SpringMVC框架部署（总结）
1. 基于Maven创建web工程
2. 添加SpringMVC所需的依赖
* Spring：context、aspect、jdbc、test、web、webmvc、jackson
3. 创建SpringMVC配置文件spring-servlet.xml
4. 在web.xml中配置SpringMVC的前端控制器
5. 在web.xml中配置SpringMVC的编码过滤器
6. 在spring-servlet.xml中配置SpringMVC的静态资源处理策略
> 基于Maven创建web工程流程：
1. file-new-maven-pom.xml(添加packaging标签)
2. 在main目录新建webapp目录
3. 在webapp新建WEB-INF目录
4. 在webapp下新建web.xml文件
5. file-programme structure-Modeles-Dependencies-添加Libraries-Tomcat(其实就是添加jsp-api.jar和servlet-api.jar这两个依赖)
6. Add Configuration（调试配置）-Tomcat Server-选择Application server（Tomcat版本）-选择Deployment（下方出现Warning）-选择...:war exploded并且设置Application context：（访问的url）
7. 在resources目录下创建spring-servlet.xml
8. 在web.xml中配置SpringMVC的前端控制器

### 6.2 文件上传
> 案例：添加图书，同时提交图书的封面图片
#### 6.2.1 前端提交文件
* 表单提交方式必须为post
* 表单enctype属性设置为multipart/form-data（表单设置为非压缩传输）
```html
<h4>添加图书信息</h4>
<form action="book/add" method="post" enctype="multipart/form-data">
    <label>图书名称：<input type="text" name="bookName"/></label><br/>
    <label>图书作者：<input type="text" name="bookAuthor"/></label><br/>
    <label>图书价格：<input type="text" name="bookPrice"/></label><br/>
    <label>图书封面：<input type="file" name="imgFile"/></label><br/>
    <p><input type="submit" value="提交"/></p>
</form>
```
#### 6.2.2 控制器接受数据和文件
> SpringMVC处理上传文件需要借助于CommonsMultipartResolver文件解析器
* 添加CommonsMultipartResolver依赖：commmons-io commons-fileupload
```xml
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.4</version>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.4</version>
        </dependency>
```
* 在spring-servlet.xml中配置文件解析器
```xml

    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="1024000000"/>
        <property name="maxInMemorySize" value="102400"/>
        <property name="defaultEncoding" value="utf-8"/>
    </bean>
```
* 控制器接收文件-在处理文件上传的方法中定义一个MultiPartFile类型的对象，就可以接收图片了
```java
@Controller
@RequestMapping("/book")
public class BookController {

@RequestMapping("/add")
    public String addBook(Book2 book, MultipartFile imgFile, HttpServletRequest request) throws IOException {

System.out.println("add");
        //imgFile就表示上传的图片
        String originalFilename = imgFile.getOriginalFilename();
        //1.截取上传文件的后缀名
        String ext = originalFilename.substring(originalFilename.lastIndexOf('.'));//截取了.jpg
        String fileName = System.currentTimeMillis() + ext;//生成新文件名

//2.获取imgs目录在服务器的路径
        String dir = request.getServletContext().getRealPath("imgs");
        String savePath = dir + "/" + fileName;//服务器存储路径

//3.保存文件
        imgFile.transferTo(new File(savePath));

//4.将图片访问路径设置到book对象
        book.setBookImg("imgs/" + fileName);

//5.调用service保存book到数据库

return "tips";
    }
}
```
### 6.3 文件下载
![img_1.png](img_1.png)
#### 6.3.1显示文件列表
* 前端
```html
</head>

<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css" integrity="sha384-HSMxcRTRxnN+Bdg0JdbxYKrThecOKuH5zCYotlSAcp1+c8xmyTe9GYg1l9a69psu" crossorigin="anonymous">

<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap-theme.min.css" integrity="sha384-6pzBo3FDv/PJ8r2KRkGHifhEocL+1X2rVCTTkUfGk7/0pbek5mMa1upzvWbrUbOZ" crossorigin="anonymous">

<script src="https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/js/bootstrap.min.js" integrity="sha384-aJ21OjlMXNL5UyIl/XNwTMqvzeRMZH2w8c5cRVpzpU8Y5bApTppSuUkhZXN0VxHd" crossorigin="anonymous"></script>

<body>

</div>

</body>
</html>
```
* BookController
```java
@RequestMapping("/list")
    @ResponseBody
    public String[] listImgs(HttpServletRequest request){
        //1.从imgs目录下获取所有的图片信息
        String dir = request.getServletContext().getRealPath("imgs");
        File imgDir=new File(dir);
        String[] fileNames = imgDir.list();
        return fileNames;
    }
```
#### 6.3.2实现文件下载
* list.jsp
```javascript
var htmlStr="<div class='col-lg-2  col-md-3 col-sm-4 col-xs-6'><div class='thumbnail'><img src='imgs/"+fn+"' alt='...'><div class='caption'> <p><a href='book/download?fname="+fn+"' class='btn btn-primary' role='button'>下载</a></p></div></div></div>";
```
* BookController
```java
@RequestMapping("/download")
    public void downloadImg(String fname,HttpServletRequest request,HttpServletResponse response) throws IOException {
        //从imgs目录找到当前文件
        String dir = request.getServletContext().getRealPath("imgs");
        String filePath=dir+"/"+fname;
        FileInputStream fileInputStream = new FileInputStream(filePath);//创建输入流

//返回浏览器不能识别的类型，浏览器可以识别图片，图片类型会直接显示
        response.setContentType("application/exe");
        //返回请求头，设置文件名称
        response.addHeader("Content-Disposition","attachment;filename="+fname);

//利用io完成文件拷贝
        IOUtils.copy(fileInputStream, response.getOutputStream());
    }
```

## 七、统一异常处理
> 在应用系统运行的过程中，可能由于运行环境、用户操作、资源不足等各方面的原因导致系统出现异常（HTTP状态问题、Exception）;如果系统出现了异常，这些异常将会通过返回浏览器呈现给用户，而这种异常的显示没有必要，我们可以在服务器进行特定处理----当异常出现之后呈现给用户一个统一的，可读的异常提示页面。
### 7.1 HTTP异常状态统一处理
> HTTP Status 404 
* 创建一个用于进行异常提示的页面：404.jsp
* 在web.xml进行配置
```xml

    <error-page>
        <error-code>404</error-code>
        <location>/404.jsp</location>
    </error-page>
```
### 7.2 Java代码异常的统一处理
#### 7.2.1 基于Servlet-api的处理
```xml
    <error-page>
        <exception-type>java.lang.NumberFormatException</exception-type>
        <location>/err.jsp</location>
    </error-page>
```
#### 7.2.2 基于SpringMVC
* 使用异常处理类进行统一处理
```java
@ControllerAdvice
public class MyExceptionHandler {
    @ExceptionHandler(NullPointerException.class)
    public String nullHandler(){
        return "err";
    }
    @ExceptionHandler(NumberFormatException.class)
    public String formatHandler(){
        return "err";
    }
}
```

## 八、拦截器
### 8.1 拦截器介绍
> SpringMVC提供的拦截器就类似于Servlet-api中的过滤器，可以对控制器的请求进行拦截，实现相关的预处理和后处理
* 过滤器：是Servlet规范的一部分，所有web项目都可以使用
* 过滤器在web.xml配置（可以使用注解），能够拦截所有web请求
* 拦截器：是SpringMVC框架的实现，只有在SpringMVC中可以使用
* 拦截器在SpringMVC配置文件配置，不会拦截SpringMVC放行的资源（jsp\html\css..）

### 8.2自定义拦截器
#### 8.2.1 创建拦截器
```java
public class MyInterceptor1 implements HandlerInterceptor {

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("预处理");
        //必须传bookId才可以通过预处理
        Enumeration<String> keys = request.getParameterNames();//获取元素key
        while (keys.hasMoreElements()){
            String key=keys.nextElement();
            if("bookId".equals(key)){
                return true;
            }
        }
        response.setStatus(400);
        return false;
    }

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("后处理");
        modelAndView.addObject("tips1","mode");//通过拦截器后处理返回前端数据

}
}
```

#### 8.2.2 配置拦截器
```xml
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/book/query"/>
            
            <mvc:mapping path="/student/**"/>
            <mvc:exclude-mapping path="/student/add"/>
            
            <bean class="com.qfedu.utils.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>
```

#### 8.2.3 拦截器链
* 将多个拦截器按照一定的顺序，构成一个执行链
```xml
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/book/query"/>
            <bean class="com.qfedu.utils.MyInterceptor1"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/book/query"/>
            <bean class="com.qfedu.utils.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>
```

geniusdz/SpringMVC

简介

发行版

贡献者

近期动态

geniusdz/SpringMVC .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

geniusdz/SpringMVC