拦截器简介

什么是拦截器

Spring中的拦截器(Interceptor) ，用于拦截控制器方法的执行，可以在方法执行前后，添加自定义逻辑，类似于AOP编程思想。

实际应用中，可以使用拦截器实现，认证授权、日志记录、字符编码转换，敏感词过滤等等。

和过滤器有什么区别

过滤器也能实现拦截功能，具体和拦截器有什么不同呢

1. 触发机制

过滤器Filter是在请求进入容器后，但在进入servlet之前进行预处理，请求结束是在servlet处理完以后。

拦截器 Interceptor 是在请求进入servlet后，在进入Controller之前进行预处理的，Controller 中渲染了对应的视图之后请求结束。
在这里插入图片描述

2. 实现原理

过滤器和拦截器底层实现方式大不相同，过滤器是基于函数回调的，拦截器则是基于Java的反射机制（动态代理）实现的。

3. 使用范围

过滤器实现的是 javax.servlet.Filter 接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter 的使用要依赖于Tomcat等容器，导致它只能在web程序中使用。

拦截器(Interceptor) 它是一个Spring组件，并由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中。

4. 拦截的请求范围

过滤器几乎可以对所有进入容器的请求起作用。

拦截器只会对Controller中请求或访问static目录下的资源请求起作用。

核心类

HandlerInterceptor接口

Spring MVC提供了HandlerInterceptor接口来实现拦截器功能，我们可以实现这个接口，然后注册拦截器，以添加常见的预处理行为，而无需修改每个控制器方法。

HandlerInterceptor定义了三个方法，可在控制器方法执行前后添加自定义逻辑。

public interface HandlerInterceptor {
	/**
	 * 在 HandlerMapping 确定合适的处理程序对象之后，但在 HandlerAdapter 调用处理程序之前调用
	 */
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}
	/**
	 * 拦截处理程序的执行。在 HandlerAdapter 实际上调用处理程序之后调用，但在 DispatcherServlet 呈现视图之前调用
	 */
	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 {
	}
}

AsyncHandlerInterceptor

AsyncHandlerInterceptor异步处理程序拦截器，继承自HandlerInterceptor接口，主要是扩展了一个afterConcurrentHandlingStarted方法。

	/**
	*处理程序被并发执行时，代替 {@code postHandle} 和 {@code 		  afterCompletion} 被调用。
 	* 实现可以使用提供的请求和响应，但应该 
	* 避免以与并发处理程序执行冲突的方式修改它们。这种方法的典型用途是清理线程局部变量。
	*/
	default void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
			Object handler) throws Exception {
	}

WebRequestInterceptor

WebRequestInterceptor也是拦截器接口，不过它拦截方法传入的参数是WebRequest。

WebRequest是Spring定义的接口，它是对HttpServletRequest的封装。对WebRequest 进行的操作都将同步到HttpServletRequest 中。

public interface WebRequestInterceptor {
	// 拦截请求处理程序，在其调用之前的执行。允许准备上下文资源（例如 Hibernate Session）并将它们公开为请求属性或线程本地对象
	void preHandle(WebRequest request) throws Exception;
	// 拦截请求处理程序的执行成功调用之后，就在视图呈现之前（如果有的话）。允许在成功的处理程序执行后修改上下文资源（例如，刷新休眠Session）。
	void postHandle(WebRequest request, @Nullable ModelMap model) throws Exception;
	// 请求处理完成后的回调，即渲染视图后。将在处理程序执行的任何结果上调用，从而允许进行适当的资源清理。 
	void afterCompletion(WebRequest request, @Nullable Exception ex) throws Exception;

}

InterceptorRegistration

InterceptorRegistration类，用来协助拦截器进行注册登记，可以为每个拦截器配置匹配路径、包含路径等。

它的属性如下：

	// 注册的拦截器
	private final HandlerInterceptor interceptor;
	// 包含路径
	@Nullable
	private List<String> includePatterns;
	// 排除路径
	@Nullable
	private List<String> excludePatterns;
	// 匹配器
	@Nullable
	private PathMatcher pathMatcher;
	// 顺序
	private int order = 0;

InterceptorRegistry

InterceptorRegistry翻译过来是拦截器注册表，它的主要作用是维护了应用程序所有的拦截器列表。

public class InterceptorRegistry {
	// 拦截器注册集合
	private final List<InterceptorRegistration> registrations = new ArrayList<>();
	// 添加Handler拦截器，
	public InterceptorRegistration addInterceptor(HandlerInterceptor interceptor) {
		InterceptorRegistration registration = new InterceptorRegistration(interceptor);
		this.registrations.add(registration);
		return registration;
	}
	// 添加WebRequestInterceptor 拦截器
	public InterceptorRegistration addWebRequestInterceptor(WebRequestInterceptor interceptor) {
		WebRequestHandlerInterceptorAdapter adapted = new WebRequestHandlerInterceptorAdapter(interceptor);
		InterceptorRegistration registration = new InterceptorRegistration(adapted);
		this.registrations.add(registration);
		return registration;
	}
}

自定义拦截器案例

1. 准备工作

添加一个用户对象，封装用户信息、权限值等。

@Data
public class User {
    String username;
    String password;
    Integer age;
    String name;
    Long userId;
    String permissionCode;
}

编写一个登陆接口，模拟登陆，将用户信息保存到Session 中。

    @GetMapping("/user/login")
    public Object login(HttpSession httpSession) {
        User user = new User();
        user.setName("吃个桃桃");
        user.setAge(15);
        user.setUserId(1111L);
        user.setPermissionCode("add:user");
        httpSession.setAttribute("user", user);
        return user;
    }

2. 编写拦截器

自定义拦截器，实现HandlerInterceptor 接口，模拟访问时，对用户是否登陆，是否具有权限访问进行校验。

public class MvcPermissionInterceptor implements HandlerInterceptor {

    /**
     * 前置处理
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 可以通过handler获取执行方法的相关信息, 方法名，注解等。
        // 1. 放行路径，直接放行，或者在注册时使用excludePathPatterns排除
        String requestURI = request.getRequestURI();
        if ("test".equals(requestURI)) {
            System.out.println(requestURI + "放行！！！");
            return true;
        }
        Map<String, Object> result = new HashMap<>();
        // 2. 判断用户是有已登录
        User user = (User) request.getSession().getAttribute("user");
        if (user == null) {
            printMsg(result, response, HttpStatus.UNAUTHORIZED.value(), 401, "未登录！！！");
            return false;

        }
        // 3. 检查用户权限
        String permissionCode = user.getPermissionCode();
        if (!"add:user".equals(permissionCode)) {
            printMsg(result, response, HttpStatus.FORBIDDEN.value(), 403, "没权限");
            return false;
        }
        System.out.println("已登录，并拥有权限");
        return true;
    }

    /**
     * 响应错误信息
     */
    private void printMsg(Map<String, Object> result, HttpServletResponse response, int statusCode, int code, String msg) throws IOException {
        response.setStatus(statusCode);
        response.setContentType("application/json; charset=UTF-8");
        result.put("code", code);
        result.put("msg", msg);
        ObjectMapper mapper = new ObjectMapper();
        mapper.writeValue(response.getOutputStream(), result);
        response.setHeader("Cache-Control", "No-Cache");
        response.flushBuffer();
    }

    /**
     * 后置处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    /**
     * 完成处理
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

3. 注册拦截器

在WebMvcConfigurer配置类中，重写addInterceptors方法，添加拦截器，并配置匹配路径。

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MvcPermissionInterceptor()).addPathPatterns("/**").excludePathPatterns("/v1/user/login");
    }
}

4. 测试

直接访问接口，返回未登录信息。
在这里插入图片描述
使用登录接口登录，然后再访问资源接口，发现能正常访问，并打印了拦截器相关执行日志。
在这里插入图片描述

执行流程源码分析

首先看下大致流程，可以看到拦截器是在DispatcherServlet中进行执行的，所以将断点打在DispatcherServlet的doDispatch方法中。
在这里插入图片描述

1. 获取拦截器

doDispatch方法中会调用getHandler去获取当前请求的拦截器，所有的拦截器都在HandlerExecutionChain类中。
在这里插入图片描述

2. 调用前置方法

HandlerExecutionChain处理器执行链，接着会调用拦截器的前置方法，当返回false时，请求直接return了。

if (!mappedHandler.applyPreHandle(processedRequest, response)) {
    return;
}

applyPreHandle会循环拦截器。

    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  	  // 循环拦截器
        for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
            HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
            // 执行每个拦截器
            if (!interceptor.preHandle(request, response, this.handler)) {
            // 拦截器返回false时，调用已执行完毕拦截器的afterCompletion方法
                this.triggerAfterCompletion(request, response, (Exception)null);
                return false;
            }
        }
        return true;
    }

3. 后置方法

所有拦截器执行完毕，且都返回ture后，处理器方法开始执行（controller方法）。

处理器方法执行完毕后，开始调用applyPostHandle执行控制器后置方法。

   mappedHandler.applyPostHandle(processedRequest, response, mv);

applyPostHandle很简单，就是循环拦截器，执行其postHandle方法。

    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
        for(int i = this.interceptorList.size() - 1; i >= 0; --i) {
            HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
            interceptor.postHandle(request, response, this.handler, mv);
        }

    }

执行完成方法

后置方法执行完毕后，DispatcherServlet进入到processDispatchResult方法，最终会调用HandlerExecutionChain的triggerAfterCompletion循环执行拦截器的完成方法。
在这里插入图片描述

到此，整个拦截器就执行完毕了。

多个拦截器执行顺序

再添加一个拦截器，然后发现其执行顺序好像有点乱。
在这里插入图片描述

1. 当拦截器都通过时

若每个拦截器的preHandle()都返回true时：

  • 此时多个拦截器的执行顺序和拦截器在SpringMVC的配置文件的配置顺序有关
  • preHandle()会按照配置的顺序执行；
  • postHandle()和afterComplation()会按照配置的反序执行

2. 当某个拦截器返回false时

若某个拦截器的preHandle()返回了false时：

  • preHandle()返回false和它之前的拦截器的preHandle()都会执行，postHandle()都不执行，返回false的拦截器之前的拦截器的afterComplation()会执行
# spring # mvc # java
Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生