SpringMVC 拦截器学习

Java › Spring › SpringMVC › 转载

demo地址

https://gitee.com/fengzxia/spring-mvc-interceptor-learn

常见应用场景

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

需要用到的jar，版本号可以根据自己项目中spring的版本号来些，我这里是5.0.0.RELEASE版本

1
2
3
4
5
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.0.0.RELEASE</version>
</dependency>

拦截器接口如下

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
package org.springframework.web.servlet;

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

import org.springframework.lang.Nullable;
import org.springframework.web.method.HandlerMethod;


public interface HandlerInterceptor {

	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}

	
	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

}

拦截器一共有3个回调方法:

  1. perHandle:预处理回调方法，实现处理器的预处理（如登录检测、ip白名单拦截），第三个参数为响应的处理器；
    返回值:true表示继续流程（如调用下一个拦截器或处理器）；
    false表示中断（如登录检测失败，ip不在白名单），不会继续调用其他的拦截器或者处理器，此时需要通过response来产生响应；
  2. postHandle:后处理回调方法，实现处理器的后处理（但是在渲染视图之前），此时我们可以通过modelAndView(模型和视图对象)对模型数据进行处理或对视图进行处理，modelAndView也可能为null。
  3. afterCompletion:整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在次记录结束时间并输出消耗时间，还可以进行一些资源清理，类似try-catch-finally中的finally，但仅调用处理器执行链中perHandle返回true的拦截器afterCompletion

拦截器适配器

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

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
34
35
package org.springframework.web.servlet.handler;

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

import org.springframework.lang.Nullable;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;


public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {


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

		return true;
	}

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

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

运行流程图

正常流程
1-1 正常流程

中断流程
1-2 中断流程

中断流程中，比如是HandlerInterceptor2中断的流程（preHandle返回false），此处仅调用它之前拦截器的preHandle返回true的afterCompletion方法。

DispatcherServlet内部的工作流程

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
34
35
36
//doDispatch方法  
//1、处理器拦截器的预处理（正序执行）  
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();  
if (interceptors != null) {  
    for (int i = 0; i < interceptors.length; i++) {  
    HandlerInterceptor interceptor = interceptors[i];  
        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {  
            //1.1、失败时触发afterCompletion的调用  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
            return;  
        }  
        interceptorIndex = i;//1.2、记录当前预处理成功的索引  
  }  
}  
//2、处理器适配器调用我们的处理器  
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
//当我们返回null或没有返回逻辑视图名时的默认视图名翻译（详解4.15.5 RequestToViewNameTranslator）  
if (mv != null && !mv.hasView()) {  
    mv.setViewName(getDefaultViewName(request));  
}  
//3、处理器拦截器的后处理（逆序）  
if (interceptors != null) {  
  for (int i = interceptors.length - 1; i >= 0; i--) {  
    HandlerInterceptor interceptor = interceptors[i];  
    interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);  
  }  
}  
//4、视图的渲染  
if (mv != null && !mv.wasCleared()) {  
  render(mv, processedRequest, response);  
  if (errorView) {  
      WebUtils.clearErrorRequestAttributes(request);  
  }  
  //5、触发整个请求处理完毕回调方法afterCompletion  
  triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null); 
}
  • 注:以上是流程的简化代码，中间省略了部分代码，不完整

正常流程

1.拦截器实现

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
34
package com.lx.interceptor;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

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

/**
 * 拦截器
 *
 * @author 段誉
 * @create 2019-03-21 9:03
 */
public class MyHandlerInterceptor1 extends HandlerInterceptorAdapter {////此处一般继承HandlerInterceptorAdapter适配器即可
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler) throws Exception {
    System.out.println("--------------------------MyHandlerInterceptor1.preHandle");
    return true;
  }

  @Override
  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler
          , ModelAndView modelAndView) throws Exception {
    System.out.println("--------------------------MyHandlerInterceptor1.postHandle");
  }

  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                              Object handler, Exception ex) throws Exception {
    System.out.println("--------------------------MyHandlerInterceptor1.afterCompletion");
  }
}

以上是MyHandlerInterceptor1实现，MyHandlerInterceptor2同理，只是输出内容为MyHandlerInterceptor2。

2.控制器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.lx.controller;

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

/**
 * @author 段誉
 * @create 2019-03-20 15:29
 */
@Controller
public class IndexController {
  @GetMapping
  public String index() {
    System.out.println("IndexController.index");
    return "/index";
  }

}

3.springMVC配置文件

1
2
3
4
5
6
7
8
9
10
11
<mvc:interceptors>
  <mvc:interceptor>
    <mvc:mapping path="/**"/>
    <bean class="com.lx.interceptor.MyHandlerInterceptor1"/>
  </mvc:interceptor>
  <mvc:interceptor>
    <mvc:mapping path="/**"/>
    <!--<mvc:exclude-mapping path="/index/**"/>-->
    <bean class="com.lx.interceptor.MyHandlerInterceptor2"/>
  </mvc:interceptor>
</mvc:interceptors>
  • mvc:mapping指定拦截器链接
  • mvc:exclude-mapping设置不过滤的链接
  • 上边拦截器设置的顺序就是拦截器执行的顺序

4.启动测试服务

http://localhost:8080
控制台输出

1
2
3
4
5
6
7
--------------------------MyHandlerInterceptor1.preHandle
--------------------------MyHandlerInterceptor2.preHandle
IndexController.index
--------------------------MyHandlerInterceptor2.postHandle
--------------------------MyHandlerInterceptor1.postHandle
--------------------------MyHandlerInterceptor2.afterCompletion
--------------------------MyHandlerInterceptor1.afterCompletion

与图1-1执行顺序一样，验证afterCompletion是否在页面加载完后执行可以在该回调方法内设置断点，然后查看页面。
想要查看中断流程效果可以将MyHandlerInterceptor1或MyHandlerInterceptor2的preHandle返回值设置成false查看

应用

性能监控

  1. 实现分析
    1. 在进入处理器之前记录开始时间，即在拦截器的preHandle记录开始时间;
    2. 在结束请求处理之后记录结束时间，即在afterCompletion记录结束时间，并用(结束时间-开始时间)得到这次请求的处理时间。
    3. 因为拦截器是单例，因此不管用户请求多少次都只有一个拦截器实现，即线程不安全，所以需要用到ThreadLocal，它是线程绑定的遍历，提供一个局部变量(一个线程一个ThreadLocal，A线程的ThreadLocal只能看到A线程的ThreadLocal，不能看到B线程的ThreadLocal)。
  2. 代码实现
    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
    34
    35
    36
    package com.lx.interceptor;

    import org.springframework.core.NamedThreadLocal;
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

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

    /**
     * 性能监控
     *
     * @author 段誉
     * @create 2019-03-21 13:37
     */
    public class PerformanceMonitorInterceptor extends HandlerInterceptorAdapter {
      private NamedThreadLocal<Long> startTimeThreadLocal = new NamedThreadLocal<>("Performance-Monitor-Start-Time");
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                               Object handler) throws Exception {
        //将接口请求时间绑定到当前线程
        startTimeThreadLocal.set(System.currentTimeMillis());
        return true;
      }

      @Override
      public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                  Object handler, Exception ex) throws Exception {
        //结束时间
        long endTime = System.currentTimeMillis();
        //得到线程的开始时间
        Long startTime = startTimeThreadLocal.get();
        //消耗的时间
        long consumeTime = endTime - startTime;
        System.out.println(String.format("[%s]消耗的时间为[]毫秒", request.getRequestURI(), consumeTime));
      }
    }
  • NamedThreadLocal：Spring提供的一个命名的ThreadLocal实现。
  • 在测试时需要把stopWatchHandlerInterceptor放在拦截器链的第一个，这样得到的时间才是比较准确的。

转载

参考自开涛的博客:第五章 处理器拦截器详解——跟着开涛学SpringMVC 学习编写的demo，加深了自己对aop的了解