springmvc工做原理以及源碼分析(基於spring3.1.0)

時間 2019-11-11

標籤 springmvc 原理以及源碼分析基於 spring3.1.0 spring 欄目 Spring 简体版

原文原文鏈接

　　springmvc是一個基於spring的web框架.本篇文章對它的工做原理以及源碼進行深刻分析.前端

　　1、springmvc請求處理流程web

　　2、springmvc的工做機制spring

　　3、springmvc核心源碼分析設計模式

　　4、談談springmvc的優化數組

1、springmvc請求處理流程

　　引用spring in action上的一張圖來講明瞭springmvc的核心組件和請求處理流程:緩存

　　①：DispatcherServlet是springmvc中的前端控制器(front controller),負責接收request並將request轉發給對應的處理組件.tomcat

　　②：HanlerMapping是springmvc中完成url到controller映射的組件.DispatcherServlet接收request,而後從HandlerMapping查找處理request的controller.安全

　　③：Cntroller處理request,並返回ModelAndView對象,Controller是springmvc中負責處理request的組件(相似於struts2中的Action),ModelAndView是封裝結果視圖的組件.cookie

　　④ ⑤ ⑥：視圖解析器解析ModelAndView對象並返回對應的視圖給客戶端.session

2、springmvc的工做機制

　　在容器初始化時會創建全部url和controller的對應關係,保存到Map<url,controller>中.tomcat啓動時會通知spring初始化容器(加載bean的定義信息和初始化全部單例bean),而後springmvc會遍歷容器中的bean,獲取每個controller中的全部方法訪問的url,而後將url和controller保存到一個Map中;

　　這樣就能夠根據request快速定位到controller,由於最終處理request的是controller中的方法,Map中只保留了url和controller中的對應關係,因此要根據request的url進一步確認controller中的method,這一步工做的原理就是拼接controller的url(controller上@RequestMapping的值)和方法的url(method上@RequestMapping的值),與request的url進行匹配,找到匹配的那個方法;　　

　　肯定處理請求的method後,接下來的任務就是參數綁定,把request中參數綁定到方法的形式參數上,這一步是整個請求處理過程當中最複雜的一個步驟。springmvc提供了兩種request參數與方法形參的綁定方法:

　　① 經過註解進行綁定,@RequestParam

　　② 經過參數名稱進行綁定.
　　使用註解進行綁定,咱們只要在方法參數前面聲明@RequestParam("a"),就能夠將request中參數a的值綁定到方法的該參數上.使用參數名稱進行綁定的前提是必需要獲取方法中參數的名稱,Java反射只提供了獲取方法的參數的類型,並無提供獲取參數名稱的方法.springmvc解決這個問題的方法是用asm框架讀取字節碼文件,來獲取方法的參數名稱.asm框架是一個字節碼操做框架,關於asm更多介紹能夠參考它的官網.我的建議,使用註解來完成參數綁定,這樣就能夠省去asm框架的讀取字節碼的操做.

3、源代碼的分析

　咱們根據工做機制中三部分來分析springmvc的源代碼.

　　　　其一,ApplicationContext初始化時創建全部url和controller類的對應關係(用Map保存);

　　　　其二,根據請求url找到對應的controller,並從controller中找處處理請求的方法;

　　　　其三,request參數綁定到方法的形參,執行方法處理請求,並返回結果視圖.

第一步、創建Map<urls,controller>的關係

　　咱們首先看第一個步驟,也就是創建Map<url,controller>關係的部分.第一部分的入口類爲ApplicationObjectSupport的setApplicationContext方法.setApplicationContext方法中核心部分就是初始化容器initApplicationContext(context),子類AbstractDetectingUrlHandlerMapping實現了該方法,因此咱們直接看子類中的初始化容器方法.

public void initApplicationContext() throws ApplicationContextException {
        super.initApplicationContext();
        detectHandlers();
    }
    /**
　　  * 創建當前ApplicationContext中的全部controller和url的對應關係
　　　 */
    protected void detectHandlers() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
        }
　　　　 // 獲取ApplicationContext容器中全部bean的Name
        String[] beanNames = (this.detectHandlersInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                getApplicationContext().getBeanNamesForType(Object.class));

        // 遍歷beanNames,並找到這些bean對應的url
        for (String beanName : beanNames) {
　　　　　　 // 找bean上的全部url(controller上的url+方法上的url),該方法由對應的子類實現
            String[] urls = determineUrlsForHandler(beanName);
            if (!ObjectUtils.isEmpty(urls)) {
                // 保存urls和beanName的對應關係,put it to Map<urls,beanName>,該方法在父類AbstractUrlHandlerMapping中實現
                registerHandler(urls, beanName);
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
                }
            }
        }
    }
    /** 獲取controller中全部方法的url,由子類實現,典型的模板模式 **/
　　protected abstract String[] determineUrlsForHandler(String beanName);

View Code

　　determineUrlsForHandler(String beanName)方法的做用是獲取每一個controller中的url,不一樣的子類有不一樣的實現,這是一個典型的模板設計模式.由於開發中咱們用的最多的就是用註解來配置controller中的url,DefaultAnnotationHandlerMapping是AbstractDetectingUrlHandlerMapping的子類,處理註解形式的url映射.因此咱們這裏以DefaultAnnotationHandlerMapping來進行分析.咱們看DefaultAnnotationHandlerMapping是如何查beanName上全部映射的url.

　/**
　　 * 獲取controller中全部的url
     */
　　protected String[] determineUrlsForHandler(String beanName) {
       // 獲取ApplicationContext容器 
　　　　ApplicationContext context = getApplicationContext();
        //從容器中獲取controller
　　　　 Class<?> handlerType = context.getType(beanName);
　　　　 // 獲取controller上的@RequestMapping註解
        RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
        if (mapping != null) { // controller上有註解
            this.cachedMappings.put(handlerType, mapping);
　　　　　　  // 返回結果集
            Set<String> urls = new LinkedHashSet<String>();
　　　　　　  // controller的映射url
            String[] typeLevelPatterns = mapping.value();
            if (typeLevelPatterns.length > 0) { // url>0
                // 獲取controller中全部方法及方法的映射url
                String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType, true);
                for (String typeLevelPattern : typeLevelPatterns) {
                    if (!typeLevelPattern.startsWith("/")) {
                        typeLevelPattern = "/" + typeLevelPattern;
                    }
                    boolean hasEmptyMethodLevelMappings = false;
                    for (String methodLevelPattern : methodLevelPatterns) {
                        if (methodLevelPattern == null) {
                            hasEmptyMethodLevelMappings = true;
                        }
                        else {
　　　　　　　　　　　　　　　　// controller的映射url+方法映射的url
                            String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
　　　　　　　　　　　　　　　　// 保存到set集合中
　　　　　　　　　　　　　　　　 addUrlsForPath(urls, combinedPattern);
                        }
                    }
                    if (hasEmptyMethodLevelMappings ||
                            org.springframework.web.servlet.mvc.Controller.class.isAssignableFrom(handlerType)) {
                        addUrlsForPath(urls, typeLevelPattern);
                    }
                }
　　　　　　　　　// 以數組形式返回controller上的全部url
                return StringUtils.toStringArray(urls);
            }
            else {
                // controller上的@RequestMapping映射url爲空串,直接找方法的映射url
                return determineUrlsForHandlerMethods(handlerType, false);
            }
        } // controller上沒@RequestMapping註解
        else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
            // 獲取controller中方法上的映射url
            return determineUrlsForHandlerMethods(handlerType, false);
        }
        else {
            return null;
        }
    }

View Code

　　到這裏HandlerMapping組件就已經創建全部url和controller的對應關係。

第二步、根據訪問url找到對應controller中處理請求的方法.

　　下面咱們開始分析第二個步驟,第二個步驟是由請求觸發的,因此入口爲DispatcherServlet.DispatcherServlet的核心方法爲doService(),doService()中的核心邏輯由doDispatch()實現,咱們查看doDispatch()的源代碼.

/** 中央控制器,控制請求的轉發 **/
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        int interceptorIndex = -1;

        try {
            ModelAndView mv;
            boolean errorView = false;
            try {
　　　　　　　　　// 1.檢查是不是文件上傳的請求
                processedRequest = checkMultipart(request);

                // 2.取得處理當前請求的controller,這裏也稱爲hanlder,處理器,第一個步驟的意義就在這裏體現了.這裏並非直接返回controller,而是返回的HandlerExecutionChain請求處理器鏈對象,該對象封裝了handler和interceptors.
                mappedHandler = getHandler(processedRequest, false);
　　　　　　　　　// 若是handler爲空,則返回404
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }
                //3. 獲取處理request的處理器適配器handler adapter 
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                // 處理 last-modified 請求頭
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (logger.isDebugEnabled()) {
                        String requestUri = urlPathHelper.getRequestUri(request);
                        logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                // 4.攔截器的預處理方法
                HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
                if (interceptors != null) {
                    for (int i = 0; i < interceptors.length; i++) {
                        HandlerInterceptor interceptor = interceptors[i];
                        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
                            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
                            return;
                        }
                        interceptorIndex = i;
                    }
                }

                // 5.實際的處理器處理請求,返回結果視圖對象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                // 結果視圖對象的處理
                if (mv != null && !mv.hasView()) {
                    mv.setViewName(getDefaultViewName(request));
                }

                // 6.攔截器的後處理方法
                if (interceptors != null) {
                    for (int i = interceptors.length - 1; i >= 0; i--) {
                        HandlerInterceptor interceptor = interceptors[i];
                        interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
                    }
                }
            }
            catch (ModelAndViewDefiningException ex) {
                logger.debug("ModelAndViewDefiningException encountered", ex);
                mv = ex.getModelAndView();
            }
            catch (Exception ex) {
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                mv = processHandlerException(processedRequest, response, handler, ex);
                errorView = (mv != null);
            }

            
            if (mv != null && !mv.wasCleared()) {
                render(mv, processedRequest, response);
                if (errorView) {
                    WebUtils.clearErrorRequestAttributes(request);
                }
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                            "': assuming HandlerAdapter completed request handling");
                }
            }

            // 請求成功響應以後的方法
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
        }

　　第2步:getHandler(processedRequest)方法實際上就是從HandlerMapping中找到url和controller的對應關係.這也就是第一個步驟:創建Map<url,Controller>的意義.咱們知道,最終處理request的是controller中的方法,咱們如今只是知道了controller,還要進一步確認controller中處理request的方法.因爲下面的步驟和第三個步驟關係更加緊密,直接轉到第三個步驟.

第三步、反射調用處理請求的方法,返回結果視圖

　　上面的方法中,第2步其實就是從第一個步驟中的Map<urls,beanName>中取得controller,而後通過攔截器的預處理方法,到最核心的部分--第5步調用controller的方法處理請求.在第2步中咱們能夠知道處理request的controller,第5步就是要根據url肯定controller中處理請求的方法,而後經過反射獲取該方法上的註解和參數,解析方法和參數上的註解,最後反射調用方法獲取ModelAndView結果視圖。由於上面採用註解url形式說明的,因此咱們這裏繼續以註解處理器適配器來講明.第5步調用的就是AnnotationMethodHandlerAdapter的handle().handle()中的核心邏輯由invokeHandlerMethod(request, response, handler)實現。

/** 獲取處理請求的方法,執行並返回結果視圖 **/
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
　　　　 // 1.獲取方法解析器
        ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
　　　　 // 2.解析request中的url,獲取處理request的方法 
        Method handlerMethod = methodResolver.resolveHandlerMethod(request);
　　　　 // 3.方法調用器
        ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        ExtendedModelMap implicitModel = new BindingAwareModelMap();
　　　　 // 4.執行方法
        Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
　　　　 // 5.封裝結果視圖
        ModelAndView mav =
                methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
        methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
        return mav;
    }

　　這一部分的核心就在2和4了.先看第2步,經過request找controller的處理方法.實際上就是拼接controller的url和方法的url,與request的url進行匹配,找到匹配的方法.

/** 根據url獲取處理請求的方法 **/
public Method resolveHandlerMethod(HttpServletRequest request) throws ServletException {
　　　　　　  // 若是請求url爲,localhost:8080/springmvc/helloWorldController/say.action, 則lookupPath=helloWorldController/say.action
            String lookupPath = urlPathHelper.getLookupPathForRequest(request);
            Comparator<String> pathComparator = pathMatcher.getPatternComparator(lookupPath);
            Map<RequestSpecificMappingInfo, Method> targetHandlerMethods = new LinkedHashMap<RequestSpecificMappingInfo, Method>();
            Set<String> allowedMethods = new LinkedHashSet<String>(7);
            String resolvedMethodName = null;
　　　　　　 // 遍歷controller上的全部方法,獲取url匹配的方法
            for (Method handlerMethod : getHandlerMethods()) {
                RequestSpecificMappingInfo mappingInfo = new RequestSpecificMappingInfo(this.mappings.get(handlerMethod));
                boolean match = false;
                if (mappingInfo.hasPatterns()) {// 獲取方法上的url
                    for (String pattern : mappingInfo.getPatterns()) { // 方法上可能有多個url,springmvc支持方法映射多個url
                        if (!hasTypeLevelMapping() && !pattern.startsWith("/")) {
                            pattern = "/" + pattern;
                        }
　　　　　　　　　　　　　　// 獲取controller上的映射和url和方法上的url,拼湊起來與lookupPath是否匹配
                        String combinedPattern = getCombinedPattern(pattern, lookupPath, request);
                        if (combinedPattern != null) { 
                            if (mappingInfo.matches(request)) {
                                match = true;
                                mappingInfo.addMatchedPattern(combinedPattern);
                            }
                            else {
                                if (!mappingInfo.matchesRequestMethod(request)) {
                                    allowedMethods.addAll(mappingInfo.methodNames());
                                }
                                break;
                            }
                        }
                    }
                    mappingInfo.sortMatchedPatterns(pathComparator);
                }
                else if (useTypeLevelMapping(request)) {
              　// other 
        }

　　經過上面的代碼,已經能夠找處處理request的controller中的方法了,如今看如何解析該方法上的參數,並調用該方法。也就是執行方法這一步.執行方法這一步最重要的就是獲取方法的參數,而後咱們就能夠反射調用方法了.

    public final Object invokeHandlerMethod(Method handlerMethod, Object handler,
            NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
       
　　　　 Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
        try {
            boolean debug = logger.isDebugEnabled();
　　　　　　　// 處理方法上的其餘註解
            for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
                Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
                if (attrValue != null) {
                    implicitModel.addAttribute(attrName, attrValue);
                }
            }
            for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
                Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
                Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
                if (debug) {
                    logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
                }
                String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
                if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
                    continue;
                }
                ReflectionUtils.makeAccessible(attributeMethodToInvoke);
                Object attrValue = attributeMethodToInvoke.invoke(handler, args);
                if ("".equals(attrName)) {
                    Class resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
                    attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
                }
                if (!implicitModel.containsAttribute(attrName)) {
                    implicitModel.addAttribute(attrName, attrValue);
                }
            }
　　　　　　　// 核心代碼,獲取方法上的參數值
            Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
            if (debug) {
                logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
            }
            ReflectionUtils.makeAccessible(handlerMethodToInvoke);
            return handlerMethodToInvoke.invoke(handler, args);
        }

resolveHandlerArguments方法實現代碼比較長,它最終要實現的目的就是:完成request中的參數和方法參數上數據的綁定.

springmvc中提供兩種request參數到方法中參數的綁定方式:

　　① 經過註解進行綁定,@RequestParam

private Object[] resolveHandlerArguments(Method handlerMethod, Object handler,
            NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
　　　　 // 1.獲取方法參數類型的數組
        Class[] paramTypes = handlerMethod.getParameterTypes();
　　　　// 聲明數組,存參數的值
        Object[] args = new Object[paramTypes.length];
　　　　//2.遍歷參數數組,獲取每一個參數的值
        for (int i = 0; i < args.length; i++) {
            MethodParameter methodParam = new MethodParameter(handlerMethod, i);
            methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
            GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
            String paramName = null;
            String headerName = null;
            boolean requestBodyFound = false;
            String cookieName = null;
            String pathVarName = null;
            String attrName = null;
            boolean required = false;
            String defaultValue = null;
            boolean validate = false;
            int annotationsFound = 0;
            Annotation[] paramAnns = methodParam.getParameterAnnotations();
　　　　　　 // 處理參數上的註解
            for (Annotation paramAnn : paramAnns) {
                if (RequestParam.class.isInstance(paramAnn)) {
                    RequestParam requestParam = (RequestParam) paramAnn;
                    paramName = requestParam.value();
                    required = requestParam.required();
                    defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
                    annotationsFound++;
                }
                else if (RequestHeader.class.isInstance(paramAnn)) {
                    RequestHeader requestHeader = (RequestHeader) paramAnn;
                    headerName = requestHeader.value();
                    required = requestHeader.required();
                    defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
                    annotationsFound++;
                }
                else if (RequestBody.class.isInstance(paramAnn)) {
                    requestBodyFound = true;
                    annotationsFound++;
                }
                else if (CookieValue.class.isInstance(paramAnn)) {
                    CookieValue cookieValue = (CookieValue) paramAnn;
                    cookieName = cookieValue.value();
                    required = cookieValue.required();
                    defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
                    annotationsFound++;
                }
                else if (PathVariable.class.isInstance(paramAnn)) {
                    PathVariable pathVar = (PathVariable) paramAnn;
                    pathVarName = pathVar.value();
                    annotationsFound++;
                }
                else if (ModelAttribute.class.isInstance(paramAnn)) {
                    ModelAttribute attr = (ModelAttribute) paramAnn;
                    attrName = attr.value();
                    annotationsFound++;
                }
                else if (Value.class.isInstance(paramAnn)) {
                    defaultValue = ((Value) paramAnn).value();
                }
                else if ("Valid".equals(paramAnn.annotationType().getSimpleName())) {
                    validate = true;
                }
            }
　　
            if (annotationsFound > 1) {
                throw new IllegalStateException("Handler parameter annotations are exclusive choices - " +
                        "do not specify more than one such annotation on the same parameter: " + handlerMethod);
            }

            if (annotationsFound == 0) {// 若是沒有註解
                Object argValue = resolveCommonArgument(methodParam, webRequest);
                if (argValue != WebArgumentResolver.UNRESOLVED) {
                    args[i] = argValue;
                }
                else if (defaultValue != null) {
                    args[i] = resolveDefaultValue(defaultValue);
                }
                else {
                    Class paramType = methodParam.getParameterType();
　　　　　　　　　　  // 將方法聲明中的Map和Model參數,放到request中,用於將數據放到request中帶回頁面
                    if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) {
                        args[i] = implicitModel;
                    }
                    else if (SessionStatus.class.isAssignableFrom(paramType)) {
                        args[i] = this.sessionStatus;
                    }
                    else if (HttpEntity.class.isAssignableFrom(paramType)) {
                        args[i] = resolveHttpEntityRequest(methodParam, webRequest);
                    }
                    else if (Errors.class.isAssignableFrom(paramType)) {
                        throw new IllegalStateException("Errors/BindingResult argument declared " +
                                "without preceding model attribute. Check your handler method signature!");
                    }
                    else if (BeanUtils.isSimpleProperty(paramType)) {
                        paramName = "";
                    }
                    else {
                        attrName = "";
                    }
                }
            }
　　　　　　　// 從request中取值,並進行賦值操做
            if (paramName != null) {
　　　　　　　　　// 根據paramName從request中取值,若是沒有經過RequestParam註解指定paramName,則使用asm讀取class文件來獲取paramName
                args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (headerName != null) {
                args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (requestBodyFound) {
                args[i] = resolveRequestBody(methodParam, webRequest, handler);
            }
            else if (cookieName != null) {
                args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
            }
            else if (pathVarName != null) {
                args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
            }
            else if (attrName != null) {
                WebDataBinder binder =
                        resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
                boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
                if (binder.getTarget() != null) {
                    doBind(binder, webRequest, validate, !assignBindingResult);
                }
                args[i] = binder.getTarget();
                if (assignBindingResult) {
                    args[i + 1] = binder.getBindingResult();
                    i++;
                }
                implicitModel.putAll(binder.getBindingResult().getModel());
            }
        }
　　　　 // 返回參數值數組
        return args;
    }

View Code

　　關於asm框架獲取方法參數的部分,這裏就再也不進行分析了.感興趣的話F3進去就能看到這個過程.

　　到這裏,方法的參數值列表也獲取到了,就能夠直接進行方法的調用了.整個請求過程當中最複雜的一步就是在這裏了.ok,到這裏整個請求處理過程的關鍵步驟都分析完了.理解了springmvc中的請求處理流程,整個代碼仍是比較清晰的.

4、談談springmvc的優化

　　上面咱們已經對springmvc的工做原理和源碼進行了分析,在這個過程發現了幾個優化點:

　　1.controller若是能保持單例,儘可能使用單例,這樣能夠減小建立對象和回收對象的開銷.也就是說,若是controller的類變量和實例變量能夠以方法形參聲明的儘可能以方法的形參聲明,不要以類變量和實例變量聲明,這樣能夠避免線程安全問題.

　　2.處理request的方法中的形參務必加上@RequestParam註解,這樣能夠避免springmvc使用asm框架讀取class文件獲取方法參數名的過程.即使springmvc對讀取出的方法參數名進行了緩存,若是不要讀取class文件固然是更加好.

　　3.閱讀源碼的過程當中,發現springmvc並無對處理url的方法進行緩存,也就是說每次都要根據請求url去匹配controller中的方法url,若是把url和method的關係緩存起來,會不會帶來性能上的提高呢?有點噁心的是,負責解析url和method對應關係的ServletHandlerMethodResolver是一個private的內部類,不能直接繼承該類加強代碼,必需要該代碼後從新編譯.固然,若是緩存起來,必需要考慮緩存的線程安全問題.