SpringMVC拦截器的使用详解

一、拦截器简介

Spring MVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。

常见应用场景

1、日志记录：记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等。
2、权限检查：如登录检测，进入处理器检测检测是否登录，如果没有直接返回到登录页面；
3、性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）；
4、通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个处理器都需要的即可使用拦截器实现。
5、OpenSessionInView：如Hibernate，在进入处理器打开Session，在完成后关闭Session。

本质也是AOP（面向切面编程），也就是说符合横切关注点的所有功能都可以放入拦截器实现。

二、SpringMVC的默认控制器

1、DispatcherServlet

SpringMVC具有统一的入口DispatcherServlet，所有的请求都通过DispatcherServlet。DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller来处理。 所以我们现在web.xml中加入以下配置：

    <servlet>  
     <servlet-name>springMybatis</servlet-name>  
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
     <load-on-startup>1</load-on-startup>  
   </servlet>  
   <servlet-mapping>  
     <servlet-name>springMybatis</servlet-name>  
     <!-- 所有的的请求，都会被DispatcherServlet处理 -->  
     <url-pattern>/</url-pattern>  
   </servlet-mapping>  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

初始化 DispatcherServlet时，该框架在 web应用程序WEB-INF目录中寻找一个名为[servlet-名称]-servlet.xml的文件， 并在那里定义相关的Beans，重写在全局中定义的任何Beans。

2、配置静态资源文件不拦截

如果只配置拦截类似于*.do格式的url，则对静态资源的访问是没有问题的，但是如果配置拦截了所有的请求（如我们上面配置的“/”），就会造成js文件、css文件、图片文件等静态资源无法访问。一般实现拦截器主要是为了权限管理，主要是拦截一些url请求，所以不对静态资源进行拦截。要过滤掉静态资源一般有两种方式。

第一种是采用<mvc:default-servlet-handler />，（一般Web应用服务器默认的Servlet名称是”default”，所以这里我们激活Tomcat的defaultServlet来处理静态文件，在web.xml里配置如下代码即可：）

<servlet-mapping>  
    <servlet-name>default</servlet-name>  
    <url-pattern>/js/*</url-pattern>  
    <url-pattern>/css/*</url-pattern>  
    <url-pattern>/images/*</url-pattern>  
    <url-pattern>/fonts/*</url-pattern>  
</servlet-mapping>  

• 1
• 2
• 3
• 4
• 5
• 6
• 7

Tomcat, Jetty, JBoss, and GlassFish 默认 Servlet的名字 – “default”
Resin 默认 Servlet的名字 – “resin-file”
WebLogic 默认 Servlet的名字 – “FileServlet”
WebSphere 默认 Servlet的名字 – “SimpleFileServlet”

第二种是采用<mvc:resources />，在springmvc的配置文件中加入以下代码：

<mvc:resources mapping="/js/**" location="/static_resources/javascript/"/>    
<mvc:resources mapping="/styles/**" location="/static_resources/css/"/>    
<mvc:resources mapping="/images/**" location="/static_resources/images/"/>  

• 1
• 2
• 3

三、自定义拦截器

在springmvc中，定义拦截器要实现HandlerInterceptor接口，并实现该接口中提供的三个方法。

1、拦截器接口HandlerInterceptor

package org.springframework.web.servlet;  
public interface HandlerInterceptor {  
    boolean preHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler)   
            throws Exception;  

    void postHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, ModelAndView modelAndView)   
            throws Exception;  

    void afterCompletion(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, Exception ex)  
            throws Exception;  
}   

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

• preHandle

预处理回调方法，实现处理器的预处理（如登录检查），第三个参数为响应的处理器（如具体的Controller实现）；
返回值：true表示继续流程（如调用下一个拦截器或处理器）；false表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应；

• postHandle

后处理回调方法，实现处理器的后处理（但在渲染视图之前），此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对视图进行处理，modelAndView也可能为null。

• afterCompletion

整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在此记录结束时间并输出消耗时间，还可以进行一些资源清理，类似于try-catch-finally中的finally，但仅调用处理器执行链中preHandle返回true的拦截器的afterCompletion。

2、拦截器适配器

有时候我们可能只需要实现三个回调方法中的某一个，如果实现HandlerInterceptor接口的话，三个方法必须实现，不管你需不需要，此时spring提供了一个HandlerInterceptorAdapter适配器（一种适配器设计模式的实现），允许我们只实现需要的回调方法。

public abstract class HandlerInterceptorAdapter implements HandlerInterceptor {  
     //省略代码 此处所以三个回调方法都是空实现，preHandle返回true。  
} 

• 1
• 2
• 3

使用方式如下：

//省略import  
public class HandlerInterceptor1 extends HandlerInterceptorAdapter {
//此处继承HandlerInterceptorAdapter适配器即可  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
        System.out.println("===========HandlerInterceptor1 preHandle");  
        return true;  
    }  
    @Override  
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {  
        System.out.println("===========HandlerInterceptor1 postHandle");  
    }  
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {  
        System.out.println("===========HandlerInterceptor1 afterCompletion");  
    }  
}  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

四、示例演示

1、自定义拦截器

这里采用实现接口的方式来自定义拦截器。
定义拦截器1

//测试拦截器1
public class HandlerInterceptor1 implements HandlerInterceptor{

    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        System.out.println("HandlerInterceptor1....preHandle");

        //false表示拦截，不向下执行；true表示放行
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {

        System.out.println("HandlerInterceptor1....postHandle");

    }

    @Override
    public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {

        System.out.println("HandlerInterceptor1....afterCompletion");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

定义拦截器2

//测试拦截器2
public class HandlerInterceptor2 implements HandlerInterceptor{

    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        System.out.println("HandlerInterceptor2....preHandle");

        //false表示拦截，不向下执行；true表示放行
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {

        System.out.println("HandlerInterceptor2....postHandle");

    }

    @Override
    public void afterCompletion(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex)
            throws Exception {

        System.out.println("HandlerInterceptor2....afterCompletion");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30

2、springmvc拦截器的配置

在springmvc中，拦截器是针对具体的HandlerMapping进行配置的，也就是说如果在某个HandlerMapping中配置拦截，经过该 HandlerMapping映射成功的handler最终使用该拦截器。比如，假设我们在配置文件中配置了的映射器是org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping，那么我们可以这样来配置拦截器：

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
    <property name="interceptors">
        <list>
            <ref bean="handlerInterceptor1"/>
            <ref bean="handlerInterceptor2"/>
        </list>
    </property>
</bean>
<bean id="handlerInterceptor1" class="ssm.intercapter.HandlerInterceptor1"/>
<bean id="handlerInterceptor2" class="ssm.intercapter.HandlerInterceptor2"/>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

在springmvc中配置全局拦截器如下：

<!-- 配置拦截器 -->
<mvc:interceptors>
    <!-- 多个拦截器，按顺序执行 -->        
    <mvc:interceptor>
        <mvc:mapping path="/**"/> <!-- 表示拦截所有的url包括子url路径 -->
        <bean class="ssm.interceptor.HandlerInterceptor1"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="ssm.interceptor.HandlerInterceptor2"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="ssm.interceptor.HandlerInterceptor3"/>
    </mvc:interceptor>
</mvc:interceptors>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

一般情况下我们都用这种配置，<mvc:mapping>中指定要拦截的url即可。

3、springmvc拦截器的执行测试

仿照上面的HandlerInterceptor1再写两个拦截器，HandlerInterceptor2和HandlerInterceptor3，配置是按照上面这个配置。然后我们来测试一下三个拦截器的执行情况，并做相关总结。

• 三个拦截器都放行

也就是说，我们将三个拦截器的preHandle方法中返回值都改成true，来测试一下拦截器的执行顺序，测试结果如下：

HandlerInterceptor1….preHandle 
HandlerInterceptor2….preHandle 
HandlerInterceptor3….preHandle

HandlerInterceptor3….postHandle 
HandlerInterceptor2….postHandle 
HandlerInterceptor1….postHandle

HandlerInterceptor3….afterCompletion 
HandlerInterceptor2….afterCompletion 
HandlerInterceptor1….afterCompletion

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

根据打印的结果做一个总结：当所有拦截器都放行的时候，preHandle方法是按照配置的顺序执的；而另外两个方法按照配置的顺序逆向执行的。

• 有一个拦截器不放行

我们将第三个拦截器的preHandle方法中返回值改成false，前两个还是true，来测试一下拦截器的执行顺序，测试结果如下：

HandlerInterceptor1….preHandle 
HandlerInterceptor2….preHandle 
HandlerInterceptor3….preHandle

HandlerInterceptor2….afterCompletion 
HandlerInterceptor1….afterCompletion

• 1
• 2
• 3
• 4
• 5
• 6

根据打印的结果做一个总结：
1. 由于拦截器1和2放行，所以拦截器3的preHandle才能执行。也就是说前面的拦截器放行，后面的拦截器才能执行preHandle。
2. 拦截器3不放行，所以其另外两个方法没有被执行。即如果某个拦截器不放行，那么它的另外两个方法就不会背执行。
3. 只要有一个拦截器不放行，所有拦截器的postHandle方法都不会执行，但是只要执行过preHandle并且放行的，就会执行afterCompletion方法。

• 三个拦截器都不放行

这种情况其实可以参考上面的情况了，是一个特例，也看一下运行结果：

HandlerInterceptor1….preHandle

• 1

很明显，就只执行了第一个拦截器的preHandle方法，因为都不放行，所以没有一个执行postHandle方法和afterCompletion方法。

五、拦截器的使用

从第二种情况来看，比如现在要写一个统一异常处理的逻辑，那么要将该拦截器放在拦截器链的第一个位置，且一定要放行，因为只有放行了，才会去执行afterCompletion，而且放在拦截器链的第一个的话，afterCompletion方法会最后执行，才能在里面执行统一异常处理的逻辑。 再比如，登陆认证拦截器，放在拦截器链接中第一个位置（如果有统一异常处理，那么应该放在统一异常处理的后面）。权限校验拦截器，放在登陆认证拦截器之后（因为登陆通过后才校验权限）。 这里写一个登陆验证的拦截器来说明一下如何使用springmvc的拦截器。

1、拦截器思路

如果请求的url是公开地址（无需登陆即可访问的url），让放行。
否则检测用户session是否存在。
如果用户session不存在，则跳转到登陆页面。
如果用户session存在则放行，继续操作。

2、实现登陆的Controller方法

//登陆
@RequestMapping("/login")
public String login(HttpServletRequest request, String username, String password) throws Exception {

    //实际中要去和数据库匹配的
    //....
    //这里就假设登陆成功了
    HttpSession session = request.getSession();
    session.setAttribute("username", username);
    return "redirect:queryItems.action";
}

//退出
@RequestMapping("/logout")
public String logout(HttpServletRequest request) throws Exception {

    HttpSession session = request.getSession();
    session.invalidate();
    return "redirect:queryItems.action";
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

3、登陆验证拦截器的实现

//测试拦截器1
public class LoginInterceptor implements HandlerInterceptor{

    //进入Handler方法之前执行
    //可以用于身份认证、身份授权。如果认证没有通过表示用户没有登陆，需要此方法拦截不再往下执行，否则就放行
    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        //获取请求的url
        String url = request.getRequestURI();
        //判断url是否公开地址（实际使用时将公开地址配置到配置文件中）
        //这里假设公开地址是否登陆提交的地址
        if(url.indexOf("login.action") > 0) {
            //如果进行登陆提交，放行
            return true;
        }

        //判断session
        HttpSession session = request.getSession();
        //从session中取出用户身份信息
        String username = (String) session.getAttribute("username");
        if(username != null) {
            return true;
        }

        //执行到这里表示用户身份需要验证，跳转到登陆页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);

        return false;
    }
    //节省空间，省略另外两个方法不写了，也不用处理
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33

然后配置该拦截器：

<!-- 配置拦截器 -->
<mvc:interceptors>
    <!-- 多个拦截器，按顺序执行 -->    
    <mvc:interceptor>
        <mvc:mapping path="/**"/> <!-- 拦截所有的url包括子url路径 -->
        <bean class="ssm.interceptor.LoginInterceptor"/>
    </mvc:interceptor>
    <!-- 其他拦截器 -->
</mvc:interceptors>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

这样当我们任意请求一个url的时候，就会被刚刚我们定义的拦截器给捕获到，然后会判断是否session中有用户信息，没有的话就会跳到登陆页面让我们登陆：

<form action="${pageContext.request.contextPath }/login.action" method="post">
    用户名：<input type="text" name="username" /><br>
    密码：<input type="password" name="password" /><br>
    <input type="submit" name="提交" />
</form>