Spring1-拦截器

DispatcherServlet:

是一个servlet，也就是会被放到tomcat容器中，只不过功能是用来分发。

所有请求，视图解析，映射处理之类的都是通过DispatcherServlet来交给其他组件，最后返回响应给用户。

步骤：

 1、  首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

2、  DispatcherServlet——>HandlerMapping，HandlerMapping 将会把请求映射为 HandlerExecutionChain 对象（包含一个 Handler 处理器（页面控制器）对象、多个 HandlerInterceptor 拦截器，handler处理器是通过AbstractUrlHandlerMapping类中的方法来获取的，HandlerInterceptor是通过AbstractHandlerMapping类来获取的）对象，通过这种策略模式，很容易添加新的映射策略；

3、  DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4、  HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个 ModelAndView 对象（包含模型数据、逻辑视图名）；

5、  ModelAndView 的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的 View，通过这种策略模式，很容易更换其他视图技术；

6、  View——>渲染，View 会根据传进来的 Model 模型数据进行渲染，此处的 Model 实际是一个 Map 数据结构，因此很容易支持其他视图技术；

7、  返回控制权给 DispatcherServlet，由 DispatcherServlet 返回响应给用户，到此一个流程结束。

---

//根据url调用不同的handler来处理。
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);

				// Determine handler for the current request.
                //根据request找对应的HandlerExecutionChain
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
                //mappedHandler是Chain，里面有handler和interceptor,从handler中得到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;
					}
				}
				//chain中的所有前处理进行处理。
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
                //用HandlerAdapter处理请求，得到的是ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

				applyDefaultViewName(processedRequest, mv);
                //调用postHandler进行处理。
				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);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
            //有异常依然会执行afterCOmpletion
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
            //Interceptor中的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);
				}
			}
		}
	}

AbstractHandlerMapping

获得HandlerExecutionChain，以及拦截器的list。

1个url->多个拦截器。1个url->1个handler.

在AbstractHandlerMapping中，

	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //抽象方法，在子类中实现。被欢迎页和AbstractUrlHandlerMapping实现了。
		Object handler = getHandlerInternal(request);
		if (handler == null) {
            //用默认的handler
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
        //反射调用从ApplicationContext中获得handler.
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		//从handler中得到HandlerExecutionChain;
		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
		………………………………………………

		if (CorsUtils.isCorsRequest(request)) {
			CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}

		return executionChain;
	}


//Interceptorlist 是在这里被放进去的。因为url可能对应多个Interceptro，所以这里不用找最佳匹配。
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    //如果handler是HandlerExecutionChain的子类，直接转换，不是的话放到Chain中的Handler变量中
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
		
		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
    //向HandlerExecutionChain添加拦截器集合。
    //this.adaptedInterceptors是在初始化的时候获得，有所有的
    //如果是MappedInterceptor,需要将url和设置的过滤条件对比。
		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
			if (interceptor instanceof MappedInterceptor) {
				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
				//pathMatcher工具类。字符串路径匹配。
                if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
					chain.addInterceptor(mappedInterceptor.getInterceptor());
				}
			}
			else {
				chain.addInterceptor(interceptor);
			}
		}
		return chain;
	}

AbstractUrlHandlerMapping

从url中找出handler,这里找的是handler，和interceptor不一样。主要就是解决模式匹配的问题：/xxx/* 还有一个url匹配多个Map中的key。

	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
        //查找handler
		Object handler = lookupHandler(lookupPath, request);
        //没有对应的handler
		if (handler == null) {
			// We need to care for the default handler directly, since we need to
			// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
			Object rawHandler = null;
			if ("/".equals(lookupPath)) {
                //rootHandler用来处理"/"
				rawHandler = getRootHandler();
			}
			if (rawHandler == null) {
                //默认handler
				rawHandler = getDefaultHandler();
			}
            
			if (rawHandler != null) {
				// Bean name or resolved handler?
				if (rawHandler instanceof String) {
					String handlerName = (String) rawHandler;
                    //应该是根据名字去找handler.
					rawHandler = obtainApplicationContext().getBean(handlerName);
				}
                //检验是否匹配。
				validateHandler(rawHandler, request);
                //注册拦截器。
				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
			}
		}
		return handler;
	}
-------------------------------------
//查找Handler
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// Direct match?
    //直接从map中找
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
            //如果是beanname，容器中获取
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
            //验证
			validateHandler(handler, request);
            //拦截器
			return buildPathExposingHandler(handler, urlPath, urlPath, null);
		}

		// Pattern match?
    //模式匹配
		List<String> matchingPatterns = new ArrayList<>();
		for (String registeredPattern : this.handlerMap.keySet()) {
            //工具包中的matcher,进行匹配。matcher.match(Pattern,path）
			if (getPathMatcher().match(registeredPattern, urlPath)) {
                //先把满足的加到list中，因为可能有多个。
				matchingPatterns.add(registeredPattern);
			}
            //要不要考虑末尾的斜杠
			else if (useTrailingSlashMatch()) {
                //
				if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
					matchingPatterns.add(registeredPattern +"/");
				}
			}
		}
		//从list中找出最匹配的。
		String bestMatch = null;
    //自定义比较器，比较器的具体实现在AntPathMatcher中
		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
		if (!matchingPatterns.isEmpty()) {
            //排序
			matchingPatterns.sort(patternComparator);
            
			if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
				logger.trace("Matching patterns " + matchingPatterns);
			}
            //获取第一个
			bestMatch = matchingPatterns.get(0);
		}
    //存在最佳匹配
		if (bestMatch != null) {
			handler = this.handlerMap.get(bestMatch);
            //map中没有对应的handler
			if (handler == null) {
                
				if (bestMatch.endsWith("/")) {
					handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
				}
				if (handler == null) {
                    //抛异常
					throw new IllegalStateException(
							"Could not find handler for best pattern match [" + bestMatch + "]");
				}
			}
			// Bean name or resolved handler?
            //多次出现了的语句。map中放的有的是String，（猜测：第一次用，还未初始化？？）。
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = obtainApplicationContext().getBean(handlerName);
			}
            //检测
			validateHandler(handler, request);
			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);

			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
			// for all of them
            //可能有多个最佳匹配。
			Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
			for (String matchingPattern : matchingPatterns) {
				if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
					uriTemplateVariables.putAll(decodedVars);
				}
			}
			return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
		}

		// No handler found...
		return null;
	}
-------------
    //用找到的handler构建一个HandlerExecutionChain,并注册两个两个拦截器PathExposingHandlerInterceptor，UriTemplateVariablesHandlerInterceptor
    
	protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
			String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {

		HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
		chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
		if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
			chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
		}
		return chain;
	}

两个内部拦截器作用：就是将与当前url实际匹配的pattern、匹配条件以及url模板参数等设置到request的属性里面去，这样在后面的处理过程中就可以直接从request属性中获取。

handler可以通过protected void registerHandler(String urlPath, Object handler) 来注册的。

//部分函数	
protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
		Assert.notNull(urlPath, "URL path must not be null");
		Assert.notNull(handler, "Handler object must not be null");
		Object resolvedHandler = handler;

		// Eagerly resolve handler if referencing singleton via name.
    //非懒加载
		if (!this.lazyInitHandlers && handler instanceof String) {
			String handlerName = (String) handler;
			ApplicationContext applicationContext = obtainApplicationContext();
			if (applicationContext.isSingleton(handlerName)) {
				resolvedHandler = applicationContext.getBean(handlerName);
			}
		}
    		Object mappedHandler = this.handlerMap.get(urlPath);
		if (mappedHandler != null) {
            //已经有了
			if (mappedHandler != resolvedHandler) {
				throw new IllegalStateException(
						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
			}
		}
		else {
            //“/”注册的是rootHandler
			if (urlPath.equals("/")) 
				setRootHandler(resolvedHandler);
			}
            //  "/*"注册默认handler
			else if (urlPath.equals("/*")) {
				setDefaultHandler(resolvedHandler);
			}
			else {
                //加进去
				this.handlerMap.put(urlPath, resolvedHandler);
				}
			}
		}
	}

拦截器

拦截器的实现：

• 实现HandlerInterceptor
• 继承实现了HandlerInterceptor接口的类。例如：HandlerInterceptorAdapter

HandlerExecutionChain

private final Object handler;//HandlerMethod

@Nullable
private HandlerInterceptor[] interceptors;

@Nullable
private List<HandlerInterceptor> interceptorList;//存在这里

private int interceptorIndex = -1;

interceptors是在构造函数中直接传入的。最后也会通过CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);加到List中

//责任链，返回false，说明不用再往下继续了。之后的controller和interceptor都不用再执行了。直接执行afterCompletion	
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)) {
					//直接执行after了。
                    triggerAfterCompletion(request, response, null);
                    
					return false;
				}
                //最后一个interceptor的位置
				this.interceptorIndex = i;
			}
		}
		return true;
	}

	/**
	 * Apply postHandle methods of registered interceptors.
	 */
	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);
			}
		}
	}

	/**
	 * 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, @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);
				}
			}
		}
	}

• HandlerInterceptorAdapter
  实现了AsyncHandlerInterceptor，多了afterConcurrentHandlingStarted()：可以处理异步请求。Controller中有异步请求方法时会触发该方法。一般继承这个抽象类
• MappedInterceptor 对某些地址进行排除和包括的拦截器。
• WebInterceptor： 针对请求，参数中没有response，并且没有返回值。

和Filter的区别：

• Interceptor 是SPring的组件，FIlter是在Servlet容器中。javax.servlet包中。
• FIlter优先于Interceptor执行。
• 总的来说就是不是同一个东西，但是功能相似。在Spring架构中，优先使用拦截器。

Filter方法：

• void init(FilterConfig paramFilterConfig)
• doFilter(ServletRequest paramServletRequest, ServletResponse paramServletResponse, FilterChain paramFilterChain) 责任链模式，将Chain传递下去
• void destroy() 销毁资源。

用途：权限检查。