精盡Spring MVC原始碼分析 - HandlerMapping 組件（二）之 HandlerInterceptor 攔截器-有解無憂

該系列檔案是本人在學習 Spring MVC 的原始碼程序中總結下來的，可能對讀者不太友好，請結合我的原始碼注釋 Spring MVC 原始碼分析 GitHub 地址進行閱讀

Spring 版本：5.2.4.RELEASE

該系列其他檔案請查看：《精盡 Spring MVC 原始碼分析 - 文章導讀》

HandlerMapping 組件

HandlerMapping 組件，請求的處理器匹配器，負責為請求找到合適的 HandlerExecutionChain 處理器執行鏈，包含處理器（handler）和攔截器們（interceptors）

handler 處理器是 Object 型別，可以將其理解成 HandlerMethod 物件（例如我們使用最多的 @RequestMapping 注解所標注的方法會決議成該物件），包含了方法的所有資訊，通過該物件能夠執行該方法
HandlerInterceptor 攔截器對處理請求進行增強處理，可用于在執行方法前、成功執行方法后、處理完成后進行一些邏輯處理

由于 HandlerMapping 組件涉及到的內容比較多，考慮到內容的排版，所以將這部分內容拆分成了四個模塊，依次進行分析：

《HandlerMapping 組件（一）之 AbstractHandlerMapping》
《HandlerMapping 組件（二）之 HandlerInterceptor 攔截器》
《HandlerMapping 組件（三）之 AbstractHandlerMethodMapping》
《HandlerMapping 組件（四）之 AbstractUrlHandlerMapping》

HandlerMapping 組件（二）之 HandlerInterceptor 攔截器

在上一篇《HandlerMapping 組件（一）之 AbstractHandlerMapping》檔案中分析了 HandlerMapping 組件的 AbstractHandlerMapping 抽象類，在獲取HandlerExecutionChain 處理器執行鏈時，會去尋找匹配的 HandlerInterceptor 攔截器們，并添加到其中，那么本文將分享 Spring MVC 的攔截器相關內容

HandlerInterceptor

org.springframework.web.servlet.HandlerInterceptor，處理器攔截器介面，代碼如下：

public interface HandlerInterceptor {
	/**
	 * 前置處理，在 {@link HandlerAdapter#handle(HttpServletRequest, HttpServletResponse, Object)} 執行之前
	 */
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}

	/**
	 * 后置處理，在 {@link HandlerAdapter#handle(HttpServletRequest, HttpServletResponse, Object)} 執行成功之后
	 */
	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	/**
	 * 完成處理，在 {@link HandlerAdapter#handle(HttpServletRequest, HttpServletResponse, Object)} 執行之后（無論成功還是失敗）
	 * 條件：執行 {@link #preHandle(HttpServletRequest, HttpServletResponse, Object)} 成功的攔截器才會執行該方法
	 */
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}
}

HandlerExecutionChain

org.springframework.web.servlet.HandlerExecutionChain，處理器執行鏈，也就是通過 HandlerMapping 組件為請求找到的處理物件，包含處理器（handler）和攔截器們（interceptors）

構造方法

public class HandlerExecutionChain {
	/**
	 * 處理器
	 */
	private final Object handler;

	/**
	 * 攔截器陣列
	 */
	@Nullable
	private HandlerInterceptor[] interceptors;

	/**
	 * 攔截器陣列，
	 *
	 * 在實際使用時，會呼叫 {@link #getInterceptors()} 方法，初始化到 {@link #interceptors} 中
	 */
	@Nullable
	private List<HandlerInterceptor> interceptorList;

	/**
	 * 已成功執行 {@link HandlerInterceptor#preHandle(HttpServletRequest, HttpServletResponse, Object)} 的位置
	 *
	 * 在 {@link #applyPostHandle} 和 {@link #triggerAfterCompletion} 方法中需要用到，用于倒序執行攔截器的方法
	 */
	private int interceptorIndex = -1;

	public HandlerExecutionChain(Object handler) {
		this(handler, (HandlerInterceptor[]) null);
	}

	public HandlerExecutionChain(Object handler, @Nullable HandlerInterceptor... interceptors) {
		if (handler instanceof HandlerExecutionChain) {
			HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;
			this.handler = originalChain.getHandler();
			this.interceptorList = new ArrayList<>();
			// 將原始的 HandlerExecutionChain 的 interceptors 復制到 this.interceptorList 中
			CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);
			// 將入參的 interceptors 合并到 this.interceptorList 中
			CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);
		} else {
			this.handler = handler;
			this.interceptors = interceptors;
		}
	}
}

handler：請求對應的處理器物件，可以先理解為 HandlerMethod 物件（例如我們常用的 @RequestMapping 注解對應的方法會決議成該物件），也就是我們的某個 Method 的所有資訊，可以被執行
interceptors：請求匹配的攔截器陣列
interceptorList：請求匹配的攔截器集合，至于為什么要該屬性，我還沒看明白??
interceptorIndex：記錄已成功執行前置處理的攔截器位置，因為已完成處理只會執行前置處理成功的攔截器，且倒序執行

addInterceptor

addInterceptor(HandlerInterceptor interceptor) 方法，添加攔截器到 interceptorList 集合中，方法如下：

public void addInterceptor(HandlerInterceptor interceptor) {
    initInterceptorList().add(interceptor);
}

private List<HandlerInterceptor> initInterceptorList() {
    // 如果 interceptorList 為空，則初始化為 ArrayList
    if (this.interceptorList == null) {
        this.interceptorList = new ArrayList<>();
        // 如果 interceptors 非空，則添加到 interceptorList 中
        if (this.interceptors != null) {
            // An interceptor array specified through the constructor
            CollectionUtils.mergeArrayIntoCollection(this.interceptors, this.interceptorList);
        }
    }
    // 置空 interceptors
    this.interceptors = null;
    // 回傳 interceptorList
    return this.interceptorList;
}

getInterceptors

getInterceptors() 方法，獲得 interceptors 陣列，方法如下：

@Nullable
public HandlerInterceptor[] getInterceptors() {
    // 將 interceptorList 初始化到 interceptors 中
    if (this.interceptors == null && this.interceptorList != null) {
        this.interceptors = this.interceptorList.toArray(new HandlerInterceptor[0]);
    }
    // 回傳 interceptors 陣列
    return this.interceptors;
}

applyPreHandle

applyPreHandle(HttpServletRequest request, HttpServletResponse response) 方法，執行請求匹配的攔截器的前置處理，方法如下：

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // <1> 獲得攔截器陣列
    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        // <2> 遍歷攔截器陣列
        for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            // <3> 前置處理
            if (!interceptor.preHandle(request, response, this.handler)) {
                // <3.1> 已完成處理 攔截器
                triggerAfterCompletion(request, response, null);
                // 回傳 false ，前置處理失敗
                return false;
            }
            // <3.2> 標記 interceptorIndex 位置
            this.interceptorIndex = i;
        }
    }
    // <4> 回傳 true ，前置處理成功
    return true;
}

獲得攔截器陣列，通過上面的 getInterceptors() 方法，獲得 interceptors 陣列
遍歷 interceptors 攔截器陣列
依次執行攔截器的前置處理
1. 如果有某個攔截器的前置處理失敗，則呼叫 triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex) 方法，觸發攔截器們的已完成處理，最后回傳 false
2. 每個攔截器成功執行前置處理后，記錄當前攔截器的位置到 interceptorIndex 屬性中，為了已完成處理只會執行前置處理成功的攔截器，且倒序執行
回傳 true，攔截器們的前置處理都成功

applyPostHandle

applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) 方法，執行請求匹配的攔截器的后置處理，方法如下：

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable 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);
        }
    }
}

請求匹配的攔截器的后置處理是倒序執行的
如果前置處理沒有全部執行成功，或者處理請求的程序中出現例外是不會呼叫該方法的，也就是不會執行后置處理

triggerAfterCompletion

triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex) 方法，執行請求匹配的攔截器的已完成處理，方法如下：

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable 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);
            }
        }
    }
}

請求匹配的攔截器的已完成處理是倒序執行的
通過interceptorIndex屬性，只會執行前置處理成功的攔截器們，因為該屬性定義了成功執行前置處理的攔截器的位置
如果前置處理沒有全部執行成功，或者處理請求的程序中出現例外還是會呼叫該方法，也就是會執行已完成處理

HandlerInterceptor 的實作類

HandlerMapping 介面體系的結構如下：

可以看到它的實作類有許多，這里來看幾個重要的類

MappedInterceptor

org.springframework.web.servlet.handler.MappedInterceptor，實作 HandlerInterceptor 介面，支持地址匹配的 HandlerInterceptor 實作類

每一個 <mvc:interceptor /> 標簽，將被決議成一個 MappedInterceptor 型別的 Bean 攔截器物件

構造方法

public final class MappedInterceptor implements HandlerInterceptor {
	/**
	 * 匹配的路徑
	 */
	@Nullable
	private final String[] includePatterns;

	/**
	 * 不匹配的路徑
	 */
	@Nullable
	private final String[] excludePatterns;

	/**
	 * 攔截器物件
	 */
	private final HandlerInterceptor interceptor;

	/**
	 * 路徑匹配器
	 */
	@Nullable
	private PathMatcher pathMatcher;

	public MappedInterceptor(@Nullable String[] includePatterns, HandlerInterceptor interceptor) {
		this(includePatterns, null, interceptor);
	}
    
	public MappedInterceptor(@Nullable String[] includePatterns, @Nullable String[] excludePatterns,
			HandlerInterceptor interceptor) {
		this.includePatterns = includePatterns;
		this.excludePatterns = excludePatterns;
		this.interceptor = interceptor;
	}

	public MappedInterceptor(@Nullable String[] includePatterns, WebRequestInterceptor interceptor) {
		this(includePatterns, null, interceptor);
	}
}

includePatterns：攔截器需要匹配的請求路徑
excludePatterns：攔截器需要排除的請求路徑
pathMatcher：路徑匹配器
interceptor：攔截器物件

通過前面三個屬性去判斷請求是否匹配

matches

matches(String lookupPath, PathMatcher pathMatcher) 方法，判斷請求路徑是否匹配，方法如下：

public boolean matches(String lookupPath, PathMatcher pathMatcher) {
    PathMatcher pathMatcherToUse = (this.pathMatcher != null ? this.pathMatcher : pathMatcher);
    // <1> 先判斷該路徑是否在不匹配的路徑中
    if (!ObjectUtils.isEmpty(this.excludePatterns)) {
        for (String pattern : this.excludePatterns) {
            if (pathMatcherToUse.match(pattern, lookupPath)) {
                return false;
            }
        }
    }
    // <2> 如果匹配的路徑為空，則都匹配通過
    if (ObjectUtils.isEmpty(this.includePatterns)) {
        return true;
    }
    // <3> 判斷路徑是否在需要匹配的路徑中
    for (String pattern : this.includePatterns) {
        if (pathMatcherToUse.match(pattern, lookupPath)) {
            return true;
        }
    }
    return false;
}

先判斷該路徑是否在不匹配的路徑中
如果匹配的路徑為空，則都匹配通過
判斷路徑是否在需要匹配的路徑中

攔截方法的實作

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
    return this.interceptor.preHandle(request, response, handler);
}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
        @Nullable ModelAndView modelAndView) throws Exception {
    this.interceptor.postHandle(request, response, handler, modelAndView);
}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
        @Nullable Exception ex) throws Exception {
    this.interceptor.afterCompletion(request, response, handler, ex);
}

都是直接呼叫interceptor攔截器對應的方法

其他

使用示例

1. `<mvc:interceptors>` 標簽

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/**" />
        <mvc:exclude-mapping path="/error/**" />
        <bean  />
    </mvc:interceptor>
</mvc:interceptors>

每一個 <mvc:interceptor /> 標簽，將被決議成一個 MappedInterceptor 型別的 Bean 攔截器物件

然后 MappedInterceptor 型別的攔截器在 AbstractHandlerMapping 的 initApplicationContext() -> detectMappedInterceptors 會被掃描到

protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
    // 掃描已注冊的 MappedInterceptor 的 Bean 們，添加到 mappedInterceptors 中
    // MappedInterceptor 會根據請求路徑做匹配，是否進行攔截
    mappedInterceptors.addAll(BeanFactoryUtils
            .beansOfTypeIncludingAncestors(obtainApplicationContext(), MappedInterceptor.class, true, false)
            .values());
}

也就是說在初始化 HandlerMapping 組件的時候會掃描到我們自定義的攔截器，并添加到屬性中

<mvc:interceptor /> 標簽如何被決議成MappedInterceptor物件的？

可以來看到spring-webmvc工程的 spring.handlers 檔案，如下：

http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler

指定了 NamespaceHandler 為 MvcNamespaceHandler 物件，也就是說<mvc />標簽會被該物件進行決議，如下：

public class MvcNamespaceHandler extends NamespaceHandlerSupport {
	@Override
	public void init() {
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
		registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
		registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
		registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
		registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
	}
}

其中<mvc:interceptor />標簽則會被 InterceptorsBeanDefinitionParser 物件進行決議，如下：

class InterceptorsBeanDefinitionParser implements BeanDefinitionParser {
	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext context) {
		context.pushContainingComponent(
				new CompositeComponentDefinition(element.getTagName(), context.extractSource(element)));

		RuntimeBeanReference pathMatcherRef = null;
		if (element.hasAttribute("path-matcher")) {
			pathMatcherRef = new RuntimeBeanReference(element.getAttribute("path-matcher"));
		}

		List<Element> interceptors = DomUtils.getChildElementsByTagName(element, "bean", "ref", "interceptor");
		for (Element interceptor : interceptors) {
			// 將 <mvc:interceptor /> 標簽決議 MappedInterceptor 物件
			RootBeanDefinition mappedInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);
			mappedInterceptorDef.setSource(context.extractSource(interceptor));
			mappedInterceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

			ManagedList<String> includePatterns = null;
			ManagedList<String> excludePatterns = null;
			Object interceptorBean;
			if ("interceptor".equals(interceptor.getLocalName())) {
				includePatterns = getIncludePatterns(interceptor, "mapping");
				excludePatterns = getIncludePatterns(interceptor, "exclude-mapping");
				Element beanElem = DomUtils.getChildElementsByTagName(interceptor, "bean", "ref").get(0);
				interceptorBean = context.getDelegate().parsePropertySubElement(beanElem, null);
			}
			else {
				interceptorBean = context.getDelegate().parsePropertySubElement(interceptor, null);
			}
			mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, includePatterns);
			mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, excludePatterns);
			mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(2, interceptorBean);

			if (pathMatcherRef != null) {
				mappedInterceptorDef.getPropertyValues().add("pathMatcher", pathMatcherRef);
			}

			String beanName = context.getReaderContext().registerWithGeneratedName(mappedInterceptorDef);
			context.registerComponent(new BeanComponentDefinition(mappedInterceptorDef, beanName));
		}

		context.popAndRegisterContainingComponent();
		return null;
	}

	private ManagedList<String> getIncludePatterns(Element interceptor, String elementName) {
		List<Element> paths = DomUtils.getChildElementsByTagName(interceptor, elementName);
		ManagedList<String> patterns = new ManagedList<>(paths.size());
		for (Element path : paths) {
			patterns.add(path.getAttribute("path"));
		}
		return patterns;
	}
}

邏輯不復雜，會將 <mvc:interceptor /> 標簽決議 BeanDefinition 物件，beanClass 為 MappedInterceptor，決議出來的屬性也會添加至其中，也就會給初始化成 MappedInterceptor 型別的 Spring Bean 到 Spring 背景關系中

2. Java Config

在 SpringBoot 2.0+ 專案中，添加攔截器的方式可以如下：

@Component
public class JwtInterceptor implements HandlerInterceptor {
    /**
     * 前置處理
     *
     * @param handler  攔截的目標，處理器
     * @return 該請求是否繼續往下執行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // JWT 校驗
        // 驗證通過，回傳 true，否則回傳false
        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 {
    }
}

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List<String> excludePath = new ArrayList<>();
        // 將攔截器添加至 InterceptorRegistry
		registry.addInterceptor(jwtInterceptor()).addPathPatterns("/**").excludePathPatterns(excludePath);
    }

    @Bean
    public JwtInterceptor jwtInterceptor() {
        return new JwtInterceptor();
    }

}

使用的程序中，如果patterns路徑沒有設定好，可能在請求程序中發生的錯誤會被攔截器攔截到，可以在攔截器中根據自定義注解進行攔截處理

因為 JwtInterceptor 不是 MappedInterceptor 型別的攔截器，不會被 AbstractHandlerMapping 探測到，既然這樣子，那么我們就直接呼叫 AbstractHandlerMapping 的 setInterceptors(Object... interceptors) 設定進去不就好了

由于 Spring 5.0 廢棄了 WebMvcConfigurerAdapter，所以需要通過 WebMvcConfigurer 介面來添加我們的攔截器，那么在 Spring Boot 2.0+ 中是如何將 WebMvcConfigurer 添加的攔截器設定到 AbstractHandlerMapping 物件中的呢？接下來開始簡單的分析

先來看到 spring-boot-autoconfigure 專案中的 WebMvcAutoConfiguration 自動配置類，其中有一個內部靜態類 EnableWebMvcConfiguration，繼承了 DelegatingWebMvcConfiguration 物件（spring-webmvc 專案中），部分代碼如下：

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(WebProperties.class)
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {
    // ... 省略相關代碼
}

回到我們的 spring-webmvc專案，來看到 org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration 這個類，繼承 WebMvcConfigurationSupport 類，部分代碼如下：

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

    /** WebMvcConfigurer 組合類，內部方法就是遍歷所有的 WebMvcConfigurer 實作類 */
	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

	@Autowired(required = false)
	public void setConfigurers(List<WebMvcConfigurer> configurers) {
		if (!CollectionUtils.isEmpty(configurers)) {
            // <1> 注入所有的 WebMvcConfigurer 實作類到 configurers 中
			this.configurers.addWebMvcConfigurers(configurers);
		}
	}
    
    @Override
	protected void addInterceptors(InterceptorRegistry registry) {
        // <2> 呼叫 WebMvcConfigurer 組合類的 addInterceptors(InterceptorRegistry registry) 方法
		this.configurers.addInterceptors(registry);
	}
}

// org.springframework.web.servlet.config.annotation.WebMvcConfigurerComposite.java
class WebMvcConfigurerComposite implements WebMvcConfigurer {
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
        // <3> 依次執行 WebMvcConfigurer 實作類的 addInterceptors 方法，將對應的攔截器添加至 registry 中
		for ( WebMvcConfigurer delegate : this.delegates) {
			delegate.addInterceptors(registry);
		}
	}
}

注入所有的 WebMvcConfigurer 實作類到 configurers 中，示例中我們自定義的 InterceptorConfig 就會被注入到這里
呼叫 WebMvcConfigurer 組合類的 addInterceptors(InterceptorRegistry registry) 方法，看第 3 步
依次執行 WebMvcConfigurer 實作類的 addInterceptors(InterceptorRegistry registry) 方法，將對應的攔截器添加至 registry 中，呼叫示例中我們自定義的 InterceptorConfig 方法，則將我們自定義 JwtInterceptor 攔截器添加至 registry 中了

再來看到 org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport 這個類，部分代碼如下：

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
    @Bean
	public RequestMappingHandlerMapping requestMappingHandlerMapping() {
		RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
		mapping.setOrder(0);
		mapping.setInterceptors(getInterceptors());
		// ... 省略相關代碼
		return mapping;
	}
    
    protected final Object[] getInterceptors() {
		// 若 interceptors 未初始化，則進行初始化
		if (this.interceptors == null) {
			// 創建 InterceptorRegistry 物件
			InterceptorRegistry registry = new InterceptorRegistry();
			// 添加攔截器到 interceptors 中
			addInterceptors(registry);
			// 添加內置攔截器到 interceptors 中
			registry.addInterceptor(new ConversionServiceExposingInterceptor(mvcConversionService()));
			registry.addInterceptor(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider()));
			// 初始化到 interceptors 屬性
			this.interceptors = registry.getInterceptors();
		}
		// 若 interceptors 已初始化，則直接回傳
		return this.interceptors.toArray();
	}
}

邏輯并不復雜，可以看到 Spring MVC 用到的 RequestMappingHandlerMapping 物件會通過 addInterceptors(InterceptorRegistry registry) 方法，獲取到我們自定義InterceptorConfig中添加的JwtInterceptor 攔截器，并設定到 RequestMappingHandlerMapping 物件中

總結

本文對 Spring MVC 處理請求的程序中使用到的 HandlerMapping 組件中的 HandlerInterceptor 攔截器進行了分析，DispatcherServlet 在處理請求的程序中，會執行 HandlerMapping 組件中與請求匹配的攔截器，進行一些攔截處理，攔截器的在專案中會經常使用到，應用場景比較多，例如權限校驗、引數預處理等等，上面也提供了相應的使用示例

攔截器有以下三個方法：

preHandle：前置處理，在執行方法前執行，全部成功執行才會往下執行方法
postHandle：后置處理，在成功執行方法后執行，倒序
afterCompletion：已完成處理，不管方法是否成功執行都會執行，不過只會執行前置處理成功的攔截器，倒序

多個攔截器的執行順序就是自定義 WebMvcConfigurer 實作類添加攔截器時所加入的順序

參考文章：芋道原始碼《精盡 Spring MVC 原始碼分析》

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/235629.html

標籤：Java

上一篇：Spring 事務的那些坑，都在這里了！

下一篇：3分鐘快速搞懂Java的橋接方法

精盡Spring MVC原始碼分析 - HandlerMapping 組件（二）之 HandlerInterceptor 攔截器

HandlerMapping 組件

HandlerMapping 組件（二）之 HandlerInterceptor 攔截器

HandlerInterceptor

HandlerExecutionChain

構造方法

addInterceptor

getInterceptors

applyPreHandle

applyPostHandle

triggerAfterCompletion

HandlerInterceptor 的實作類

MappedInterceptor

構造方法

matches

攔截方法的實作

其他

使用示例

1. <mvc:interceptors> 標簽

2. Java Config

總結

1. `<mvc:interceptors>` 標簽