/**
 * Use the given handler to handle this request.
 * The workflow that is required may vary widely.
 * @param request current HTTP request
 * @param response current HTTP response
 * @param handler handler to use. This object must have previously been passed
 * to the {@code supports} method of this interface, which must have 实际上是 HandlerMethod
 * returned {@code true}.
 * @throws Exception in case of errors
 * @return a ModelAndView object with the name of the view and the required
 * model data, or {@code null} if the request has been handled directly
 */
 //
 @Nullable
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
	//遍历DipatcherServlet.properties里org.springframework.web.servlet.HandlerAdapter的配置，调用handlerAdpater.supports看那个符合条件
	//Springboot中，会执行RequestMappingHandler.supports-->AbstractHandlerMethodAdapter.supports 即handler是HandlerMetod
	if (this.handlerAdapters != null) {
		for (HandlerAdapter adapter : this.handlerAdapters) {
			if (adapter.supports(handler)) { 
				return adapter;
			}
		}
	}
	throw new ServletException("No adapter for handler [" + handler +
			"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

@Override
protected ModelAndView handleInternal(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

	ModelAndView mav;
	//校验requestMethod和requireSession
	checkRequest(request);

	// Execute invokeHandlerMethod in synchronized block if required.
	// session线程不安全，如果想用户多次请求都访问同一个session需要加一个全局锁。。性能极差很少见
	if (this.synchronizeOnSession) {
		HttpSession session = request.getSession(false);
		if (session != null) {
			Object mutex = WebUtils.getSessionMutex(session);
			synchronized (mutex) {
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// No HttpSession available -> no mutex necessary
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}
	}
	else {
		// No synchronization on session demanded at all...
		// 关键方法，代理方法执行handlerMethod,返回modelAndView
		mav = invokeHandlerMethod(request, response, handlerMethod);
	}

	if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
		if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
			applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
		}
		else {
			prepareResponse(response);
		}
	}

	return mav;
}

/**
 * Invoke the {@link RequestMapping} handler method preparing a {@link ModelAndView}
 * if view resolution is required.
 * @since 4.2
 * @see #createInvocableHandlerMethod(HandlerMethod)
 */
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
	//HttpServletRequest 的封装
	ServletWebRequest webRequest = new ServletWebRequest(request, response);
	try {
		//用来处理request中的参数映射，WebDataBinderFactory里的值见：afterPropertiesSet
		WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
		//用来创建初始化model
		ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
		//根据handlerMethod实例化一个ServletInvocableHandlerMethod来处理请求
		ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
		//设置argumentResolvers处理request的参数 argumentResolvers里的值见afterPropertiesSet
		if (this.argumentResolvers != null) {
			invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
		}
		//设置argumentResolvers处理response的参数 returnValueHandlers里的值见afterPropertiesSet
		// 可自定义 TODO 比如想给所有的ResponseBody返回值封装成{code:0,msg:1,data:null}
		if (this.returnValueHandlers != null) {
			invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
		}
		invocableMethod.setDataBinderFactory(binderFactory);
		invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

		//modelAndView的上下文对象
		ModelAndViewContainer mavContainer = new ModelAndViewContainer();
		mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
		//初始化Model对象，同时将sessionAtrributes值和ModelAtrributes的值都合并在一起放在Model中
		modelFactory.initModel(webRequest, mavContainer, invocableMethod);
		mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

		//todo 未读
		AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
		asyncWebRequest.setTimeout(this.asyncRequestTimeout);

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		asyncManager.setTaskExecutor(this.taskExecutor);
		asyncManager.setAsyncWebRequest(asyncWebRequest);
		asyncManager.registerCallableInterceptors(this.callableInterceptors);
		asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

		if (asyncManager.hasConcurrentResult()) {
			Object result = asyncManager.getConcurrentResult();
			mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
			asyncManager.clearConcurrentResult();
			LogFormatUtils.traceDebug(logger, traceOn -> {
				String formatted = LogFormatUtils.formatValue(result, !traceOn);
				return "Resume with async result [" + formatted + "]";
			});
			invocableMethod = invocableMethod.wrapConcurrentResult(result);
		}

		//关键代码，通过handlerMethod的代理方法，执行Controller的方法，将结果存储到mavContainer
		invocableMethod.invokeAndHandle(webRequest, mavContainer);
		if (asyncManager.isConcurrentHandlingStarted()) {
			return null;
		}

		//获取ModelAndView
		return getModelAndView(mavContainer, modelFactory, webRequest);
	}
	finally {
		webRequest.requestCompleted();
	}
}

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {

	//关键代码，通过java的反射机制doInvoke执行handlerMethod对应的controller方法
	Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
	setResponseStatus(webRequest);

	if (returnValue == null) {
		if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
			disableContentCachingIfNecessary(webRequest);
			mavContainer.setRequestHandled(true);
			return;
		}
	}
	else if (StringUtils.hasText(getResponseStatusReason())) {
		mavContainer.setRequestHandled(true);
		return;
	}

	mavContainer.setRequestHandled(false);
	Assert.state(this.returnValueHandlers != null, "No return value handlers");
	try {
		//调用returnValueHandlers 将返回值写到response中（webRequest.getNativeResponse)里
		// 由于现在开发采用前后端分离，RestApi往往会用到RequestResponseBodyMethodProcessor，可以看这个类，返回值和controller方法有@ResponseBody
		this.returnValueHandlers.handleReturnValue(
				returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
	}
	catch (Exception ex) {
		if (logger.isTraceEnabled()) {
			logger.trace(formatErrorForReturnValue(returnValue), ex);
		}
		throw ex;
	}
}

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
		Object... providedArgs) throws Exception {
	//从request里获取controller执行方法的参数，request里的值变为方法里设置的参数
	Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
	if (logger.isTraceEnabled()) {
		logger.trace("Arguments: " + Arrays.toString(args));
	}
	//通过java的反射机制，执行controller里的方法，方法参数getMethodArgumentValues获取
	return doInvoke(args);
}

protected Object doInvoke(Object... args) throws Exception {
	ReflectionUtils.makeAccessible(getBridgedMethod());
	try {
		//todo 通过反射执行方法 书签
		//调用java反射包的invoke 代理执行HandlerMethod里econtroller对应的方法
		// getBridgedMethod= 如果没有意外等于controller被执行的方法
		// getBean()=Controller对象
		// args=request通过argumentResolver得到的方法参数对象
		return getBridgedMethod().invoke(getBean(), args);
	}
	catch (IllegalArgumentException ex) {
		assertTargetBean(getBridgedMethod(), getBean(), args);
		String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
		throw new IllegalStateException(formatInvokeError(text, args), ex);
	}
	catch (InvocationTargetException ex) {
		// Unwrap for HandlerExceptionResolvers ...
		Throwable targetException = ex.getTargetException();
		if (targetException instanceof RuntimeException) {
			throw (RuntimeException) targetException;
		}
		else if (targetException instanceof Error) {
			throw (Error) targetException;
		}
		else if (targetException instanceof Exception) {
			throw (Exception) targetException;
		}
		else {
			throw new IllegalStateException(formatInvokeError("Invocation failure", args), targetException);
		}
	}
}

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping

public void afterPropertiesSet() {
	//调用initHandlerMethods
	initHandlerMethods();
}

 //从ApplicationContext扫描所有的bean, 找到并且将handler method注册到容器中【将url和handlerMethod关联】
 protected void initHandlerMethods() {
	//获取application中所有的bean
	for (String beanName : getCandidateBeanNames()) {
		if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
       		//重点方法
			processCandidateBean(beanName);
		}
	}
	handlerMethodsInitialized(getHandlerMethods());
}

protected void processCandidateBean(String beanName) {
	Class<?> beanType = null;
	try {
		beanType = obtainApplicationContext().getType(beanName);
	} catch (Throwable ex) {
		// An unresolvable bean type, probably from a lazy bean - let's ignore it.
		if (logger.isTraceEnabled()) {
			logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
		}
	}
	//这里isHandler判断beanType是否是一个Controller【判断是否有@Controller和@RequestMapping注解】
	if (beanType != null && isHandler(beanType)) {
     		//重点方法
		detectHandlerMethods(beanName);
	}
}

protected void detectHandlerMethods(Object handler) {
		Class<?> handlerType = (handler instanceof String ?
				obtainApplicationContext().getType((String) handler) : handler.getClass());

		if (handlerType != null) {
			Class<?> userType = ClassUtils.getUserClass(handlerType);
			//遍历handler中的方法，通过getMappingForMethod返回RequestMappingInfo
			// 通过方法上的RequestMapping注解,生成RequestMappingInfo，并且和Method关联
			Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
					(MethodIntrospector.MetadataLookup<T>) method -> {
						try {
							return getMappingForMethod(method, userType);
						} catch (Throwable ex) {
							throw new IllegalStateException("Invalid mapping on handler class [" +
									userType.getName() + "]: " + method, ex);
						}
					});
			if (logger.isTraceEnabled()) {
				logger.trace(formatMappings(userType, methods));
			}

			//遍历method-->RequestMappingInfo 并且将method和mapping注册到 mappingRegistry中RequestMappingHandlerMapping对其进行了改写
			methods.forEach((method, mapping) -> {
				Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
				registerHandlerMethod(handler, invocableMethod, mapping);
			});
		}
	}

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
	this.mappingRegistry.register(mapping, handler, method);
}

	public void register(T mapping, Object handler, Method method) {
		// Assert that the handler method is not a suspending one.
		if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
			throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
		}
		this.readWriteLock.writeLock().lock();
		try {
			//封装成HandlerMethod
			HandlerMethod handlerMethod = createHandlerMethod(handler, method);
			//判断mapping是否已经存在，存在抛异常
			validateMethodMapping(handlerMethod, mapping);
			//关联 mapping-->handlerMethod
			this.mappingLookup.put(mapping, handlerMethod);
			//根据mapping获取url并且将Url和mapping关联起来
			List<String> directUrls = getDirectUrls(mapping);
			for (String url : directUrls) {
				this.urlLookup.add(url, mapping);
			}

			//关联name【RequestMappingInfoHandlerMethodMappingNamingStrategy.getName】和handlerMethod
			String name = null;
			if (getNamingStrategy() != null) {
				name = getNamingStrategy().getName(handlerMethod, mapping);
				addMappingName(name, handlerMethod);
			}

			//corsLookup绑定handlerMethod和corsConfig,注解或者方法上带CrossOrigin
			CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
			if (corsConfig != null) {
				this.corsLookup.put(handlerMethod, corsConfig);
			}

			this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
		} finally {
			this.readWriteLock.writeLock().unlock();
		}
	}

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	//根据request获取一个指定的handler，如果没找到返回null，类型是HandlerMethod，调用链路RequestMappingHandlerMapping.getHandlerInternal-->AbstractHandlerMethodMapping.getgetHandlerInternal
	
	//重点方法1 
	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 = obtainApplicationContext().getBean(handlerName);
	}

	//重点方法2 返回HandlerExecutionChain【handler和拦截器】的封装
	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

	if (logger.isTraceEnabled()) {
		logger.trace("Mapped to " + handler);
	} else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
		logger.debug("Mapped to " + executionChain.getHandler());
	}

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

	return executionChain;
}

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	//获取urlPath用于查找HandlerMethod
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	request.setAttribute(LOOKUP_PATH, lookupPath);
	this.mappingRegistry.acquireReadLock();
	try {
		//查找HandlerMethod 优先通过Path找，没找到轮询mappingLookup，之后对找到的HandlerMethod排序找到最合适的HandlerMethod
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		//re-create bean 享元模式防止请求修改HandlerMethod
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	} finally {
		this.mappingRegistry.releaseReadLock();
	}
}

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
	//
	List<Match> matches = new ArrayList<>();
	//通过path查找到符合要求的RequestMappingInfo
	List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
	if (directPathMatches != null) {
		addMatchingMappings(directPathMatches, matches, request);
	}

	//如果通过path没找到去mappingLookup轮询一遍查找
	if (matches.isEmpty()) {
		// No choice but to go through all mappings...
		addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
	}

	//不为空
	if (!matches.isEmpty()) {
		//根据RequestMappingInfoHandlerMapping.getMappingComparator排序Match.mapping的Compare然后取第一个
		// todo 优先级未看
		Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
		matches.sort(comparator);
		//排序后取第一个作为返回结果
		Match bestMatch = matches.get(0);
		//取出来俩个然后优先级一样直接抛出异常意思是Handler重复"多个优先级"
		if (matches.size() > 1) {
			if (logger.isTraceEnabled()) {
				logger.trace(matches.size() + " matching mappings: " + matches);
			}
			if (CorsUtils.isPreFlightRequest(request)) {
				return PREFLIGHT_AMBIGUOUS_MATCH;
			}
			Match secondBestMatch = matches.get(1);
			if (comparator.compare(bestMatch, secondBestMatch) == 0) {
				Method m1 = bestMatch.handlerMethod.getMethod();
				Method m2 = secondBestMatch.handlerMethod.getMethod();
				String uri = request.getRequestURI();
				throw new IllegalStateException(
						"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
			}
		}
		request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
		//为request设置值：PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE，返回对应的handlerMethod
		//这里其实就是把mapping,和handler都返回只不过mapping放在了requst里
		handleMatch(bestMatch.mapping, lookupPath, request);
		return bestMatch.handlerMethod;
	} else {
		//都没匹配到调用该方法见RequestMappingInfoHandlerMapping，其中不符合RequestMappingInfo的会抛异常
		return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
	}
}

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
	//如果是一个存在的HandlerExecutionChain,直接返回，否则new一个HandlerExecutionChain
	//new HandlerExecutionChain(handler)在HandlerExecutionChain的构造方法里会再判断下Handler的类型，
	// 如果是HandlerExecutionChain进行merge
	// 如果是HandlerMethod会进行赋值具体见HandlerExecutionChain构造方法
	HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
			(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

	String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
	//处理拦截器，
	// 如果是MappedInterceptor，判断lookupPath是否匹配如果匹配将拦截器加入到HandlerExecutionChain
	// 如果是HandlerInterceptor 或者WebRequestInterceptor直接将拦截器加入到HandlerExecutionChain
	// todo 注意：springboot 通过WebMvcConfigurer配置的interceptor最终都会转成MappedInterceptor，
	// 见InterceptorRegistration.getInterceptor(),入口在WebMvcAutoConfiguration.requestMappingHandlerMapping()方法
	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;
}