Spring MVC--参数解析与方法执行

public interface HandlerAdapter {
  /**
   * 判断是否支持当前的handler适配
   */
	boolean supports(Object handler);
  /**
   * 具体的处理适配
   */
	ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
    .....
}

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  for (HandlerAdapter ha : this.handlerAdapters) {
    // 判断是否支持,支持则返回
    if (ha.supports(handler)) {
      return ha;
    }
  }
  throw new ServletException("No adapter for handler [" + handler +
      "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

public final boolean supports(Object handler) {
	return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
}
   // 把请求转到具体的子类
protected abstract ModelAndView handleInternal(HttpServletRequest request,
		HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;

protected ModelAndView handleInternal(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    ... 
    // 调用invokeHandlerMethod方法拿到对应的结果
    mav = invokeHandlerMethod(request, response, handlerMethod);
    ...
    return mav;
	}

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

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
      // 参数转换以及绑定类工厂
      WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
      // 结果转换生成工厂
	ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
      // 包装要执行的方法HandlerMethod
      ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
      // 加入参数解析器
      invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
      // 加入返回值解析器
      invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
      // 加入转换工厂
      invocableMethod.setDataBinderFactory(binderFactory);
      // 用户获取方法参数名的service
			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
      .....
      // 调用方法
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}
      // 取出结果并进行封装
			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
  Object...providedArgs) throws Exception {
  // 获取要执行的方法参数封装
  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);
    // 优先使用方法传来的参数
    args[i] = resolveProvidedArgument(parameter, providedArgs);
    if (args[i] != null) {
      continue;
    }
    // 使用参数解析器去解析参数
    if (this.argumentResolvers.supportsParameter(parameter)) {
      try {
        args[i] = this.argumentResolvers.resolveArgument(
          parameter, mavContainer, request, this.dataBinderFactory);
        continue;
      } catch (Exception ex) {
        throw ex;
      }
    }
    ...
  }
  return args;
}

public interface HandlerMethodArgumentResolver {
  /**
   * 是否支持该参数的解析.
   */
	boolean supportsParameter(MethodParameter parameter);
	/**
   * 解析操作
   */
	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 {
    ...
    // 获取要获取的参数名称
		Object resolvedName = resolveStringValue(namedValueInfo.name);
    // 根据参数名从request中取出结果,这一步延迟到子类中实现,降低子类的复杂度.
		Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    ...
    // 使用WebDataBinder转换到需要的类型
		if (binderFactory != null) {
			WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
			try {
				arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
			}
			...
		}
		handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
		return arg;
	}

public final Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    // 获取参数名
    String name = ModelFactory.getNameForParameter(parameter);
    // 获取该参数实例,该方法实质上使用无参构造函数创建实例
    Object attribute = (mavContainer.containsAttribute(name) ? mavContainer.getModel().get(name) :
            createAttribute(name, parameter, binderFactory, webRequest));
    ...
    // 创建绑定
    WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
    if (binder.getTarget() != null) {
        if (!mavContainer.isBindingDisabled(name)) {
        // 按照名称进行参数绑定
        bindRequestParameters(binder, webRequest);
      }
      // 如果有必要则进行验证
        validateIfApplicable(binder, parameter);
        if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
            throw new BindException(binder.getBindingResult());
        }
    }
    // 转换为参数需要的类型
    return binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
}

public class StringToEnumConvert implements ConverterFactory<String,Enum> {
  @Override
  @SuppressWarnings("unchecked")
  public <T extends Enum> Converter<String, T> getConverter(Class<T> aClass) {
    return s -> (T)Enum.valueOf(aClass, s.trim());
  }
}

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {

  @Override
  public void addFormatters(FormatterRegistry registry) {
    //添加字符串到枚举类的转换
    registry.addConverterFactory(new StringToEnumConvert());
  }
}

protected Object doInvoke(Object... args) throws Exception {
	ReflectionUtils.makeAccessible(getBridgedMethod());
	try {
               // 获取用户方法执行
		return getBridgedMethod().invoke(getBean(), args);
	}
       ....
}