摘要
- 本文從原始碼層面簡單講解SpringMVC的引數繫結原理
SpringMVC引數繫結相關元件的初始化過程
- 在理解初始化之前，先來認識一個介面
HandlerMethodArgumentResolver
- 方法引數解析器介面，這個介面是SpringMVC引數解析繫結的核心介面。不同的引數型別繫結都是通過實現這個介面來實現。也可以通過實現這個介面來自定義引數解析器。這個介面中有如下兩個方法
public interface HandlerMethodArgumentResolver {
//該解析器是否支援parameter引數的解析
boolean supportsParameter(MethodParameter parameter);
//將方法引數從給定請求(webRequest)解析為引數值並返回
Object resolveArgument(MethodParameter parameter,
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest,
WebDataBinderFactory binderFactory) throws Exception;
}
複製程式碼初始化
- RequestMappingHandlerAdapter.java類的afterPropertiesSet（line:481）方法初始化相關方法引數解析器。程式碼如下
public void afterPropertiesSet() {
if (this.argumentResolvers == null) {
//初始化SpringMVC預設的方法引數解析器，並新增至argumentResolvers（HandlerMethodArgumentResolverComposite）
List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
if (this.initBinderArgumentResolvers == null) {
//初始化SpringMVC預設的初始化繫結器(@InitBinder)引數解析器，並新增至initBinderArgumentResolvers（HandlerMethodArgumentResolverComposite）
List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
if (this.returnValueHandlers == null) {
//獲取預設的方法返回值解析器
List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
}
initControllerAdviceCache();
}
複製程式碼- 現在我們進入getDefalutArgumentResolvers方法，程式碼如下
//預設的引數解析，建立了預設的24個引數解析器，並新增至resolvers
//這裡的24個引數解析器都是針對不同的引數型別來解析的
private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();
// 基於註解的引數解析器
//一般用於帶有@RequestParam註解的簡單引數繫結，簡單引數比如byte、int、long、double、String以及對應的包裝型別
resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
//用於處理帶有@RequestParam註解，且引數型別為Map的解析繫結
resolvers.add(new RequestParamMapMethodArgumentResolver());
//一般用於處理帶有@PathVariable註解的預設引數繫結
resolvers.add(new PathVariableMethodArgumentResolver());
//也是用於帶有@PathVariable註解的Map相關引數繫結，後續還有一些預設的引數解析器。後續還有一些引數解析器，我這裡都不一一解釋了。想具體確認某個引數會交個哪個引數解析器處理，可以通過以下解析器的supportsParameter(MethodParameter parameter)方法得知
resolvers.add(new PathVariableMapMethodArgumentResolver());
resolvers.add(new MatrixVariableMethodArgumentResolver());
resolvers.add(new MatrixVariableMapMethodArgumentResolver());
resolvers.add(new ServletModelAttributeMethodProcessor(false));
resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));
resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
resolvers.add(new RequestHeaderMapMethodArgumentResolver());
resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
// 基於型別的引數解析器
resolvers.add(new ServletRequestMethodArgumentResolver());
resolvers.add(new ServletResponseMethodArgumentResolver());
resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));
resolvers.add(new RedirectAttributesMethodArgumentResolver());
resolvers.add(new ModelMethodProcessor());
resolvers.add(new MapMethodProcessor());
resolvers.add(new ErrorsMethodArgumentResolver());
resolvers.add(new SessionStatusMethodArgumentResolver());
resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
// Custom arguments
if (getCustomArgumentResolvers() != null) {
resolvers.addAll(getCustomArgumentResolvers());
}
複製程式碼- 引數解析器新增至HandlerMethodArgumentResolverComposite這個類，這個也是實現了HandlerMethodArgumentResolver介面。這裡運用涉及模式中的composite模式（組合模式），SpringMVC中，所有請求的引數解析都是進入HandlerMethodArgumentResolverComposite類來完成的。它有兩個成員變數，如下
//它的元素在RequestMappingHandlerAdapter類的afterPropertiesSet方法中被新增，存放的是SpringMVC一些預設的HandlerMethodArgumentResolver引數解析器
private final List<HandlerMethodArgumentResolver> argumentResolvers =
new LinkedList<HandlerMethodArgumentResolver>();
//存放已經解析過的引數，已經對應的HandlerMethodArgumentResolver解析器。加快查詢過程
private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache =
new ConcurrentHashMap<MethodParameter, HandlerMethodArgumentResolver>(256);
複製程式碼- 介紹了這麼多，話不多說。直接來看一個詳細解析繫結過程吧
繫結過程
- 先看一個簡單引數繫結，有如下Controller和請求,程式碼如下。
@Controller
@RequestMapping("/ParameterBind")
public class ParameterBindTestController {
@ResponseBody
@RequestMapping("/test1")
public String test1(int id){
System.out.println(id);
return "test1";
}
}
複製程式碼- 請求進入DispatcherServlet的doDispatch後，獲取HandlerMethod。然後根據HandlerMethod來確認HandlerApapter，確認後執行HandlerAdapter的handle方法。這裡確認HandlerApater為RequestMappingHandlerAdapter，在執行handlerMethod之前，需要處理引數的繫結。然後看看詳細的引數繫結過程
- 執行HandlerAdapter的handler方法後，進入RequestMappingHandlerAdapter的invokeHandleMethod方法（line:711）
private ModelAndView invokeHandleMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
//根據handlerMethod和binderFactory建立一個ServletInvocableHandlerMethod。後續把請求直接交給ServletInvocableHandlerMethod執行。
//createRequestMappingMethod方法比較簡單，把之前RequestMappingHandlerAdapter初始化的argumentResolvers和returnValueHandlers新增至ServletInvocableHandlerMethod中
ServletInvocableHandlerMethod requestMappingMethod = createRequestMappingMethod(handlerMethod, binderFactory);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
asyncWebRequest.setTimeout(this.asyncRequestTimeout);
final 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();
if (logger.isDebugEnabled()) {
logger.debug("Found concurrent result value [" + result + "]");
}
requestMappingMethod = requestMappingMethod.wrapConcurrentResult(result);
}
requestMappingMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
return getModelAndView(mavContainer, modelFactory, webRequest);
}
複製程式碼- 然後進入invokeAndHanldle方法，然後進入invokeForRequest方法，這個方法的職責是從request中解析出HandlerMethod方法所需要的引數，然後通過反射呼叫HandlerMethod中的method。程式碼如下
public final Object invokeForRequest(NativeWebRequest request,
ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//從request中解析出HandlerMethod方法所需要的引數，並返回Object[]
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
StringBuilder builder = new StringBuilder("Invoking [");
builder.append(this.getMethod().getName()).append("] method with arguments ");
builder.append(Arrays.asList(args));
logger.trace(builder.toString());
}
//通過反射執行HandleMethod中的method，方法引數為args。並返回方法執行的返回值
Object returnValue = invoke(args);
if (logger.isTraceEnabled()) {
logger.trace("Method [" + this.getMethod().getName() + "] returned [" + returnValue + "]");
}
return returnValue;
}
複製程式碼- 直接進入getMethodArgumentValues方法看看其過程，程式碼如下
/**
* 獲取當前請求的方法引數值。
*/
private Object[] getMethodArgumentValues(
NativeWebRequest request, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//獲取方法引數陣列
MethodParameter[] parameters = getMethodParameters();
//建立一個引數陣列，儲存從request解析出的方法引數
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(parameterNameDiscoverer);
GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
//判斷之前RequestMappingHandlerAdapter初始化的那24個HandlerMethodArgumentResolver（引數解析器），是否存在支援該引數解析的解析器
if (argumentResolvers.supportsParameter(parameter)) {
try {
args[i] = argumentResolvers.resolveArgument(parameter, mavContainer, request, dataBinderFactory);
continue;
} catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);
}
throw ex;
}
}
if (args[i] == null) {
String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);
throw new IllegalStateException(msg);
}
}
return args;
}
複製程式碼- 進入HandlerMethodArgumentResolverComposite的resolveArgument方法
public Object resolveArgument(
MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
throws Exception {
//首先獲取引數解析器，這裡獲取的邏輯是首先從argumentResolverCache快取中獲取該MethodParameter匹配的HandlerMethodArgumentResolver。如果為空，遍歷初始化定義的那24個。查詢匹配的HandlerMethodArgumentResolver，然後新增至argumentResolverCache快取中
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
Assert.notNull(resolver, "Unknown parameter type [" + parameter.getParameterType().getName() + "]");
//解析引數
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
複製程式碼- 然後進入HandlerMethodArgumentResolver的resolverArgument方法
public final Object resolveArgument(
MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
throws Exception {
//獲取int的Class物件
Class<?> paramType = parameter.getParameterType();
//根據引數定義建立一個NamedValueInfo物件
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
//根據引數名解析出物件的值
Object arg = resolveName(namedValueInfo.name, parameter, webRequest);
if (arg == null) {
if (namedValueInfo.defaultValue != null) {
arg = resolveDefaultValue(namedValueInfo.defaultValue);
}
else if (namedValueInfo.required) {
handleMissingValue(namedValueInfo.name, parameter);
}
arg = handleNullValue(namedValueInfo.name, arg, paramType);
}
else if ("".equals(arg) && (namedValueInfo.defaultValue != null)) {
arg = resolveDefaultValue(namedValueInfo.defaultValue);
}
//上面步驟獲取的args是String型別，然後轉換為方法引數所需要的型別(int)
if (binderFactory != null) {
WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
arg = binder.convertIfNecessary(arg, paramType, parameter);
}
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
return arg;
}
複製程式碼- 這個方法的職責是，首先獲取paramType。也就是int對應的Class物件。然後根據parameter物件建立一個NamedValueInfo物件。這個物件存放的就是引數名、是否必須、引數預設值3個成員變數。然後進入resolverName方法解析引數，裡面的邏輯其實很簡單，就是根據方法的引數名來獲取request中的引數。關鍵程式碼如下
String[] paramValues = webRequest.getParameterValues(name);
if (paramValues != null) {
arg = paramValues.length == 1 ? paramValues[0] : paramValues;
}
複製程式碼所以這裡返回的值就是9999,這裡返回的值還是String型別的。而需要的引數是int型別的。然後通過binder.coverIfNecessary方法把String轉換為int型別返回。
物件繫結
- 新加一個方法，程式碼如下
@ResponseBody
@RequestMapping("/test2")
public String test2(User u){
System.out.println(u.toString());
return "test1";
}
複製程式碼- 這個請求的引數解析繫結便會交給ServletModelAttributeMethodProcessor這個類，在初始化argumentResolvers的時候。是會建立兩個不同的ServletModelAttributeMethodProcessor物件的。
resolvers.add(new ServletModelAttributeMethodProcessor(false));
resolvers.add(new ServletModelAttributeMethodProcessor(true));
複製程式碼- 這兩個有什麼區別？進入supportsParameter方法看看
/**
*帶有@ModelAttribute註解返回true
* parameter不是簡單型別也返回true.
*/
public boolean supportsParameter(MethodParameter parameter) {
if (parameter.hasParameterAnnotation(ModelAttribute.class)) {
return true;
}
else if (this.annotationNotRequired) {
return !BeanUtils.isSimpleProperty(parameter.getParameterType());
}
else {
return false;
}
}
複製程式碼- 雖然test2(User u)方法沒有ModelAttribute註解，但是User.class不是簡單型別。所以該MethodHandler的引數u還是會交給ServletModelAtttributeMethodProcessor處理。
- 看看ServletModelAttributeMethodProcessor的resolveArgument方法。它的resolveArgument是由父類ModelAttributeMethodProcessor具體實現的，程式碼如下。
/**
* 解析model中的引數，如果從ModelAndViewContainer未找到，直接通過反射例項化一個物件。具體例項化是通過父類的createAttribute方法，通過呼叫BeanUtils.instantiateClass方法來例項化的。這個物件便是後續傳給test2(User u)方法的物件，但是此時建立的物件裡面的值都還為空，注入值是通過bindRequestParameters方法來實現的。
*/
public final Object resolveArgument(
MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest request, WebDataBinderFactory binderFactory)
throws Exception {
String name = ModelFactory.getNameForParameter(parameter);
Object attribute = (mavContainer.containsAttribute(name)) ?
mavContainer.getModel().get(name) : createAttribute(name, parameter, binderFactory, request);
WebDataBinder binder = binderFactory.createBinder(request, attribute, name);
if (binder.getTarget() != null) {
//將請求繫結至目標binder的target物件，也就是剛剛建立的attribute物件。
bindRequestParameters(binder, request);
//如果有驗證，則驗證引數
validateIfApplicable(binder, parameter);
if (binder.getBindingResult().hasErrors()) {
if (isBindExceptionRequired(binder, parameter)) {
throw new BindException(binder.getBindingResult());
}
}
}
// Add resolved attribute and BindingResult at the end of the model
Map<String, Object> bindingResultModel = binder.getBindingResult().getModel();
mavContainer.removeAttributes(bindingResultModel);
mavContainer.addAllAttributes(bindingResultModel);
return binder.getTarget();
}
複製程式碼- 該方法的職責是例項化一個parameterType的物件，然後根據request和attribute、name建立一個WebDataBinder物件，其中。然後進入bindRequestParameters方法繫結，根據reqeust中的引數建立一個MutablePropertyValues物件。MutablePropertyValues裡面存放了一個或多個PropertyValue，其中PropertyValue用於儲存單個bean屬性的相關資訊，比如引數名、引數值。這裡需要注意的是PropertyValue並不是儲存request物件的所有引數屬性資訊。而是一個引數屬性對應一個PropertyValue。比如這裡的reqeust物件，攜帶了兩個引數，name和age，便會分別建立兩個PropertyValue物件。對應的MutablePropertyValues結構如下圖
- 建立MutablePropertyValues物件化後，進入DataBinder.applyPropertyValues(DataBinder.java line737)。會根據剛剛建立的User物件。建立一個BeanWrapperImpl物件，BeanWrapperImpl實現了PropertyAccessor（屬性訪問器）介面。這是spring-bean下的一個類，在Sping中，對Bean屬性的存取都是通過BeanWrapperImpl類來實現的。BeanWarapperImpl在這裡作用就是通過PropertyValue中的屬性相關描述，注入到BeanWarapperImpl對應的java物件的屬性中去。具體注入的方法是setPropertyValues，這個方法略複雜。它的職責簡單總結起來就是根據屬性名呼叫對應的set...方法。比如注入User物件的name屬性時，通過反射獲取setName方法。如果有該方法便呼叫。這也是為什麼在定義SpringMVC model 物件需要set...方法。如果沒有set方法，引數注入便會失敗。
引數解析繫結總結
- SpringMVC初始化時，RequestMappingHandlerAdapter類會把一些預設的引數解析器新增到argumentResolvers中。當SpringMVC接收到請求後首先根據url查詢對應的HandlerMethod。
- 遍歷HandlerMethod的MethodParameter陣列
- 根據MethodParameter的型別來查詢確認使用哪個HandlerMethodArgumentResolver，遍歷所有的argumentResolvers的supportsParameter(MethodParameter parameter)方法。。如果返回true，則表示查詢成功，當前MethodParameter，使用該HandlerMethodArgumentResolver。這裡確認大多都是根據引數的註解已經引數的Type來確認。
- 解析引數，從request中解析出MethodParameter對應的引數，這裡解析出來的結果都是String型別。
- 轉換引數，把對應String轉換成具體方法所需要的型別，這裡就包括了基本型別、物件、List、Set、Map。
歡迎工作一到五年的Java工程師朋友們加入Java程式設計師開發： 721575865
群內提供免費的Java架構學習資料（裡面有高可用、高併發、高效能及分散式、Jvm效能調優、Spring原始碼，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料）合理利用自己每一分每一秒的時間來學習提升自己，不要再用"沒有時間“來掩飾自己思想上的懶惰！趁年輕，使勁拼，給未來的自己一個交代！