public interface HandlerAdapter {  
        boolean supports(Object handler);  
        ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;  
        long getLastModified(HttpServletRequest request, Object handler);  
    }  

    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
            ........  
            try {  
                try {  
                    //獲取合適的HandlerAdapter實現(xiàn)類  
                    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
                ........  
                    if (isGet || "HEAD".equals(method)) {  
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());  
                    }  
                ........  
                    //執(zhí)行真正的請求操作  
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
            ........  
        }  

//初始化handlerAdapters 放在一個鏈表中
    private void initHandlerAdapters(ApplicationContext context) {  
            this.handlerAdapters = null;  
            if (this.detectAllHandlerAdapters) {  
                // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.  
                Map<String, HandlerAdapter> matchingBeans =  
                        BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);  
                if (!matchingBeans.isEmpty()) {  
                    this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());  
                    // We keep HandlerAdapters in sorted order.  
                    OrderComparator.sort(this.handlerAdapters);  
                }  
            }  
            else {  
                try {  
                    HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);  
                    this.handlerAdapters = Collections.singletonList(ha);  
                }  
                catch (NoSuchBeanDefinitionException ex) {  
                    // Ignore, we'll add a default HandlerAdapter later.  
                }  
            }  
            // Ensure we have at least some HandlerAdapters, by registering  
            // default HandlerAdapters if no other adapters are found.  
            if (this.handlerAdapters == null) {  
                this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);  
                if (logger.isDebugEnabled()) {  
                    logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");  
                }  
            }  
        }  

rotected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {  
        for (HandlerAdapter ha : this.handlerAdapters) {  
            if (logger.isTraceEnabled()) {  
                logger.trace("Testing handler adapter [" + ha + "]");  
            }  
            if (ha.supports(handler)) {  
                return ha;  
            }  
        }  
        throw new ServletException("No adapter for handler [" + handler +  
                "]: Does your handler implement a supported interface like Controller?");  
    }  

    public class SimpleControllerHandlerAdapter implements HandlerAdapter {  
        public boolean supports(Object handler) {  
            return (handler instanceof Controller);  
        }  
        public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)  
                throws Exception {  
            return ((Controller) handler).handleRequest(request, response);  
        }  
        public long getLastModified(HttpServletRequest request, Object handler) {  
            if (handler instanceof LastModified) {  
                return ((LastModified) handler).getLastModified(request);  
            }  
            return -1L;  
        }  
    }  

    public interface Controller {  
        ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception; 
    }  

    public abstract class AbstractController extends WebContentGenerator implements Controller {  
        private boolean synchronizeOnSession = false;  
        /** 
         * Set if controller execution should be synchronized on the session, 
         * to serialize parallel invocations from the same client. 
         * <p>More specifically, the execution of the <code>handleRequestInternal</code> 
         * method will get synchronized if this flag is "true". The best available 
         * session mutex will be used for the synchronization; ideally, this will 
         * be a mutex exposed by HttpSessionMutexListener. 
         * <p>The session mutex is guaranteed to be the same object during 
         * the entire lifetime of the session, available under the key defined 
         * by the <code>SESSION_MUTEX_ATTRIBUTE</code> constant. It serves as a 
         * safe reference to synchronize on for locking on the current session. 
         * <p>In many cases, the HttpSession reference itself is a safe mutex 
         * as well, since it will always be the same object reference for the 
         * same active logical session. However, this is not guaranteed across 
         * different servlet containers; the only 100% safe way is a session mutex. 
         * @see org.springframework.web.servlet.mvc.AbstractController#handleRequestInternal 
         * @see org.springframework.web.util.HttpSessionMutexListener 
         * @see org.springframework.web.util.WebUtils#getSessionMutex(javax.servlet.http.HttpSession) 
         */  
        public final void setSynchronizeOnSession(boolean synchronizeOnSession) {  
            this.synchronizeOnSession = synchronizeOnSession;  
        }  
        /** 
         * Return whether controller execution should be synchronized on the session. 
         */  
        public final boolean isSynchronizeOnSession() {  
            return this.synchronizeOnSession;  
        }  
        public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response)  
                throws Exception {  
            // Delegate to WebContentGenerator for checking and preparing.  
            checkAndPrepare(request, response, this instanceof LastModified);  
            // Execute handleRequestInternal in synchronized block if required.  
            if (this.synchronizeOnSession) {  
                HttpSession session = request.getSession(false);  
                if (session != null) {  
                    Object mutex = WebUtils.getSessionMutex(session);  
                    synchronized (mutex) {  
                        return handleRequestInternal(request, response);  
                    }  
                }  
            }  
            return handleRequestInternal(request, response);  
        }  
        /** 
         * Template method. Subclasses must implement this. 
         * The contract is the same as for <code>handleRequest</code>. 
         * @see #handleRequest 
         */  
        protected abstract ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)  
            throws Exception;  
    }  

    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)  
                throws Exception {  
            try {  
             //找尋該請求對象的方法名   推測是反射   
                String methodName = this.methodNameResolver.getHandlerMethodName(request);  
                //根據(jù)方法名返回視圖
                return invokeNamedMethod(methodName, request, response);  
            }  
            catch (NoSuchRequestHandlingMethodException ex) {  
                return handleNoSuchRequestHandlingMethod(ex, request, response);  
            }  
        }  

    protected final ModelAndView invokeNamedMethod(  
                String methodName, HttpServletRequest request, HttpServletResponse response) throws Exception {  
        //獲取方法對象  來自于handlerMethodMap
            Method method = this.handlerMethodMap.get(methodName);  
            if (method == null) {  
            //沒有該請求方法名
                throw new NoSuchRequestHandlingMethodException(methodName, getClass());  
            }  
            try {  
             //參數(shù)列表
                Class[] paramTypes = method.getParameterTypes();  
                List<Object> params = new ArrayList<Object>(4);  
                params.add(request);  
                params.add(response);  
                if (paramTypes.length >= 3 && paramTypes[2].equals(HttpSession.class)) {  
                    HttpSession session = request.getSession(false);  
                    if (session == null) {  
                        throw new HttpSessionRequiredException(  
                                "Pre-existing session required for handler method '" + methodName + "'");  
                    }  
                    //session加入到params
                    params.add(session);  
                }  
                // If last parameter isn't of HttpSession type, it's a command.  
                if (paramTypes.length >= 3 &&  
                        !paramTypes[paramTypes.length - 1].equals(HttpSession.class)) {  
                    Object command = newCommandObject(paramTypes[paramTypes.length - 1]);  
                    params.add(command);  
                    //綁定
                    bind(request, command);  
                }  
                            //執(zhí)行該方法對象的invoke  
                Object returnValue = method.invoke(this.delegate, params.toArray(new Object[params.size()]));  
                //判斷返回值類型
                return massageReturnValueIfNecessary(returnValue);  
            }  
            catch (InvocationTargetException ex) {  
                // The handler method threw an exception.  
                return handleException(request, response, ex.getTargetException());  
            }  
            catch (Exception ex) {  
                // The binding process threw an exception.  
                return handleException(request, response, ex);  
            }  
        }  

    public MultiActionController() {  
        this.delegate = this;  
        registerHandlerMethods(this.delegate);  
        // We'll accept no handler methods found here - a delegate might be set later on.  
    }  

    private void registerHandlerMethods(Object delegate) {  
        this.handlerMethodMap.clear();  
        this.lastModifiedMethodMap.clear();  
        this.exceptionHandlerMap.clear();  
        // Look at all methods in the subclass, trying to find  
        // methods that are validators according to our criteria  
        Method[] methods = delegate.getClass().getMethods();  
        for (Method method : methods) {  
            // We're looking for methods with given parameters.  
            if (isExceptionHandlerMethod(method)) {  
                registerExceptionHandlerMethod(method);  
            }  
            else if (isHandlerMethod(method)) {  
                registerHandlerMethod(method);  
                registerLastModifiedMethodIfExists(delegate, method);  
            }  
        }  
    }  

public String getHandlerMethodName(HttpServletRequest request) throws NoSuchRequestHandlingMethodException {  
        String methodName = null;  
        // Check parameter names where the very existence of each parameter  
        // means that a method of the same name should be invoked, if any.  
        if (this.methodParamNames != null) {  
            for (String candidate : this.methodParamNames) {  
                if (WebUtils.hasSubmitParameter(request, candidate)) {  
                    methodName = candidate;  
                    if (logger.isDebugEnabled()) {  
                        logger.debug("Determined handler method '" + methodName +  
                                "' based on existence of explicit request parameter of same name");  
                    }  
                    break;  
                }  
            }  
        }  
        // Check parameter whose value identifies the method to invoke, if any.  
        if (methodName == null && this.paramName != null) {  
            methodName = request.getParameter(this.paramName);  
            if (methodName != null) {  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Determined handler method '" + methodName +  
                            "' based on value of request parameter '" + this.paramName + "'");  
                }  
            }  
        }  
        if (methodName != null && this.logicalMappings != null) {  
            // Resolve logical name into real method name, if appropriate.  
            String originalName = methodName;  
            methodName = this.logicalMappings.getProperty(methodName, methodName);  
            if (logger.isDebugEnabled()) {  
                logger.debug("Resolved method name '" + originalName + "' to handler method '" + methodName + "'");  
            }  
        }  
        if (methodName != null && !StringUtils.hasText(methodName)) {  
            if (logger.isDebugEnabled()) {  
                logger.debug("Method name '" + methodName + "' is empty: treating it as no method name found");  
            }  
            methodName = null;  
        }  
        if (methodName == null) {  
            if (this.defaultMethodName != null) {  
                // No specific method resolved: use default method.  
                methodName = this.defaultMethodName;  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Falling back to default handler method '" + this.defaultMethodName + "'");  
                }  
            }  
            else {  
                // If resolution failed completely, throw an exception.  
                throw new NoSuchRequestHandlingMethodException(request);  
            }  
        }  
        return methodName;  
        }