// HandlerMethod 方法中 參數(shù)解析器
public interface HandlerMethodArgumentResolver {
    // 判斷 HandlerMethodArgumentResolver 是否支持 MethodParameter(PS: 一般都是通過 參數(shù)上面的注解|參數(shù)的類型)
    boolean supportsParameter(MethodParameter parameter);
    // 從 ModelAndViewContainer(被 @ModelAttribute), NativeWebRequest(其實(shí)就是HttpServletRequest) 中獲取數(shù)據(jù), 解決 方法上的參數(shù)
    Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;
}

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    // 創(chuàng)建 MethodParameter 對應(yīng)的 NamedValueInfo
    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    MethodParameter nestedParameter = parameter.nestedIfOptional();     // Java 8 中支持的 java.util.Optional
    // 因?yàn)榇藭r的 name 可能還是被 ${} 符號包裹, 則通過 BeanExpressionResolver 來進(jìn)行解析
    Object resolvedName = resolveStringValue(namedValueInfo.name);
    if (resolvedName == null) throw new IllegalArgumentException("Specified name must not resolve to null: [" + namedValueInfo.name + "]");
    // 下面的數(shù)據(jù)大體通過 HttpServletRequest, Http Headers, URI template variables(URI 模版變量) 獲取
    // @PathVariable     --> 通過前期對 uri 解析后得到的 decodedUriVariables 獲得
    // @RequestParam     --> 通過 HttpServletRequest.getParameterValues(name) 獲取
    // @RequestAttribute --> 通過 HttpServletRequest.getAttribute(name) 獲取   <-- 這里的 scope 是 request
    // @RequestHeader    --> 通過 HttpServletRequest.getHeaderValues(name) 獲取
    // @CookieValue      --> 通過 HttpServletRequest.getCookies() 獲取
    // @SessionAttribute --> 通過 HttpServletRequest.getAttribute(name) 獲取 <-- 這里的 scope 是 session
    // 通過 resolvedName 來解決參數(shù)的真實(shí)數(shù)據(jù)  <-- 模版方法
    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    if (arg == null) {
        if (namedValueInfo.defaultValue != null) {
            // 若 arg == null, 則使用 defaultValue, 這里默認(rèn)值可能也是通過占位符 ${...} 來進(jìn)行查找
            arg = resolveStringValue(namedValueInfo.defaultValue);
        } else if (namedValueInfo.required && !nestedParameter.isOptional()) {
            // 若 arg == null && defaultValue == null && 非 optional 類型的參數(shù) 則通過 handleMissingValue 來進(jìn)行處理, 一般是報異常
            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
        }
        // 對 null 值的處理 一般還是報異常
        arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
    } // 若得到的數(shù)據(jù)是 "", 則還是使用默認(rèn)值
    else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
        // 這里的默認(rèn)值有可能也是 ${} 修飾的, 所以也需要通過 BeanExpressionResolver 來進(jìn)行解析
        arg = resolveStringValue(namedValueInfo.defaultValue);
    }
    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
        try { // 通過 WebDataBinder 中的 Converter 將 arg 轉(zhuǎn)換成 parameter.getParameterType() 對應(yīng)的類型
              // 將 arg 轉(zhuǎn)換成 parameter.getParameterType() 類型, 這里就需要 SimpleTypeConverter
            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
        } catch (ConversionNotSupportedException ex) {
            throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        } catch (TypeMismatchException ex) {
            throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        }
    }
    // 這里的 handleResolvedValue 一般是空實(shí)現(xiàn), 在PathVariableMethodArgumentResolver中也是存儲一下數(shù)據(jù)到 HttpServletRequest 中
    handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
    return arg;
}

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    // 獲取 @ModelAttribute 中指定 name
    String name = ModelFactory.getNameForParameter(parameter);
    // 從 ModelAndViewContainer.ModelMap 中獲取數(shù)據(jù)值 | 通過構(gòu)造函數(shù)創(chuàng)建一個
    Object attribute = (mavContainer.containsAttribute(name) ? mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, webRequest));
    // 檢測 name 是否可以進(jìn)行綁定
    if (!mavContainer.isBindingDisabled(name)) {
        ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
        if (ann != null && !ann.binding()) mavContainer.setBindingDisabled(name);
    }
    // 此處進(jìn)行參數(shù)的綁定操作 (PS: 下面的 attribute 就是 DataBinder 的 target)
    WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
    if (binder.getTarget() != null) {
        if (!mavContainer.isBindingDisabled(name)) {  // 若可以進(jìn)行參數(shù)的綁定
            bindRequestParameters(binder, webRequest); // 進(jìn)行參數(shù)的綁定
        }
        // applicable: 合適 <-- 這里是進(jìn)行參數(shù)的檢查
        validateIfApplicable(binder, parameter);
        // 檢查在校驗(yàn)的過程中是否出錯
        if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) throw new BindException(binder.getBindingResult());
    }
    // 將 resolved 后的 Model 放入 ModelAndViewContainer 中
    // Add resolved attribute and BindingResult at the end of the model
    Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);
    // 通過 SimpleTypeConverter 進(jìn)行參數(shù)的轉(zhuǎn)換
    return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}

// 解決 HandlerMethod 中的 argument 時使用到的 HttpMessageConverters
protected final List<HttpMessageConverter<?>> messageConverters;
// 支持的 MediaType  <-- 通過這里的 MediaType 來篩選對應(yīng)的 HttpMessageConverter
protected final List<MediaType> allSupportedMediaTypes;
// Request/Response 的 Advice <- 這里的 Advice 其實(shí)就是 AOP 中 Advice 的概念
// RequestAdvice 在從 request 中讀取數(shù)據(jù)之前|后
// ResponseAdvice 在 將數(shù)據(jù)寫入 Response 之后
private final RequestResponseBodyAdviceChain advice;

protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
        Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
    MediaType contentType;
    boolean noContentType = false;
    try { // 獲取 Http 請求頭中的 contentType
        contentType = inputMessage.getHeaders().getContentType();       
    } catch (InvalidMediaTypeException ex) {
        // 獲取失敗則報 HttpMediaTypeNotSupportedException, 根據(jù) DefaultHandlerExceptionResolver, 則報出 Http.status = 415
        throw new HttpMediaTypeNotSupportedException(ex.getMessage());  
    }
    // 若 contentType == null, 則設(shè)置默認(rèn)值, application/octet-stream
    if (contentType == null) {                                          
        noContentType = true;
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    }
    // 獲取 方法的聲明類
    Class<?> contextClass = (parameter != null ? parameter.getContainingClass() : null);
    // 獲取請求參數(shù)的類型
    Class<T> targetClass = (targetType instanceof Class ? (Class<T>) targetType : null);                
    if (targetClass == null) {   // 若 targetClass 是 null, 則通過工具類 ResolvableType 進(jìn)行解析                                                                        
        ResolvableType resolvableType = (parameter != null ? ResolvableType.forMethodParameter(parameter) : ResolvableType.forType(targetType));
        targetClass = (Class<T>) resolvableType.resolve();                                              // 獲取參數(shù)的類型
    }
    // 獲取請求的類型 HttpMethod (GET, POST, INPUT, DELETE 等)
    HttpMethod httpMethod = ((HttpRequest) inputMessage).getMethod();                                   
    Object body = NO_VALUE;
    try {
        inputMessage = new EmptyBodyCheckingHttpInputMessage(inputMessage);
        // 循環(huán)遍歷 HttpMessageConverter, 找出支持的 HttpMessageConverter
        for (HttpMessageConverter<?> converter : this.messageConverters) {                              
            Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
            // 下面分成兩類 HttpMessageConverter 分別處理
            if (converter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
                // 判斷 GenericHttpMessageConverter 是否支持 targetType + contextClass + contextType 這些類型
                if (genericConverter.canRead(targetType, contextClass, contentType)) {
                    logger.info("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    if (inputMessage.getBody() != null) { // 若處理后有 request 值
                        // 在通過 GenericHttpMessageConverter 處理前 過一下 Request 的 Advice <-- 其實(shí)就是個切面
                        inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
                        // 通過 GenericHttpMessageConverter 來處理請求的數(shù)據(jù)
                        body = genericConverter.read(targetType, contextClass, inputMessage);
                        // 在 GenericHttpMessageConverter 處理后在通過 Request 的 Advice 來做處理 <-- 其實(shí)就是個切面
                        body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
                    }
                    else { // 若處理后沒有值, 則通過 Advice 的 handleEmptyBody 方法來處理
                        body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
                    }
                    break;
                }
            }
            else if (targetClass != null) {
                // 判斷 HttpMessageConverter 是否支持 這種類型的數(shù)據(jù)
                if (converter.canRead(targetClass, contentType)) {
                    logger.info("Read [" + targetType + "] as \"" + contentType + "\" with [" + converter + "]");
                    if (inputMessage.getBody() != null) { // 若處理后有 request 值
                        // 在通過 HttpMessageConverter 處理前 過一下 Request 的 Advice <-- 其實(shí)就是個切面
                        inputMessage = getAdvice().beforeBodyRead(inputMessage, parameter, targetType, converterType);
                        // 通過 HttpMessageConverter 來處理請求的數(shù)據(jù)
                        body = ((HttpMessageConverter<T>) converter).read(targetClass, inputMessage);
                        // 在 HttpMessageConverter 處理后在通過 Request 的 Advice 來做處理 <-- 其實(shí)就是個切面
                        body = getAdvice().afterBodyRead(body, inputMessage, parameter, targetType, converterType);
                    }
                    else { // 若 Http 請求的 body 是 空, 則直接通過 Request/ResponseAdvice 來進(jìn)行處理
                        body = getAdvice().handleEmptyBody(null, inputMessage, parameter, targetType, converterType);
                    }
                    break;
                }
            }
        }
    } catch (IOException ex) {
        throw new HttpMessageNotReadableException("I/O error while reading input message", ex);
    }
    if (body == NO_VALUE) {  // 若 body 里面沒有數(shù)據(jù), 則
        if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) || (noContentType && inputMessage.getBody() == null)) return null;
        // 不滿足以上條件, 則報出異常
        throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
    }
    return body;
}

public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    // 獲取嵌套參數(shù) <- 有可能參數(shù)是用 Optional
    parameter = parameter.nestedIfOptional();   
    // 通過 HttpMessageConverter 來將數(shù)據(jù)轉(zhuǎn)換成合適的類型
    Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
    // 獲取參數(shù)的名字
    String name = Conventions.getVariableNameForParameter(parameter);
    // 構(gòu)建 WebDataBinder, 參數(shù)中的第二個值 arg 其實(shí)就是 DataBinder 的 target
    WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);  
    if (arg != null) {
        // @Validated 進(jìn)行參數(shù)的校驗(yàn)
        validateIfApplicable(binder, parameter);
        // 若有異常則直接暴出來
        if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
    }
    // 將綁定的結(jié)果保存在 ModelAndViewContainer 中
    mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
    // 對 Optional類型的參數(shù)的處理
    return adaptArgumentIfNecessary(arg, parameter);
}
@Override
protected <T> Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter, Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
    // 從 NativeWebRequest 中獲取  HttpServletRequest
    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    // 封裝 ServletServerHttpRequest
    ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
    // 通過 InputMessage 中讀取參數(shù)的內(nèi)容, 并且 通過 HttpMessageConverter 來將數(shù)據(jù)轉(zhuǎn)換成 paramType 類型的參數(shù)
    Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
    if (arg == null) {
        // 檢測參數(shù)是否是必需的
        if (checkRequired(parameter)) throw new HttpMessageNotReadableException("Required request body is missing: " + parameter.getMethod().toGenericString());
    }
    return arg; // 返回參數(shù)值
}