【springmvc】拦截器Interceptor的使用与源码分析

最新推荐文章于 2024-07-27 07:18:07 发布
最新推荐文章于 2024-07-27 07:18:07 发布
阅读量6.9w 收藏 2
点赞数
分类专栏： Spring MVC 文章标签： mvc java spring springmvc interceptor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u022812849/article/details/124908307
版权

拦截器Interceptor的使用

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

package com.morris.spring.mvc.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 {

    // 目标方法运行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle" + request.getRequestURI());
        return true;
    }

    // 目标方法运行之后执行
    @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");
    }
}

配置拦截器以及要匹配的url：

com.morris.spring.mvc.config.MVCConfig#addInterceptors

// 添加拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
	registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**"); // /**拦截任意路径
	registry.addInterceptor(new LocaleChangeInterceptor()); // 不设置path就会拦截所有请求
}

源码分析

Interceptor的收集过程

RequestMappingHandlerMapping的实例化过程中，会完成所有的Interceptor的收集工作。

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#requestMappingHandlerMapping

@Bean
@SuppressWarnings("deprecation")
public RequestMappingHandlerMapping requestMappingHandlerMapping(
	@Qualifier("mvcContentNegotiationManager") ContentNegotiationManager contentNegotiationManager,
	@Qualifier("mvcConversionService") FormattingConversionService conversionService,
	@Qualifier("mvcResourceUrlProvider") ResourceUrlProvider resourceUrlProvider) {

	RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
	mapping.setOrder(0);
	// 设置拦截器
	mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));
	mapping.setContentNegotiationManager(contentNegotiationManager);
	mapping.setCorsConfigurations(getCorsConfigurations());

	PathMatchConfigurer configurer = getPathMatchConfigurer();

	Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
	if (useSuffixPatternMatch != null) {
		mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
	}
	Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
	if (useRegisteredSuffixPatternMatch != null) {
		mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
	}
	Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
	if (useTrailingSlashMatch != null) {
		mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
	}

	UrlPathHelper pathHelper = configurer.getUrlPathHelper();
	if (pathHelper != null) {
		mapping.setUrlPathHelper(pathHelper);
	}
	PathMatcher pathMatcher = configurer.getPathMatcher();
	if (pathMatcher != null) {
		mapping.setPathMatcher(pathMatcher);
	}
	Map<String, Predicate<Class<?>>> pathPrefixes = configurer.getPathPrefixes();
	if (pathPrefixes != null) {
		mapping.setPathPrefixes(pathPrefixes);
	}

	return mapping;
}

org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#getInterceptors

protected final Object[] getInterceptors(
	FormattingConversionService mvcConversionService,
	ResourceUrlProvider mvcResourceUrlProvider) {
	if (this.interceptors == null) {
		// interceptors默认为空
		InterceptorRegistry registry = new InterceptorRegistry();
		/**
			 * @see DelegatingWebMvcConfiguration#addInterceptors(org.springframework.web.servlet.config.annotation.InterceptorRegistry)
			 */
		addInterceptors(registry);
		// 添加两个默认的Interceptor
		registry.addInterceptor(new ConversionServiceExposingInterceptor(mvcConversionService));
		registry.addInterceptor(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider));
		this.interceptors = registry.getInterceptors();
	}
	return this.interceptors.toArray();
}

org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration#addInterceptors

protected void addInterceptors(InterceptorRegistry registry) {
	this.configurers.addInterceptors(registry);
}

而MVCConfig实现了WebMvcConfigurer，最终会调到MVCConfig.addInterceptors()方法将我们自定义的Interceptor加入到RequestMappingHandlerMapping的interceptors属性中。

org.springframework.web.servlet.config.annotation.InterceptorRegistration#getInterceptor

protected Object getInterceptor() {
	if (this.includePatterns.isEmpty() && this.excludePatterns.isEmpty()) {
		return this.interceptor;
	}

	String[] include = StringUtils.toStringArray(this.includePatterns);
	String[] exclude = StringUtils.toStringArray(this.excludePatterns);
	// 包装为MappedInterceptor
	MappedInterceptor mappedInterceptor = new MappedInterceptor(include, exclude, this.interceptor);
	if (this.pathMatcher != null) {
		mappedInterceptor.setPathMatcher(this.pathMatcher);
	}
	return mappedInterceptor;
}

org.springframework.web.servlet.handler.AbstractHandlerMapping#initApplicationContext

protected void initApplicationContext() throws BeansException {
	extendInterceptors(this.interceptors);
	// 从spring mvc容器中获取所有的MappedInterceptor
	// 从这里可以看出，我们可以通过向spring mvc容器中注入MappedInterceptor来实现注入Interceptor
	detectMappedInterceptors(this.adaptedInterceptors);
	// 初始化interceptor
	// 将interceptors添加到adaptedInterceptors
	initInterceptors();
}

protected void initInterceptors() {
	if (!this.interceptors.isEmpty()) {
		for (int i = 0; i < this.interceptors.size(); i++) {
			Object interceptor = this.interceptors.get(i);
			if (interceptor == null) {
				throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
			}
			this.adaptedInterceptors.add(adaptInterceptor(interceptor));
		}
	}
}

最后所有的Intercepor位于RequestMappingHandlerMapping的adaptedInterceptors属性。

Interceptor的执行过程

所有的请求都会经过DispatcherServlet的doDispatch()方法。

org.springframework.web.servlet.DispatcherServlet#doDispatch

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 {
			// 判断请求头中是否有文件，如果有会将请求包装为MultipartHttpServletRequest
			processedRequest = checkMultipart(request);
			multipartRequestParsed = (processedRequest != request);

			// Determine handler for the current request.
			// HandlerExecutionChain，获取Handler
			mappedHandler = getHandler(processedRequest);
			if (mappedHandler == null) {
				noHandlerFound(processedRequest, response);
				return;
			}

			// Determine handler adapter for the current request.
			// 获取HandlerAdapter
			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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
					return;
				}
			}

			// 调用拦截器的HandlerInterceptor.preHandle()
			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
				return;
			}

			// Actually invoke the handler.
			/**
				 * @see AbstractHandlerMethodAdapter#handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Object)
				 */
			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

			applyDefaultViewName(processedRequest, mv);
			// 调用拦截器的HandlerInterceptor.postHandle()
			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);
		}
		// 进行异常处理
		// 视图渲染
		// 调用拦截器的HandlerInterceptor.afterCompletion()
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	}
	catch (Exception ex) {
		// 调用拦截器的HandlerInterceptor.afterCompletion()
		triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
	}
	catch (Throwable err) {
		// 调用拦截器的HandlerInterceptor.afterCompletion()
		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);
			}
		}
	}
}

将handler与interceptors封装为HandlerExecutionChain。

org.springframework.web.servlet.handler.AbstractHandlerMapping#getHandlerExecutionChain

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
	HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
								   (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

	// 获取url
	String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
	for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
		if (interceptor instanceof MappedInterceptor) {
			MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
			// 将url与interceptor配置的url进行匹配
			if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
				// 能匹配上的interceptor加入到HandlerExecutionChain中
				chain.addInterceptor(mappedInterceptor.getInterceptor());
			}
		}
		else {
			// 直接向容器中注入的MappedInterceptor
			// 没配置path的直接加入到HandlerExecutionChain中
			chain.addInterceptor(interceptor);
		}
	}
	return chain;
}

在handler执行之前HandlerInterceptor.interceptor：

org.springframework.web.servlet.HandlerExecutionChain#applyPreHandle

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];
			// 调用HandlerInterceptor.preHandle
			if (!interceptor.preHandle(request, response, this.handler)) {
				// 调用HandlerInterceptor.afterCompletion
				triggerAfterCompletion(request, response, null);
				return false;
			}
			this.interceptorIndex = i;
		}
	}
	return true;
}

这里要注意的是调用了HandlerInterceptor的preHandle()方法就一定会调用HandlerInterceptor的afterCompletion()，假如目前有A、B、C三个Interceptor，执行了A和B的preHandle()，在执行C的preHandle()方法时返回false，那么还是执行A和B的afterCompletion()，而且是先执行B.afterCompletion()，再执行A.afterCompletion()。

在handler执行之后，视图解析之前执行HandlerInterceptor.postHandle：

org.springframework.web.servlet.HandlerExecutionChain#applyPostHandle

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
	throws Exception {

	HandlerInterceptor[] interceptors = getInterceptors();
	if (!ObjectUtils.isEmpty(interceptors)) {
		// i在这里是从大到小，也就是按interceptors的逆序执行
		for (int i = interceptors.length - 1; i >= 0; i--) {
			HandlerInterceptor interceptor = interceptors[i];
			// 调用HandlerInterceptor.postHandle
			interceptor.postHandle(request, response, this.handler, mv);
		}
	}
}

在视图渲染之后执行HandlerInterceptor.afterCompletion：

org.springframework.web.servlet.HandlerExecutionChain#triggerAfterCompletion

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)
	throws Exception {

	HandlerInterceptor[] interceptors = getInterceptors();
	if (!ObjectUtils.isEmpty(interceptors)) {
		// i在这里是从大到小，也就是按interceptors的逆序执行
		for (int i = this.interceptorIndex; i >= 0; i--) {
			HandlerInterceptor interceptor = interceptors[i];
			try {
				// 调用HandlerInterceptor.afterCompletion
				interceptor.afterCompletion(request, response, this.handler, ex);
			}
			catch (Throwable ex2) {
				logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
			}
		}
	}
}
morris131
关注
专栏目录
spring boot加入拦截器Interceptor过程解析
08-25
主要介绍了spring boot加入拦截器Interceptor过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring 知识面面通 之 MappedInterceptor HandlerInterceptor的实现真谛
键盘上流淌的日子
12-15 1666
  应用Spring的HandlerInterceptor处理器拦截器时，首先需要自定义类，其实现HandlerInterceptor接口，然后配置已定义的HandlerInterceptor实现类，最后就可以享受拦截器带来的便利。   表面上，HandlerInterceptor是实现的关键。但实际上，内部实现时，MappedInterceptor是拦截器实现的精髓，其对HandlerInterceptor实现类进行了封装，Spring流程操作通过MappedInterceptor间接地与HandlerI
SpringMvc之精细化拦截MappedInterceptor
最新发布
欢谷悠扬
07-27 315
是 Spring MVC 提供的一种机制，用于在请求处理流程中拦截特定路径的请求。与常规的不同，提供了更灵活的路径匹配功能，使得开发者可以更精细地控制拦截器的应用范围。当你添加了之后，在注册拦截器时，SpringMvc会将你写的拦截器包装成!拦截器链是定制化的，是根据每次请求去定制化的。全局拦截器与精细化拦截器的主要区别在于是否添加了路径匹配。
[Java安全]—Interceptor内存马
Sentiment的博客
11-03 437
Interceptor内存马
Spring MVC源码解析 - MappedInterceptor
The Secret
01-09 1644
一. MappedInterceptor /** * * 带有路径模式匹配的HandlerInterceptor,也提供了匹配逻辑来测试拦截器是否适用于一个给定的请求路径 * * <p>A MappedInterceptor can be registered directly with any * {@link org.springframework.web.se...
【Spring MVC】Spring MVC拦截器（Interceptor）
小七的博客
03-18 2098
本文将带你详细了解Spring MVC拦截器的执行顺序、底层原理以及生产应用。
详解SpringMVC中使用Interceptor拦截器
08-31
通过以上内容，我们可以了解到SpringMVC中的Interceptor拦截器如何工作，以及如何利用它来扩展和优化我们的Web应用程序。合理使用Interceptor，可以使代码结构更加清晰，提高系统的可维护性和可扩展性。
SpringMVC中使用Interceptor拦截器
08-06
本篇文章将深入探讨如何在Spring MVC中使用Interceptor拦截器。 首先，Interceptor的实现需要继承自`HandlerInterceptor`接口或者实现`HandlerInterceptorAdapter`适配器类，这两个类都包含三个核心方法： 1. `...
详解SpringMVC拦截器配置及使用方法
08-29
综上所述，SpringMVC拦截器提供了一种灵活的方式来在请求处理前后添加自定义的处理逻辑，通过拦截器的配置与实现，开发者可以对Web应用进行多维度的控制和扩展。在实际开发中，根据业务需求选择合适的拦截时机和逻辑...
springmvc 拦截器
05-08
在其中，可以创建一个或多个`<mvc:interceptor>`子元素，每个子元素代表一个拦截器。需要指定拦截哪些请求路径，以及对应的拦截器类。 6. **自定义拦截器** 自定义拦截器需要实现Spring MVC提供的...
SpringMvc 拦截器
04-16
Spring MVC的拦截器基于Servlet API的Filter和HandlerInterceptor接口，但相比Filter，Interceptor更关注于业务逻辑，更易于与Spring MVC的其他组件集成。 接下来，我们来创建一个简单的自定义拦截器。首先，我们...
SpringMVC源码解读 --- 处理器映射器(HandlerMapping) 各种处理器映射器的使用及其源码分析
Feverasa的博客
08-02 821
这一篇我们来梳理下SpringMVC中关于HandlerMapping、HandlerAdapter、ViewResolver这些接口及其实现类。 首先简单来看下DispatcherServlet对于请求的简单执行流程，了解下大概(关于这个过程的具体细节到时候在看还需不需要来一下具体细节),实现是根据request获取HandlerExecutionChain（其包含根据映射获取到的对应方法或者类handler(Object)通过对应的HandlerMapping【这里先不花一些语言去描叙...
SpringMVC系列-3 拦截器
Sheng_Q的博客
06-24 2952
}HandlerInterceptor中的声明的preHandle/postHandle/afterCompletion为default类型的接口，可以随意选择是否实现。preHandle接口若返回false, 会跳过Controller方法的执行，流程可参考SpringMVC系列-2 HTTP请求调用链。
SpringMVC源码解析---Interceptor拦截器实现原理
gongsenlin341的博客
11-01 1294
文章目录1.概述2.拦截器的实现3.拦截器的配置4.源码分析 1.概述 在上一章节中介绍了SpringMVC的主要核心流程，本章的重点聚焦到其中的一个组件拦截器的介绍。从拦截器的使用方式到拦截器的实现原理详细的说明。 2.拦截器的实现 拦截器有两种实现方式 第一种方式是Interceptor类要实现了Spring的HandlerInterceptor接口 第二种方式是继承已经实现了HandlerInterceptor接口的类，例如继承HandlerInterceptor接口的抽象类HandlerInter
Spring MVC拦截器的原理
Mr_chen的博客
04-16 641
????摘要 今天分享下 —— Spring MVC 拦截器的原理 的一些基本知识，欢迎关注！ 拦截器是每个 Web 框架必备的功能，也是个老生常谈的主题了，这里来分析 SpringMVC 的拦截器功能是如何设计的，让你了解该功能设计的原理 ????分享 ????重要接口及类介绍 HandlerExecutionChain 类 由 HandlerMethod 和 Interceptor 集合组成的...
Spring MVC 系列之拦截器 Interceptor 最全总结
热门推荐
大鹏的博客
11-11 1万+
拦截器 Interceptor 在 Spring MVC 中的地位等同于 Servlet 规范中的过滤器 Filter，拦截的是处理器的执行，由于是全局行为，因此常用于做一些通用的功能，如请求日志打印、权限控制等。
【Spring MVC源码解析】（三）HandlerMapping
Wonder ZH
05-11 412
HandlerMapping家族成员可以分为两支，一支继承自AbastractUrlHandlerMapping，另一支继承自AbastracHandlerMethodMapping，两只都继承自AbastractHandlerMapping。 绿框AbstractHandlerMapping抽象类，实现了【获得请求对应的处理器和拦截器们】的骨架逻辑，然后提供getHandlerInternal(HttpServletRequest request)模板方法，交由子类实现。 AbstractH...
Spring 知识面面通 之 HandlerMethodArgumentResolver方法参数解析器
键盘上流淌的日子
11-26 898
  HandlerMethodArgumentResolver是一个策略接口，用于在给定请求上下文中解析方法参数。平时开发中使用的频次比较高，@CookieValue、@RequestBody、@PathVariable、@RequestParam等等这些注解都是基于这个策略接口来完成参数解析的。   HandlerMethodArgumentResolver API定义 package org.springframework.web.method.support; import org.springfr
SpringMVC拦截器：自定义异常处理与配置
SpringMVC拦截器是Spring框架提供的一种强大的功能，它允许开发者在控制器（Controller）处理请求之前或之后执行特定的操作，从而增强了应用的灵活性和控制性。拦截器的作用类似于传统Web开发中的Filter，但它是基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

morris131

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值