SpringMVC拦截器源码解析

最新推荐文章于 2023-01-31 08:50:05 发布
最新推荐文章于 2023-01-31 08:50:05 发布
阅读量1.6k 收藏 11
点赞数 4
分类专栏： Springmvc 源码分析 文章标签： SpringMVC 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamcatcher1314/article/details/80956074
版权

 前言：提到拦截器，我们一定会想到Spring Aop。在看SpringMVC源码以前，一直以为SpringMVC的拦截器是用Spring Aop的动态代理来实现，并且也很困惑，如果用动态代理如何实现拦截器？这里就不介绍Spring Aop实现拦截器的方式，剖析SpringMVC 拦截器实现的细节。

    SpringMVC拦截器也是Aop(面向切面)思想构建，但不是SpringAop动态代理实现的，主要采用责任链和适配器的设计模式来实现，直接嵌入到SpringMVC入口代码里面。

    涉及到设计模式，有利于对代码的理解

        责任链模式：https://segmentfault.com/a/1190000012079496

        适配器模式：https://www.cnblogs.com/V1haoge/p/6479118.html

一、拦截器的接口类结构

拦截器的顶级接口为HandleInterceptor，提供三个接口，分别是preHandle（请求前）、postHandle（请求提交）、afterCompletion（请求完成后拦截）

package org.springframework.web.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.method.HandlerMethod;
/**
*  拦截器顶级接口
*/
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;

}

而我们通常使用的是HandlerInterceptorAdapter（拦截器适配器），运用接口适配器模式。在实际运用中，接口中可以定义了很多方法，子类可能实现几个方法，接口适配器模式就起到了作用。

package org.springframework.web.servlet.handler;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
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, ModelAndView modelAndView)
			throws Exception {
	}
	@Override
	public void afterCompletion(
			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
	}
	/**
	 * This implementation is empty.
     * 来自实现AsyncHandlerInterceptor 的方法
	 */
	@Override
	public void afterConcurrentHandlingStarted(
			HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	}

}

二、拦截器源码运行的调用流程

    1. HandlerMapping初始化

了解到SpringMVC拦截器接口HandlerInterceptorAdapter，我们再进入SpringMVC请求入口org.springframework.web.servlet.DispatcherServlet，拦截器运作工作流程由此展开。DispatcherServlet作为控制中心，拦截器就嵌入在入口方法中doDispatch中。SpringMVC又是如何将定义的拦截器加入进去呢？


	/**
	 * 完成Servlet一系列初始化工作，包括视图解析器、处理器映射器、处理器适配器、主题解析器...
	 */
	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
        // 初始化RequestMapping，拦截器是作用在RequestMapping
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
	}

 

初始化RequestMapping的时候，获取到RequestMapping的集合，因为拦截器作用在单个RequestMapping，来实现拦截器链。这里就不详细介绍RequestMapping的获取。

    2. DispatcherServlet执行调用，doService作为Servlet主要执行者，通过调用doDispatch来真正执行请求处理

在initStrategies(ApplicationContext context)完成初始化准备工作后，来正式进入DispatcherServlet请求进入的处理过程。DispatcherServlet基于Servlet开发，它的执行方式是 doService(HttpServletRequest request, HttpServletResponse response) 

   /**
    *  doService做了一部分请求准备预处理的工作， 而实际处理的工作调用doDispatch(request, response)
    */
	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isDebugEnabled()) {
			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
					" processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
		}

		// 对请求属性快照的保持和存储后的使用,
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<String, Object>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}

		//对SpringMVC框架中处理器Handle和视图渲染，提前做准备工作
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
        // FlashMap是对重定向的参数传递的处理
		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
		request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

		try {
           //***请求的实际处理逻辑***-----进入方法
			doDispatch(request, response);
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

    3. doDispatch中完成拦截器的添加和拦截器拦截处理

 doService做了一部分请求准备预处理的工作，包括请求中设置处理器和视图的属性，作用于后续处理器的运作和视图渲染， 而实际请求逻辑处理的工作调用doDispatch(request, response)，也是我们需要重点跟进的代码。或许大家初次看doDispatch方法中的代码，还不知道拦截器在哪里运作。

处理流程是：

  1.     通过getHandler(HttpServletRequest request)获取到HandlerExecutionChain处理器执行链，将拦截器注入到HandlerExecutionChain属性
  2.   分别调用HandlerExecutionChain的三个方法，applyPreHandle、applyPostHandle、triggerAfterCompletion，实现前置拦截/请求提交拦截和请求完成后拦截。使用责任链的设计模式，实际调用的是HandleInterceptor的三个接口，分别对应preHandle、postHandle、afterCompletion
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		try {
			ModelAndView mv = null;
			Exception dispatchException = null;
			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);
				//***获取到请求执行链，拦截器的添加在里面完成***---进入方法
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
				// 获取到相应处理器适配器
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
                //1.请求前拦截处理---进入方法细看（责任链模式，调用拦截器链的执行）
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
                //2.请求提交的拦截处理---进入方法细看（责任链模式，调用拦截器链的执行）
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
            // 3.请求结果视图渲染完成后，调用mappedHandler.triggerAfterCompletion（），实现请求完成后拦截
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

 

三、结合责任链设计在拦截器中的运用

    责任链模式的定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系， 将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。

分析 1、如何将拦截器添加到HandlerExecutionChain中

    首先遍历HandlerMappings集合，HandlerMappings是在initHandlerMappings(context)初始化得到。根据request查找到相应 HandlerMapping的HandlerExecutionChain。

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //遍历处理器映射器集合，找到相应请求的处理器映射器
		for (HandlerMapping hm : this.handlerMappings) {
			if (logger.isTraceEnabled()) {
				logger.trace(
						"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
			}
            //***请求匹配到映射器，并返回HandlerExecutionChain***---进入方法细看
            //----拦截器的添加在方法里面完成
			HandlerExecutionChain handler = hm.getHandler(request);
			if (handler != null) {
				return handler;
			}
		}
		return null;
	}
@Override
	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		Object handler = getHandlerInternal(request);
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = getApplicationContext().getBean(handlerName);
		}
        //***获取HandlerExecutionChain，拦截器的添加 ***---进一步跟进代码
		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
		if (CorsUtils.isCorsRequest(request)) {
			CorsConfiguration globalConfig = this.globalCorsConfigSource.getCorsConfiguration(request);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}
		return executionChain;
	}
/**
 * 走到这里，才真正看到了HandlerExecutionChain的创建和拦截器的添加
 */
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        //获取到HandlerExecutionChain 
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
        //遍历拦截器，adaptedInterceptors也是在initHandlerMapping初始化得到
		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                    //将拦截器添加
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

分析2、如何执行多个拦截器，通过责任链模式

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}

/**
	 * Apply postHandle methods of registered interceptors.
	 */
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}
/**
	 * Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
	 * Will just invoke afterCompletion for all interceptors whose preHandle invocation
	 * has successfully completed and returned true.
	 */
	void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
			throws Exception {

		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = this.interceptorIndex; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				try {
					interceptor.afterCompletion(request, response, this.handler, ex);
				}
				catch (Throwable ex2) {
					logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
				}
			}
		}
	}
架构源启
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springmvc 拦截器
05-08
springmvc 拦截器
SpringMVC执行流程简介
qq_45174642的博客
08-13 350
1、执行详细流程： 用户向服务器发送请求，请求被SpringMVC 前端控制器 DispatcherServlet捕获。 DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI），判断请求URI对应的映射： a) 不存在 i. 再判断是否配置了mvc:default-servlet-handler ii. 如果没配置，则控制台报映射查找不到，客户端展示404错误 iii. 如果有配置...
SpringBoot拦截器及源码分析
秃头哥编程
07-11 1297
1、拦截器是什么 java里的拦截器（Interceptor）是动态拦截Action调用的对象，它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问之前进行拦截，然后再之前或者之后加入某些操作。 上面的Action一般指的就是我们Controller层的接口。 2、自定义拦截器 一般自定义一个拦截器分为三步 （1）编写一个拦截器实现Handle
拦截器及源码分析
code_java_zqy
03-04 638
文章目录拦截器配置文件中注册并配置自定义拦截器Filter和拦截器的使用时机：拦截器运行原理：源码分析 拦截器 Spring MVC也可以使用拦截器对请求进行拦截处理，用户可以自定义拦截器来实现特定的功能，自定义的拦截器必须实现HandlerInterceptor接口 preHandle()：这个方法在业务处理器处理请求之前被调用，在该方法中对用户请求 request 进行处理。如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回true；如果程序员决定不需要
Java：SpringMVC拦截器
chenyouchang的博客
01-08 1083
SpringMVC的拦截器配置
springmvc拦截器及源码分析
Blue92120的博客
01-31 302
拦截器常用于初始化资源，权限监控，会话设置，资源清理等的功能设置，就需要我们对它的执行顺序完全掌握，我们通过源码可以看到，拦截器类似于对我们业务方法的环绕通知效果，并且是通过循环收集好的拦截器集合来控制每个拦截器方法的执行顺序，进而可以真正做到深入掌握拦截器的执行机制！在doDispatch方法中，我们添加的注释的第【3】、【5】、【6】步骤是对拦截器的执行处理，现在分别来查看第【3】、【5】、【6】步骤执行的具体方法的源码。由此可以看到，拦截器的最终方法的执行也是按照倒叙来执行的，而且是在响应之后。
SpringMVC拦截器配置及运行流程解析
08-19
主要介绍了SpringMVC拦截器配置及运行流程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringMVC拦截器源码.rar
07-06
springmvc配置以及拦截器配置。。
SpringMvc 拦截器
04-16
SpringMvc 拦截器 原理清楚，代码简单，值得学习！
springMVC 详细版本 拦截器源码
03-01
springMVC 拦截器源代码 内有详细文档介绍操作 @Override public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception { //可以通过...
springMVC3学习(七)--Interceptor拦截器(源码)
05-19
springMVC3学习(七)--Interceptor拦截器(源码) 文章地址：http://blog.csdn.net/itmyhome1990/article/details/26286107
SpringMVC DispatcherServlet重写、自定义拦截器拦截器源码
06-09
SpringMVC DispatcherServlet重写、自定义拦截器拦截器源码
【Spring Boot 源码研究 】- 请求处理流程机制分析
热门推荐
Mirson - 多一些分享, 多一些进步
07-10 2万+
之前我们对Spring Boot做了研究讲解，我们知道怎么去集成配置， 知道它如何启动， 如何实现自动化配置，那么它如何接收并处理外部请求， 具体原理是怎样， 又要流转哪些关键环节？ filter，interceptor， view是在哪调用， 处理顺序是怎样？Spring Boot 和Spring MVC以及内置容器又是怎样的作用关系？ 这里我们作具体剖析研究。......
springboot源码分析(五)拦截器源码分析
weixin_42673583的博客
01-20 563
/** * 登录检查 * 1.配置好拦截器拦截哪些请求 * 2.把这些配置放在容器中 */ @Slf4j public class Logininterceptor implements HandlerInterceptor { /** * 目标方法执行之前 * @param request * @param response * @param handler * @return * @throws Exception *
HandlerExecutionChain和拦截器
weixin_43981133的博客
09-25 2797
在上一节中，您了解了Spring提供的不同处理程序映射。处理程序映射例如基于请求URL确定用户已发出请求的执行路径。找到适当的映射后，处理程序映射将返回所谓的HandlerExecutionChain，该指令指示调度程序Servlet如何进行。 HandlerExecutionChain由拦截器和一个处理程序（or controller）组成，一起提供访问业务逻辑和其他支持服务（如身份验证，日志记录和筛选）所需的全部内容。 HandlerExecutionChain始终包含处理请求的处理程序（换句话说，执行
010-Spring MVC 拦截器及其源码解析
这个需求，做不了
11-01 364
HandlerInterceptor Spring MVC 中拦截器的顶层接口如下： package org.springframework.web.servlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.springframework.lang.Nullable; public interface HandlerInterceptor
Spring MVC 拦截器 interceptor（实现 HandlerInterceptor 接口）
Java_c#
01-11 1361
一、拦截器（interceptor）的作用 SpringMVC的拦截器类似于Servlet 开发中的过滤器 Filter 二、拦截器和过滤器区别 JavaWeb三大组件（Servlet、Filter、Listener）
Spring Boot拦截器示例及源码原理分析
icarusliu的专栏
12-18 8835
Spring Boot拦截器示例及源码原理分析
拦截器与源码解析
qq_3316359388的博客
11-09 269
过滤器filter属于servlet，拦截器intercept属于SpringMVC 声明拦截器对象 修改代码： 增加数据，修改视图 多个拦截器 编写好拦截器后，注册拦截器 拦截器， 源码： 处理器适配器： 得到适配器之后，处理方法之前，执行拦截器preHandler 适配器调用处理器执行处理器方法 处理结果 ...
springmvc拦截器源码
最新发布
08-17
以下是一个简单的示例代码，展示了 Spring MVC 中编写拦截器的源码： ```java public class MyInterceptor implements HandlerInterceptor { // 在请求处理之前调用 @Override public boolean preHandle...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

架构源启

飞跃无限 成就未来

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值