public interface HandlerAdapter {
// 用于判斷當(dāng)前HandlerAdapter是否能夠處理當(dāng)前請(qǐng)求
boolean supports(Object handler);

// 如果當(dāng)前HandlerAdapter能夠用于適配當(dāng)前請(qǐng)求，那么就會(huì)處理當(dāng)前請(qǐng)求中
// 諸如參數(shù)和返回值等信息，以便能夠直接委托給具體的Handler處理
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, 
Object handler) throws Exception;

// 獲取當(dāng)前請(qǐng)求的最后更改時(shí)間，主要用于供給瀏覽器判斷當(dāng)前請(qǐng)求是否修改過，
// 從而判斷是否可以直接使用之前緩存的結(jié)果
long getLastModified(HttpServletRequest request, Object handler);
}

// AbstractHandlerMethodAdapter
@Override
public final boolean supports(Object handler) {
// 判斷當(dāng)前handler是否為HandlerMethod類型，并且判斷supportsInternal()方法返回值是否為true，
// 這里supportsInternal()方法是提供給子類實(shí)現(xiàn)的一個(gè)方法，對(duì)于RequestMappingHandlerAdapter
// 而言，其返回值始終是true，因?yàn)槠渲恍枰幚淼膆andler是HandlerMethod類型的即可
return (handler instanceof HandlerMethod 
&& supportsInternal((HandlerMethod) handler));
}

// RequestMappingHandlerAdapter
@Override
protected boolean supportsInternal(HandlerMethod handlerMethod) {
// 這里RequestMappingHandlerAdapter只是對(duì)supportsInternal()返回true，因?yàn)槠渲恍枰?
// 處理的handler類型是HandlerMethod類型即可
return true;
}

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

ModelAndView mav;
checkRequest(request);

// 判斷當(dāng)前是否需要支持在同一個(gè)session中只能線性地處理請(qǐng)求
if (this.synchronizeOnSession) {
// 獲取當(dāng)前請(qǐng)求的session對(duì)象
HttpSession session = request.getSession(false);
if (session != null) {
// 為當(dāng)前session生成一個(gè)唯一的可以用于鎖定的key
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
// 對(duì)HandlerMethod進(jìn)行參數(shù)等的適配處理，并調(diào)用目標(biāo)handler
mav = invokeHandlerMethod(request, response, handlerMethod);
}
} else {
// 如果當(dāng)前不存在session，則直接對(duì)HandlerMethod進(jìn)行適配
mav = invokeHandlerMethod(request, response, handlerMethod);
}
} else {
// 如果當(dāng)前不需要對(duì)session進(jìn)行同步處理，則直接對(duì)HandlerMethod進(jìn)行適配
mav = invokeHandlerMethod(request, response, handlerMethod);
}

// 判斷當(dāng)前請(qǐng)求頭中是否包含Cache-Control請(qǐng)求頭，如果不包含，則對(duì)當(dāng)前response進(jìn)行處理，
// 為其設(shè)置過期時(shí)間
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
// 如果當(dāng)前SessionAttribute中存在配置的attributes，則為其設(shè)置過期時(shí)間。
// 這里SessionAttribute主要是通過@SessionAttribute注解生成的
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
} else {
// 如果當(dāng)前不存在SessionAttributes，則判斷當(dāng)前是否存在Cache-Control設(shè)置，
// 如果存在，則按照該設(shè)置進(jìn)行response處理，如果不存在，則設(shè)置response中的
// Cache的過期時(shí)間為-1，即立即失效
prepareResponse(response);
}
}

return mav;
}

@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
// 獲取容器中全局配置的InitBinder和當(dāng)前HandlerMethod所對(duì)應(yīng)的Controller中
// 配置的InitBinder，用于進(jìn)行參數(shù)的綁定
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
// 獲取容器中全局配置的ModelAttribute和當(dāng)前當(dāng)前HandlerMethod所對(duì)應(yīng)的Controller
// 中配置的ModelAttribute，這些配置的方法將會(huì)在目標(biāo)方法調(diào)用之前進(jìn)行調(diào)用
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

// 將handlerMethod封裝為一個(gè)ServletInvocableHandlerMethod對(duì)象，
// 該對(duì)象用于對(duì)當(dāng)前request的整體調(diào)用流程進(jìn)行了封裝
ServletInvocableHandlerMethod invocableMethod =
createInvocableHandlerMethod(handlerMethod);
if (this.argumentResolvers != null) {
// 設(shè)置當(dāng)前容器中配置的所有ArgumentResolver
invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
}
if (this.returnValueHandlers != null) {
// 設(shè)置當(dāng)前容器中配置的所有ReturnValueHandler
invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
}
// 將前面創(chuàng)建的WebDataBinderFactory設(shè)置到ServletInvocableHandlerMethod中
invocableMethod.setDataBinderFactory(binderFactory);
// 設(shè)置ParameterNameDiscoverer，該對(duì)象將按照一定的規(guī)則獲取當(dāng)前參數(shù)的名稱
invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
// 這里initModel()方法主要作用是調(diào)用前面獲取到的@ModelAttribute標(biāo)注的方法，
// 從而達(dá)到@ModelAttribute標(biāo)注的方法能夠在目標(biāo)Handler調(diào)用之前調(diào)用的目的
modelFactory.initModel(webRequest, mavContainer, invocableMethod);
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

// 獲取當(dāng)前的AsyncWebRequest，這里AsyncWebRequest的主要作用是用于判斷目標(biāo)
// handler的返回值是否為WebAsyncTask或DefferredResult，如果是這兩種中的一種，
// 則說明當(dāng)前請(qǐng)求的處理應(yīng)該是異步的。所謂的異步，指的是當(dāng)前請(qǐng)求會(huì)將Controller中
// 封裝的業(yè)務(wù)邏輯放到一個(gè)線程池中進(jìn)行調(diào)用，待該調(diào)用有返回結(jié)果之后再返回到response中。
// 這種處理的優(yōu)點(diǎn)在于用于請(qǐng)求分發(fā)的線程能夠解放出來，從而處理更多的請(qǐng)求，只有待目標(biāo)任務(wù)
// 完成之后才會(huì)回來將該異步任務(wù)的結(jié)果返回。
AsyncWebRequest asyncWebRequest = WebAsyncUtils
.createAsyncWebRequest(request, response);
asyncWebRequest.setTimeout(this.asyncRequestTimeout);

// 封裝異步任務(wù)的線程池，request和interceptors到WebAsyncManager中
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.setTaskExecutor(this.taskExecutor);
asyncManager.setAsyncWebRequest(asyncWebRequest);
asyncManager.registerCallableInterceptors(this.callableInterceptors);
asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

// 這里就是用于判斷當(dāng)前請(qǐng)求是否有異步任務(wù)結(jié)果的，如果存在，則對(duì)異步任務(wù)結(jié)果進(jìn)行封裝
if (asyncManager.hasConcurrentResult()) {
Object result = asyncManager.getConcurrentResult();
mavContainer = (ModelAndViewContainer) 
asyncManager.getConcurrentResultContext()[0];
asyncManager.clearConcurrentResult();
if (logger.isDebugEnabled()) {
logger.debug("Found concurrent result value [" + result + "]");
}
// 封裝異步任務(wù)的處理結(jié)果，雖然封裝的是一個(gè)HandlerMethod，但只是Spring簡單的封裝
// 的一個(gè)Callable對(duì)象，該對(duì)象中直接將調(diào)用結(jié)果返回了。這樣封裝的目的在于能夠統(tǒng)一的
// 進(jìn)行右面的ServletInvocableHandlerMethod.invokeAndHandle()方法的調(diào)用
invocableMethod = invocableMethod.wrapConcurrentResult(result);
}

// 對(duì)請(qǐng)求參數(shù)進(jìn)行處理，調(diào)用目標(biāo)HandlerMethod，并且將返回值封裝為一個(gè)ModelAndView對(duì)象
invocableMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}

// 對(duì)封裝的ModelAndView進(jìn)行處理，主要是判斷當(dāng)前請(qǐng)求是否進(jìn)行了重定向，如果進(jìn)行了重定向，
// 還會(huì)判斷是否需要將FlashAttributes封裝到新的請(qǐng)求中
return getModelAndView(mavContainer, modelFactory, webRequest);
} finally {
// 調(diào)用request destruction callbacks和對(duì)SessionAttributes進(jìn)行處理
webRequest.requestCompleted();
}
}

private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) 
throws Exception {
// 判斷當(dāng)前緩存中是否緩存了當(dāng)前bean所需要裝配的InitBinder方法，如果存在，則直接從緩存中取，
// 如果不存在，則在當(dāng)前bean中進(jìn)行掃描獲取
Class<?> handlerType = handlerMethod.getBeanType();
Set<Method> methods = this.initBinderCache.get(handlerType);
if (methods == null) {
// 在當(dāng)前bean中查找所有標(biāo)注了@InitBinder注解的方法，這里INIT_BINDER_METHODS就是一個(gè)
// 選擇器，表示只獲取使用@InitBinder標(biāo)注的方法
methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS);
this.initBinderCache.put(handlerType, methods);
}

// 這里initBinderAdviceCache是在RequestMappingHandlerAdapter初始化時(shí)同步初始化的，
// 其內(nèi)包含的方法有如下兩個(gè)特點(diǎn)：①當(dāng)前方法所在類使用@ControllerAdvice進(jìn)行標(biāo)注了；
// ②當(dāng)前方法使用@InitBinder進(jìn)行了標(biāo)注。也就是說其內(nèi)保存的方法可以理解為是全局類型
// 的參數(shù)綁定方法
List<InvocableHandlerMethod> initBinderMethods = new ArrayList<>();
this.initBinderAdviceCache.forEach((clazz, methodSet) -> {
// 這里判斷的是當(dāng)前配置的全局類型的InitBinder是否能夠應(yīng)用于當(dāng)前bean，
// 判斷的方式主要在@ControllerAdvice注解中進(jìn)行了聲明，包括通過包名，類所在的包，
// 接口或者注解的形式限定的范圍
if (clazz.isApplicableToBeanType(handlerType)) {
Object bean = clazz.resolveBean();
for (Method method : methodSet) {
initBinderMethods.add(createInitBinderMethod(bean, method));
}
}
});

// 這里是將當(dāng)前HandlerMethod所在bean中的InitBinder添加到需要執(zhí)行的initBinderMethods中。
// 這里從添加的順序可以看出，全局類型的InitBinder會(huì)在當(dāng)前bean中的InitBinder之前執(zhí)行
for (Method method : methods) {
Object bean = handlerMethod.getBean();
initBinderMethods.add(createInitBinderMethod(bean, method));
}

// 將需要執(zhí)行的InitBinder封裝到InitBinderDataBinderFactory中
return createDataBinderFactory(initBinderMethods);
}

private ModelFactory getModelFactory(HandlerMethod handlerMethod, 
WebDataBinderFactory binderFactory) {
// 這里SessionAttributeHandler的作用是聲明幾個(gè)屬性，使其能夠在多個(gè)請(qǐng)求之間共享，
// 并且其能夠保證當(dāng)前request返回的model中始終保有這些屬性
SessionAttributesHandler sessionAttrHandler = 
getSessionAttributesHandler(handlerMethod);

// 判斷緩存中是否保存有當(dāng)前handler執(zhí)行之前所需要執(zhí)行的標(biāo)注了@ModelAttribute的方法
Class<?> handlerType = handlerMethod.getBeanType();
Set<Method> methods = this.modelAttributeCache.get(handlerType);
if (methods == null) {
// 如果緩存中沒有相關(guān)屬性，那么就在當(dāng)前bean中查找所有使用@ModelAttribute標(biāo)注，但是
// 沒有使用@RequestMapping標(biāo)注的方法，并將這些方法緩存起來
methods = MethodIntrospector.selectMethods(handlerType, MODEL_ATTRIBUTE_METHODS);
this.modelAttributeCache.put(handlerType, methods);
}

// 獲取全局的使用@ModelAttribute標(biāo)注，但是沒有使用@RequestMapping標(biāo)注的方法，
// 這里全局類型的方法的聲明方式需要注意的是，其所在的bean必須使用@ControllerAdvice進(jìn)行標(biāo)注
List<InvocableHandlerMethod> attrMethods = new ArrayList<>();
this.modelAttributeAdviceCache.forEach((clazz, methodSet) -> {
// 判斷@ControllerAdvice中指定的作用的bean范圍與當(dāng)前bean是否匹配，匹配了才會(huì)對(duì)其應(yīng)用
if (clazz.isApplicableToBeanType(handlerType)) {
Object bean = clazz.resolveBean();
for (Method method : methodSet) {
attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));
}
}
});

// 將當(dāng)前方法中使用@ModelAttribute標(biāo)注的方法添加到需要執(zhí)行的attrMethods中。從這里的添加順序
// 可以看出，全局類型的方法將會(huì)先于局部類型的方法執(zhí)行
for (Method method : methods) {
Object bean = handlerMethod.getBean();
attrMethods.add(createModelAttributeMethod(binderFactory, bean, method));
}

// 將需要執(zhí)行的方法等數(shù)據(jù)封裝為ModelFactory對(duì)象
return new ModelFactory(attrMethods, binderFactory, sessionAttrHandler);
}

public void initModel(NativeWebRequest request, ModelAndViewContainer container,
HandlerMethod handlerMethod) throws Exception {

// 在當(dāng)前request中獲取使用@SessionAttribute注解聲明的參數(shù)
Map<String, ?> sessionAttributes = 
this.sessionAttributesHandler.retrieveAttributes(request);
// 將@SessionAttribute聲明的參數(shù)封裝到ModelAndViewContainer中
container.mergeAttributes(sessionAttributes);
// 調(diào)用前面獲取的使用@ModelAttribute標(biāo)注的方法
invokeModelAttributeMethods(request, container);

// 這里首先獲取目標(biāo)handler執(zhí)行所需的參數(shù)中與@SessionAttribute同名或同類型的參數(shù)，
// 也就是handler想要直接從@SessionAttribute中聲明的參數(shù)中獲取的參數(shù)。然后對(duì)這些參數(shù)
// 進(jìn)行遍歷，首先判斷request中是否包含該屬性，如果不包含，則從之前的SessionAttribute緩存
// 中獲取，如果兩個(gè)都沒有，則直接拋出異常
for (String name : findSessionAttributeArguments(handlerMethod)) {
if (!container.containsAttribute(name)) {
Object value = this.sessionAttributesHandler.retrieveAttribute(request, name);
if (value == null) {
throw new HttpSessionRequiredException("Expected session attribute '" 
+ name + "'", name);
}
container.addAttribute(name, value);
}
}
}

private void invokeModelAttributeMethods(NativeWebRequest request, 
ModelAndViewContainer container) throws Exception {

while (!this.modelMethods.isEmpty()) {
// 這里getNextModelMethod()方法始終會(huì)獲取modelMethods中的第0號(hào)為的方法，
// 后續(xù)該方法執(zhí)行完了之后則會(huì)將該方法從modelMethods移除掉，因而這里while
// 循環(huán)只需要判斷modelMethods是否為空即可
InvocableHandlerMethod modelMethod = 
getNextModelMethod(container).getHandlerMethod();
// 獲取當(dāng)前方法中標(biāo)注的ModelAttribute屬性，然后判斷當(dāng)前request中是否有與該屬性中name字段
// 標(biāo)注的值相同的屬性，如果存在，并且當(dāng)前ModelAttribute設(shè)置了不對(duì)該屬性進(jìn)行綁定，那么
// 就直接略過當(dāng)前方法的執(zhí)行
ModelAttribute ann = modelMethod.getMethodAnnotation(ModelAttribute.class);
Assert.state(ann != null, "No ModelAttribute annotation");
if (container.containsAttribute(ann.name())) {
if (!ann.binding()) {
container.setBindingDisabled(ann.name());
}
continue;
}

// 通過ArgumentResolver對(duì)方法參數(shù)進(jìn)行處理，并且調(diào)用目標(biāo)方法
Object returnValue = modelMethod.invokeForRequest(request, container);

// 如果當(dāng)前方法的返回值不為空，則判斷當(dāng)前@ModelAttribute是否設(shè)置了需要綁定返回值，
// 如果設(shè)置了，則將返回值綁定到請(qǐng)求中，后續(xù)handler可以直接使用該參數(shù)
if (!modelMethod.isVoid()){
String returnValueName = getNameForReturnValue(returnValue, 
modelMethod.getReturnType());
if (!ann.binding()) {
container.setBindingDisabled(returnValueName);
}

// 如果request中不包含該參數(shù)，則將該返回值添加到ModelAndViewContainer中，
// 供handler使用
if (!container.containsAttribute(returnValueName)) {
container.addAttribute(returnValueName, returnValue);
}
}
}
}

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

// 對(duì)目標(biāo)handler的參數(shù)進(jìn)行處理，并且調(diào)用目標(biāo)handler
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
// 設(shè)置相關(guān)的返回狀態(tài)
setResponseStatus(webRequest);

// 如果請(qǐng)求處理完成，則設(shè)置requestHandled屬性
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null 
|| mavContainer.isRequestHandled()) {
mavContainer.setRequestHandled(true);
return;
}
} else if (StringUtils.hasText(getResponseStatusReason())) {
// 如果請(qǐng)求失敗，但是有錯(cuò)誤原因，那么也會(huì)設(shè)置requestHandled屬性
mavContainer.setRequestHandled(true);
return;
}

mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
// 遍歷當(dāng)前容器中所有ReturnValueHandler，判斷哪種handler支持當(dāng)前返回值的處理，
// 如果支持，則使用該handler處理該返回值
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
} catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", 
returnValue), ex);
}
throw ex;
}
}

@Nullable
public Object invokeForRequest(NativeWebRequest request, @Nullable 
ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

// 將request中的參數(shù)轉(zhuǎn)換為當(dāng)前handler的參數(shù)形式
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), 
getBeanType()) + "' with arguments " + Arrays.toString(args));
}
// 這里doInvoke()方法主要是結(jié)合處理后的參數(shù)，使用反射對(duì)目標(biāo)方法進(jìn)行調(diào)用
Object returnValue = doInvoke(args);
if (logger.isTraceEnabled()) {
logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), 
getBeanType()) + "] returned [" + returnValue + "]");
}
return returnValue;
}

// 本方法主要是通過當(dāng)前容器中配置的ArgumentResolver對(duì)request中的參數(shù)進(jìn)行轉(zhuǎn)化，
// 將其處理為目標(biāo)handler的參數(shù)的形式
private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable 
ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

// 獲取當(dāng)前handler所聲明的所有參數(shù)，主要包括參數(shù)名，參數(shù)類型，參數(shù)位置，所標(biāo)注的注解等等屬性
MethodParameter[] parameters = getMethodParameters();
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
// providedArgs是調(diào)用方提供的參數(shù)，這里主要是判斷這些參數(shù)中是否有當(dāng)前類型
// 或其子類型的參數(shù)，如果有，則直接使用調(diào)用方提供的參數(shù)，對(duì)于請(qǐng)求處理而言，默認(rèn)情況下，
// 調(diào)用方提供的參數(shù)都是長度為0的數(shù)組
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}

// 如果在調(diào)用方提供的參數(shù)中不能找到當(dāng)前類型的參數(shù)值，則遍歷Spring容器中所有的
// ArgumentResolver，判斷哪種類型的Resolver支持對(duì)當(dāng)前參數(shù)的解析，這里的判斷
// 方式比較簡單，比如RequestParamMethodArgumentResolver就是判斷當(dāng)前參數(shù)
// 是否使用@RequestParam注解進(jìn)行了標(biāo)注
if (this.argumentResolvers.supportsParameter(parameter)) {
try {
// 如果能夠找到對(duì)當(dāng)前參數(shù)進(jìn)行處理的ArgumentResolver，則調(diào)用其
// resolveArgument()方法從request中獲取對(duì)應(yīng)的參數(shù)值，并且進(jìn)行轉(zhuǎn)換
args[i] = this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);
continue;
} catch (Exception ex) {
if (logger.isDebugEnabled()) {
logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", 
i), ex);
}
throw ex;
}
}

// 如果進(jìn)行了參數(shù)處理之后當(dāng)前參數(shù)還是為空，則拋出異常
if (args[i] == null) {
throw new IllegalStateException("Could not resolve method parameter at index " 
+ parameter.getParameterIndex() + " in " 
+ parameter.getExecutable().toGenericString() 
+ ": " + getArgumentResolutionErrorMessage("No suitable resolver for",i));
}
}
return args;
}

@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

// 獲取能夠處理當(dāng)前返回值的Handler，比如如果返回值是ModelAndView類型，那么這里的handler就是
// ModelAndViewMethodReturnValueHandler
HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
if (handler == null) {
throw new IllegalArgumentException("Unknown return value type: " 
+ returnType.getParameterType().getName());
}

// 通過獲取到的handler處理返回值，并將其封裝到ModelAndViewContainer中
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}

// 本方法的主要作用是獲取能夠處理當(dāng)前返回值的ReturnValueHandler
private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, 
MethodParameter returnType) {
// 判斷返回值是否為異步類型的返回值，即WebAsyncTask或DefferredResult
boolean isAsyncValue = isAsyncReturnValue(value, returnType);

// 對(duì)所有的ReturnValueHandler進(jìn)行遍歷，判斷其是否支持當(dāng)前返回值的處理。這里如果當(dāng)前返回值
// 是異步類型的返回值，還會(huì)判斷當(dāng)前ReturnValueHandler是否為
// AsyncHandlerMethodReturnValueHandler類型，如果不是，則會(huì)繼續(xù)查找
for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
continue;
}

// 判斷是否支持返回值處理的主要位置，比如ModelAndViewMethodReturnValueHandler就會(huì)
// 判斷返回值是否為ModelAndView類型，如果是，則表示其是當(dāng)前ReturnValuleHandler所支持的類型
if (handler.supportsReturnType(returnType)) {
return handler;
}
}
return null;
}