SpringMVC原始碼之引數解析繫結原理

Java菜分享發表於2019-03-28
SpringMVC原始碼

摘要

  • 本文從原始碼層面簡單講解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";
    }
}
複製程式碼


SpringMVC原始碼之引數解析繫結原理


  • 請求進入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";
}
複製程式碼


SpringMVC原始碼之引數解析繫結原理


  • 這個請求的引數解析繫結便會交給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結構如下圖
SpringMVC原始碼之引數解析繫結原理

  • 建立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方法，引數注入便會失敗。

引數解析繫結總結

  1. SpringMVC初始化時，RequestMappingHandlerAdapter類會把一些預設的引數解析器新增到argumentResolvers中。當SpringMVC接收到請求後首先根據url查詢對應的HandlerMethod。
  2. 遍歷HandlerMethod的MethodParameter陣列
  3. 根據MethodParameter的型別來查詢確認使用哪個HandlerMethodArgumentResolver，遍歷所有的argumentResolvers的supportsParameter(MethodParameter parameter)方法。。如果返回true，則表示查詢成功，當前MethodParameter，使用該HandlerMethodArgumentResolver。這裡確認大多都是根據引數的註解已經引數的Type來確認。
  4. 解析引數，從request中解析出MethodParameter對應的引數，這裡解析出來的結果都是String型別。
  5. 轉換引數，把對應String轉換成具體方法所需要的型別，這裡就包括了基本型別、物件、List、Set、Map。

歡迎工作一到五年的Java工程師朋友們加入Java程式設計師開發： 721575865

群內提供免費的Java架構學習資料（裡面有高可用、高併發、高效能及分散式、Jvm效能調優、Spring原始碼，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料）合理利用自己每一分每一秒的時間來學習提升自己，不要再用"沒有時間“來掩飾自己思想上的懶惰！趁年輕，使勁拼，給未來的自己一個交代！


相關文章