springMVC(3)学习

SpringMVC框架

第一章：响应数据和结果视图

返回值分类

搭建开发环境

pom.xml

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xsy.lx</groupId>
  <artifactId>SpringMVC3</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
    <servlet-api.version>3.1.0</servlet-api.version>
    <jsp-api.version>2.3.3</jsp-api.version>
    <jstl.version>1.2</jstl.version>
  </properties>

  <dependencies>
    <!-- Spring Core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- Spring Web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- Spring MVC -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- Servlet API (使用较新版本) -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-api.version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- JSP API -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>${jsp-api.version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- JSTL (可选，但如果用JSP建议添加) -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl.version}</version>
    </dependency>

    <!-- Junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>SpringMVC3</finalName>
    <plugins>
      <!-- 编译插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>8</source>
          <target>8</target>
        </configuration>
      </plugin>

      <!-- War插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.2.3</version>
        <configuration>
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

在web.xml中配置前端控制器DispatcherServlet和过滤器

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

<display-name>My Web Application</display-name>

<!-- 在这里添加您的servlet、filter等配置 -->
    <!--配置解决中文乱码问题的过滤器-->
    <filter>
        <filter-name>characterEncodingFilter</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>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置前端控制器-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--加载springmvc.xml配置文件，配置的是Spring配置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--配置启动加载-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!---->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

Springmvc.xml配置文件

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置了内容，启动Tomcat服务器的时候，就会被加载-->
    <!--配置注解扫描-->
    <context:component-scan base-package="com.xsy" />

    <!--配置视图解析器，进行页面的跳转-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--跳转的页面的路径-->
        <property name="prefix" value="/pages/" />
        <!--跳转页面的后缀名称-->
        <property name="suffix" value=".jsp" />
    </bean>
    <!--让映射器、适配器和处理器生效(默认不配置也是可以的)-->
    <mvc:annotation-driven/>

</beans>

返回String

1 Controller方法返回字符串可以指定逻辑视图的名称，根据视图解释器为物理视图的地址。

java 复制代码

@RequestMapping("save1.do")
public String save(){
    System.out.println("xsy的方法执行了");
    return "suc";
}

会直接跳转到suc.jsp

返回值是void

1 如果控制器的方法返回值编写成void，执行程序包404的异常，默认查找JSP页面没有找到。

默认会跳转到@RequestMapping(value="/initUpdate") initUpdate的页面

2 可以使用请求转发或者重定向跳转到指定的页面

java 复制代码

@RequestMapping("/save2.do")
    public void save2(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("xsy的请求转发执行了");
//        进行请求转发到suc.jsp页面
        request.getRequestDispatcher("/pages/suc.jsp").forward(request,response);
//        向响应输出"hello"
        response.getWriter().print("hello");
    }

会请求转发到suc.jsp页面

当把请求转发注释掉后会执行response.getWriter().print("hello");

会在页面上写 hello

返回值是ModelAndView对象

1 ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图

java 复制代码

 @RequestMapping("/save3.do")
    public ModelAndView save3(){
        System.out.println("返回了ModelAndView");
//        创建mv对象
        ModelAndView mv = new ModelAndView();
//        把一些数据，存储到mv对象中
        mv.addObject("msg","用户名或者密码已经存在");
//        设置逻辑视图的名称
        mv.setViewName("suc");
        return mv;
    }

前段代码

jsp 复制代码

<p>消息：${msg}</p>

当访问这个接口的时候会跳转到suc.jsp中然后

消息：${msg}
这行代码会拿取mv里面的信息显示到页面中

SpringMVC框架提供的转发和重定向

forward请求转发

1 Controller方法返回String 想进行请求转发也可以编写成

java 复制代码

/**
 * 请求转发
 * @return
 */
@RequestMapping("/save4.do")
public String save4(){
    System.out.println("返回String 进行请求转发");
    return "forward:/pages/suc.jsp";
}

会请求转发到suc.jsp页面地址栏不变

redirect重定向

1 Controller方法返回String类型想进行重定向也可以编写成

java 复制代码

/**
 * 重定向
 * @return
 */
@RequestMapping("/save5.do")
public String save5(){
    System.out.println("重定向执行了");
    return "redirect:/pages/suc.jsp";
}

会重定向到suc页面地址栏地址会变化

ResponseBody响应json数据（重要）

json字符串和 javeBean对象互相转换的过程中，需要使用jackson的jar包

xml 复制代码

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.0</version>
        </dependency>

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img css js ）也会被拦截到，从而不能被使用。解决问题就是需要配置静态资源不进行拦截，在Springmvc.xml配置文件中添加下面配置

标签配置不过滤

location元素表示webapp目录下的包下的所有文件

mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b

xml 复制代码

<!--设置静态资源不过滤-->
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/images/**" location="/images"/>
<mvc:resources mapping="/js/**" location="/js/"/>

jsp代码编写

创建一个新的jsp文件

jsp 复制代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Controller方法的返回值</title>

    <%--引入jq--%>
    <script src="/js/jquery-3.7.1.min.js" type="text/javascript"></script>

    <script>
        // 页面加载
        $(function(){
            // 单击事件
            $("#btn").click(function(){
                // 发送ajax的请求
                $.ajax({
                    type: "post",
                    url: "/user/save6.do",
                    contentType:"application/json;charset=UTF-8",
                    data:'{"name":"xsy","age":"20"}',
                    dataType: "json",
                    success:function(d){
                        // 编写很多代码
                        alert(d.username+" - "+d.age);
                    }
                });
            });
        });
    </script>
    
</head>
<body>

<h3>返回值是String</h3>
<a href="/user/save1.do" >返回String</a>

<h3>返回值是void</h3>
<a href="/user/save2.do" >返回void</a>

<h3>返回值是ModelAndView</h3>
<a href="/user/save3.do" >返回ModelAndView</a>

<h3>返回值是String</h3>
<a href="/user/save4.do" >返回值是String</a>

<h3>返回值是String</h3>
<a href="/user/save5.do" >返回值是String</a>

<h3>异步的数据交互</h3>
<input type="button" value="ajax交互" id="btn">

</body>
</html>

在UserController.java中编写代码

java 复制代码

 /**
     * 异步的数据交互
     * 重定向
     * @param user
     * @return
     */
    @RequestMapping("/save6.do")
    public @ResponseBody User save6(@RequestBody User user){
        System.out.println(user);
//        模拟 调用业务层代码
        user.setName("xsy");
        user.setAge(22);
//        把user独享转换成json，字符串，在响应。使用@ResponseBody注解 Response.gerWriter.print()
        return user;
    }

实体类的编写

java 复制代码

package com.xsy.demo.entity;
import lombok.Data;
@Data
public class User {
    private String name;
    private int age;
}

第二章：SpringMVC实现文件上传

文件上传的准备

导入文件上传的jar包

xml 复制代码

  <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
  </dependency>
  <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
  </dependency>
</dependencies>

编写文件上传的jsp页面

创建upload.jsp

jsp 复制代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件上传</title>
</head>
<body>

<h3>文件上传</h3>

<form action="/fileupload.do" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload" /><br/>
    <input type="submit" value="上传" />
</form>

</body>
</html>

SpringMVC传统方式文件上传

配置文件解析器对象

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置了内容，启动Tomcat服务器的时候，就会被加载-->
    <!--配置注解扫描-->
    <context:component-scan base-package="com.xsy" />

    <!--配置视图解析器，进行页面的跳转-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--跳转的页面的路径-->
        <property name="prefix" value="/pages/" />
        <!--跳转页面的后缀名称-->
        <property name="suffix" value=".jsp" />
    </bean>
    <!--让映射器、适配器和处理器生效(默认不配置也是可以的)-->
    <mvc:annotation-driven/>
    <!--设置静态资源不过滤-->
    <mvc:resources mapping="/css/**" location="/css/"/>
    <mvc:resources mapping="/images/**" location="/images"/>
    <mvc:resources mapping="/js/**" location="/js/"/>

<!--    配置文件上传的解析器组件 id的名称是固定的 不能乱写-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--        设置上传文件的总大小 8M=8*1024*1024-->
        <property name="maxUploadSize" value="8388608"/>
    </bean>
</beans>

SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的name属性名称相同。

前端表单中：<input type="file" name="upload">
后端Controller中：MultipartFile upload
两个upload名称必须完全一致

java 复制代码

package com.xsy.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.Locale;
import java.util.UUID;

/**
 * 文件上传
 */
@Controller
public class UploadController {
    /**
     * 文件上传
     * MultipartFile upload 文件上传解析器对象 解析request后，文件上传对象
     * @param upload
     * @param request
     * @return
     * @throws IOException
     */
    @RequestMapping("/fileupload.do")
    public String upload(MultipartFile upload, HttpServletRequest request) throws IOException {
//        把文件上传到哪个位置
        String realPath=request.getSession().getServletContext().getRealPath("/uploads");
//      创建该文件夹
        File file = new File(realPath);
//      判断该文件夹是否存在
        if(!file.exists()){
//            创建文件夹
            file.mkdirs();
        }
        String originalFilename = upload.getOriginalFilename();
//        把文件的名称修改成唯一的值 随机生成一个uuid+文件名
        String uuid = UUID.randomUUID().toString().replace("-", "").toUpperCase();

        originalFilename=originalFilename+"_"+uuid;

        System.out.println("文件名称"+originalFilename);
        System.out.println(realPath);
//        文件上传
        upload.transferTo(new File(file,originalFilename));

        return "suc";
    }
}

第三章：SpringMVC的异常处理

异常处理思路

Controller调用Service，Service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进行异常的处理。

SpringMVC的异常处理

Controller代码

java 复制代码

package com.xsy.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/role")
public class RoleController {
    /**
     * 自己处理异常
     * @return
     @RequestMapping("/findAll.do")
     public String findAll(){
     try {
     System.out.println("执行了...");
     // 模拟异常
     int a = 10/0;
     } catch (Exception e) {
     e.printStackTrace();
     // 跳转到友好提示页面
     }
     return "suc";
     }
     */

    /**
     * 使用异常处理器方式
     * @return
     */

    @RequestMapping("/findAll.do")
    public String findAll(){
        System.out.println("测试自定义异常处理器");
        int a=10/0;
        return "suc";
    }
}

自定义异常类

java 复制代码

package com.xsy.demo.exception;

//自定义异常类 需要继承异常类
public class SysException extends Exception {
    private String message;
    public void setMessage(String message) {
        this.message = message;
    }

    public SysException(String message) {
        this.message = message;
    }
    @Override
    public String getMessage() {
        return message;
    }
}

自定义异常处理器

实现HandlerExceptionResolver接口用于同意处理Controller层抛出的所有异常

java 复制代码

package com.xsy.demo.resolver;

import com.xsy.demo.exception.SysException;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
//自定义异常处理器
public class SysExceptionResolver implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse, Object o, Exception e) {
//        在控制台打印异常信息
        e.printStackTrace();
//        做强转
        SysException exception=null;
//        进行判断
        // 判断
        if(e instanceof SysException){
            exception = (SysException)e;
        }else{
            exception = new SysException("系统正在维护，请联系管理员");
        }
        ModelAndView mv = new ModelAndView();
        mv.addObject("errorMsg",e.getMessage());
//        设置跳转的页面
        mv.setViewName("error");
        return mv;
    }
}

配置异常处理器

xml 复制代码

<!--    配置异常处理器-->
    <bean id="sysExceptionResolver" class="com.xsy.demo.resolver.SysExceptionResolver" />

jsp页面代码

jsp 复制代码

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
<html>
<head>
    <title>错误提示页面</title>
</head>
<body>

<h3>错误的友好提示页面</h3>

${errorMsg}

</body>
</html>

第四章：SpringMVC框架中的拦截器

拦截器的概述

SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。

可以定义拦截器链，拦截器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器就会按着定义的顺序执行。

拦截器和过滤器的功能比较类似，有区别

过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。

拦截器是SpringMVC框架独有的。

过滤器配置了/*，可以拦截任何资源

拦截器只会对控制器中的方法进行拦截

拦截器也是AOP思想的一种实现方式

想要自定义拦截器，需要实现HandlerInterceptor接口。

自定义拦截器步骤

Controller中的方法

java 复制代码

package com.xsy.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//拦截器测试
@Controller
@RequestMapping("/dept")
public class DeptController {
    @RequestMapping("/find.do")
    public String findAll(){
        System.out.println("controller方法执行了");
        return "suc";
    }
}

创建拦截器类实现HandlerInterceptor接口重写需要的方法

java 复制代码

package com.xsy.demo.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 拦截器controller中方法，放行了 执行Controller中的方法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("xsy的拦截器preHandle方法执行了");
        return true;
    }
}

在springMVC.xml中配置拦截器类

xml 复制代码

<!--    配置拦截器们-->
    <mvc:interceptors>
<!--        配置拦截器-->
        <mvc:interceptor>
<!--            该拦截器拦截哪些资源-->
            <mvc:mapping path="/dept/**"/>
            <mvc:exclude-mapping path="/role/**"/>
<!--            拦截器对象-->
            <bean class="com.xsy.demo.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

HandlerInterceptor接口中的方法

preHandler方法是Controller方法执行前拦截的方法

可以使用request或者Response跳转到指定的页面

return true放行，执行下一个拦截器如果没有拦截器执行Controller中的方法

return false不放行不会执行Controller中的方法

postHandle是Controller方法执行后执行的方法在jsp视图前执行的

可以使用request或者Response跳转到指定的页面

如果指定了跳转的页面那么Controller方法跳转的页面将不会在显示

afterCompletion方法是在JSP执行后执行

request或者Response不能在跳转页面了

java 复制代码

package com.xsy.demo.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 拦截器controller中方法，放行了 执行Controller中的方法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("xsy的拦截器preHandle方法执行了");
        return true;
    }

    /**
     * Controller方法执行后 要拦截的方法
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("xsy的拦截器的postHandle");
//        也可以进行页面的跳转
        request.getRequestDispatcher("/index.jsp").forward(request, response);
        return;
    }

    /**
     * controller跳转到的jsp页面都执行完成了 最后执行该方法
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("xsy的afterCompletion方法执行了");
    }
}

配置多个拦截器

多个拦截器执行顺序：先进后出先执行的最后才执行完

在编写一个拦截器的类

java 复制代码

package com.xsy.demo.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor2 implements HandlerInterceptor {
    /**
     * 第二个拦截器 的preHandle方法 方法了 执行Controller的方法
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("xsy的第二个拦截器执行了preHandle执行了");
        return true;
    }

    /**
     * 第二个拦截器中的 在postHandle 在Controller方法执行后 要拦截的方法
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("xsy的第二拦截器中的postHandle方法执行了");
    }

    /**
     * 第二个拦截器 跳转的jsp页面都执行完了 最后执行该方法
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("xsy的第二个拦截器中的afterCompletion方法执行了");
    }

}

在配置文件中进行配置

xml 复制代码

<!--    配置拦截器们-->
    <mvc:interceptors>
<!--        配置拦截器-->
        <mvc:interceptor>
<!--            该拦截器拦截哪些资源-->
            <mvc:mapping path="/dept/**"/>
            <mvc:exclude-mapping path="/role/**"/>
<!--            拦截器对象-->
            <bean class="com.xsy.demo.interceptor.MyInterceptor"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/dept/**"/>
            <bean class="com.xsy.demo.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

执行顺序：先进后出先执行的最后才执行完