该篇博客介绍了调用的部分逻辑，这篇主要介绍了实现Controller接口和实现HttpRequestHandler接口这两种方式的调用，这两种方式比较简单，就是通过强转，然后调用目标方法即可，麻烦的是下面这种，通过@Controller注解声明的controller，在这篇博客中会仔细介绍
对于通过@Controller、@RequestMapping()这种通过注解，声明handlerMethod的方式，会分为以下三步：
1.对请求中的参数进行解析
2.调用目标方法
3.对返回参数进行解析
我们首先看下调用链，我们要说的代码，之前的解析逻辑就是下面这个调用链
org.springframework.web.servlet.DispatcherServlet#doDispatch
org.springframework.web.servlet.HandlerAdapter#handle
org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter#handle
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle
较为核心的方法，就在这里
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
/**
* 调用实际的目标方法
* 在这个方法中完成了两步操作
* 1.对参数的解析
* 2.对目标方法的调用
*/
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
setResponseStatus(webRequest);
/**
* 下面这里是对返回参数进行解析，举例：
* @ResponseBody 注解就是在下面这里被处理的
*/
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
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 {
/**
* 处理返回结果
* 如果返回结果是对象，并且加了 @ResponseBody的注解，那么spring内部维护了一个 HttpMessageConverters
*/
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 {
/**
* 第一步：解析入参
*/
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
"' with arguments " + Arrays.toString(args));
}
/**
* 第二步调用对应的方法，获取返回值
*/
Object returnValue = doInvoke(args);
if (logger.isTraceEnabled()) {
logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
"] returned [" + returnValue + "]");
}
return returnValue;
}
我们接着看具体的解析逻辑
下面这个方法，里面的逻辑就是这样的
1.获取到所有的入参
2.依次去解析每个入参，判断哪个参数解析器可以解析，然后进行解析
/**
* Get the method argument values for the current request.
* 从request中获取到当前方法的入参，也就是args
*/
private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable 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);
/**
* 下面这行代码，看注释的意思是：从提供的参数列表中获取对应的值，但是从前面的调用链中会发现，入参的providedArgs是null
*/
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
/**
* 遍历所有的参数解析器，看哪个解析器可以解析，如果参数解析器返回true，就表示可以解析
* 如果我们要扩展参数解析器，就需要看下这里的逻辑
* 需要学习下这里的argumentResolvers是在哪里赋值的
*/
if (this.argumentResolvers.supportsParameter(parameter)) {
try {
/**
* 这里就是用parameter对应的解析器去解析该参数
*/
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;
}
}
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;
}
下面这个方法就是具体判断的逻辑，举个例子：
比如我自定义了一个注解@XXXX，然后自定义一个参数解析器，就是用来解析这个自定义的注解，那就只需要在supportsParameter方法中判断，参数是否添加了@XXXX注解就可以，这个后面单独会介绍
/**
* 遍历所有的参数处理器，找到处理该parameter的处理器，然后存入到map集合中，
* 第二次获取处理该参数的处理器时，就无须再次遍历所有的support方法，直接从map缓存中获取即可
* @param parameter
* @return
*/
@Nullable
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
if (result == null) {
for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
if (logger.isTraceEnabled()) {
logger.trace("Testing if argument resolver [" + methodArgumentResolver + "] supports [" +
parameter.getGenericParameterType() + "]");
}
/**
* 核心方法就是这里，上面会遍历所有的参数解析器，依次去调用对应的supports方法，判断是否可以处理parameter
* 如果可以，就返回true，然后会把对应的methodArgumentResolver和对应的parameter关联起来
*/
if (methodArgumentResolver.supportsParameter(parameter)) {
result = methodArgumentResolver;
this.argumentResolverCache.put(parameter, result);
break;
}
}
}
return result;
}
下面这里是具体去处理的方法
@Override
@Nullable
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
/**
* 这个方法是实际解析参数的逻辑，首先会先获取到参数对应的解析器
*/
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
if (resolver == null) {
throw new IllegalArgumentException("Unknown parameter type [" + parameter.getParameterType().getName() + "]");
}
/**
* 这里调用的就是处理的方法
*/
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
二、调用目标方法
调用这里就不仔细说了，里面的逻辑也没多少
Object returnValue = doInvoke(args);
doInvoke中会调用method.invoke(obj,args);方法去调用目标方法
三、对返回值的处理
对返回值的出来，核心的方法在这里：
handleReturnValue
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite#handleReturnValue
@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
/**
* 拿到返回值之后，判断当前返回的对象，需要由哪个handler来处理，如果是json的话，是requestResponseBodyMethodProcessor来处理的
*/
HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
if (handler == null) {
throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
}
/**
* 这里是调用returnValueHandler的处理方法
*/
handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
其实对返回值的处理逻辑，思想和参数解析是基本一样的，先判断解析类是否支持解析该返回值，如果支持解析该返回值的话，就调用对应的解析方法
@Nullable
private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) {
boolean isAsyncValue = isAsyncReturnValue(value, returnType);
for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
continue;
}
if (handler.supportsReturnType(returnType)) {
return handler;
}
}
return null;
}
我们以@ResponseBody注解为例来看下，在得到返回值之后，就判断方法或者类上是否有添加@ResponseBody注解
/**
* 处理@ResponseBody注解修饰的方法，在获取到方法的返回值之后，会通过该类对返回值进行处理
* @param returnType the method return type to check
* @return
*/
@Override
public boolean supportsReturnType(MethodParameter returnType) {
return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
returnType.hasMethodAnnotation(ResponseBody.class));
}
以上就是对方法参数的解析、方法调用、返回值解析的逻辑，其实也比较简单：
1、首先遍历所有的参数解析器，判断是否支持解析该参数，如果支持，就解析
2、通过method.invoke()调用目标方法
3、对返回值进行判断处理，和参数解析的思想一致，这里用到的应该就是适配器模式