GrailsDispatcherServlet中的doDispatch方法

@Override
protected void doDispatch(final HttpServletRequest request, HttpServletResponse response) throws Exception {

    request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, localeResolver);

    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    int interceptorIndex = -1;

    // Expose current LocaleResolver and request as LocaleContext.
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContextHolder.setLocaleContext(new LocaleContext() {
        public Locale getLocale() {
            return localeResolver.resolveLocale(request);
        }
    });

    // If the request is an include we need to try to use the original wrapped sitemesh
    // response, otherwise layouts won't work properly
    if (WebUtils.isIncludeRequest(request)) {
        response = useWrappedOrOriginalResponse(response);
    }

    GrailsWebRequest requestAttributes = null;
    RequestAttributes previousRequestAttributes = null;
    Exception handlerException = null;
    boolean isAsyncRequest = processedRequest.getAttribute("javax.servlet.async.request_uri") != null;
    try {
        ModelAndView mv;
        boolean errorView = false;
        try {
            Object exceptionAttribute = request.getAttribute(EXCEPTION_ATTRIBUTE);
            // only process multipart requests if an exception hasn't occured
            if (exceptionAttribute == null) {
                processedRequest = checkMultipart(request);
            }
            // Expose current RequestAttributes to current thread.
            previousRequestAttributes = RequestContextHolder.currentRequestAttributes();
            if(previousRequestAttributes instanceof GrailsWebRequest) {
                requestAttributes = new GrailsWebRequest(processedRequest, response, ((GrailsWebRequest)previousRequestAttributes).getAttributes());
            } else {
                requestAttributes = new GrailsWebRequest(processedRequest, response, getServletContext());
            }
            if( previousRequestAttributes != null) {
                copyParamsFromPreviousRequest(previousRequestAttributes, requestAttributes);
            }

            // Update the current web request.
            WebUtils.storeGrailsWebRequest(requestAttributes);

            if (logger.isDebugEnabled()) {
                logger.debug("Bound request context to thread: " + request);
                logger.debug("Using response object: " + response.getClass());
            }

            // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest);
            Object handler = mappedHandler.getHandler();
            if (mappedHandler == null || handler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();

            // Apply preHandle methods of registered interceptors.
            if (interceptors != null) {
                int i = 0;
                for (HandlerInterceptor interceptor : interceptors) {
                    if (!interceptor.preHandle(processedRequest, response, handler)) {
                        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
                        return;
                    }
                    interceptorIndex = i;
                    i++;
                }
            }

            // if this is an async request that has been resumed, then don't execute the action again instead try get the model and view and continue

            if (isAsyncRequest) {
                Object modelAndViewO = processedRequest.getAttribute(GrailsApplicationAttributes.MODEL_AND_VIEW);
                if (modelAndViewO != null) {
                    mv = (ModelAndView) modelAndViewO;
                }
                else {
                    mv = null;
                }
            }else {
                // Actually invoke the handler.
                HandlerAdapter ha = getHandlerAdapter(handler);
                mv = ha.handle(processedRequest, response, handler);
                // if an async request was started simply return
                if (processedRequest.getAttribute(GrailsApplicationAttributes.ASYNC_STARTED) != null) {
                    processedRequest.setAttribute(GrailsApplicationAttributes.MODEL_AND_VIEW, mv);
                    return;
                }

                // Do we need view name translation?
                if ((ha instanceof AnnotationMethodHandlerAdapter || ha instanceof RequestMappingHandlerAdapter) && mv != null && !mv.hasView()) {
                    mv.setViewName(getDefaultViewName(request));
                }
            }

            // Apply postHandle methods of registered interceptors.
            if (interceptors != null) {
                for (int i = interceptors.length - 1; i >= 0; i--) {
                    interceptors[i].postHandle(processedRequest, response, handler, mv);
                }
            }
        }
        catch (ModelAndViewDefiningException ex) {
            handlerException = ex;
            if (logger.isDebugEnabled()) {
                logger.debug("ModelAndViewDefiningException encountered", ex);
            }
            mv = ex.getModelAndView();
        }
        catch (Exception ex) {
            handlerException = ex;
            Object handler = mappedHandler == null ? null : mappedHandler.getHandler();
            mv = processHandlerException(request, response, handler, ex);
            errorView = (mv != null);
        }

        // Did the handler return a view to render?
        if (mv != null && !mv.wasCleared()) {
            // If an exception occurs in here, like a bad closing tag,
            // we have nothing to render.

            try {
                render(mv, processedRequest, response);
                if (isAsyncRequest && (response instanceof GrailsContentBufferingResponse)) {
                    GroovyPageLayoutFinder groovyPageLayoutFinder = getWebApplicationContext().getBean("groovyPageLayoutFinder", GroovyPageLayoutFinder.class);
                    GrailsContentBufferingResponse bufferingResponse = (GrailsContentBufferingResponse) response;
                    HttpServletResponse targetResponse = bufferingResponse.getTargetResponse();
                    Content content = bufferingResponse.getContent();
                    if (content != null) {
                        Decorator decorator = groovyPageLayoutFinder.findLayout(request, content);
                        SiteMeshWebAppContext webAppContext = new SiteMeshWebAppContext(request, targetResponse, getServletContext());
                        if (decorator != null) {
                            if (decorator instanceof com.opensymphony.sitemesh.Decorator) {
                                ((com.opensymphony.sitemesh.Decorator)decorator).render(content, webAppContext);
                            } else {
                                new OldDecorator2NewDecorator(decorator).render(content, webAppContext);
                            }
                        } else {
                            content.writeOriginal(targetResponse.getWriter());
                        }
                    }
                }
                if (errorView) {
                    WebUtils.clearErrorRequestAttributes(request);
                }
            } catch (Exception e) {
                // Only render the error view if we're not already trying to render it.
                // This prevents a recursion if the error page itself has errors.
                if (request.getAttribute(GrailsApplicationAttributes.RENDERING_ERROR_ATTRIBUTE) == null) {
                    request.setAttribute(GrailsApplicationAttributes.RENDERING_ERROR_ATTRIBUTE, Boolean.TRUE);

                    mv = super.processHandlerException(processedRequest, response, mappedHandler, e);
                    handlerException = e;
                    if (mv != null) render(mv, processedRequest, response);
                }
                else {
                    request.removeAttribute(GrailsApplicationAttributes.RENDERING_ERROR_ATTRIBUTE);
                    logger.warn("Recursive rendering of error view detected.", e);

                    try {
                        response.setContentType("text/plain");
                        response.getWriter().write("Internal server error");
                        response.flushBuffer();
                    } catch (Exception e2) {
                        logger.error("Internal server error - problem rendering error view", e2);
                    }

                    requestAttributes.setRenderView(false);
                    return;
                }
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Null ModelAndView returned to DispatcherServlet with name '" +
                        getServletName() + "': assuming HandlerAdapter completed request handling");
            }
        }

        // Trigger after-completion for successful outcome.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, handlerException);
    }
    catch (Exception ex) {
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    }
    catch (Error err) {
        ServletException ex = new NestedServletException("Handler processing failed", err);
        // Trigger after-completion for thrown exception.
        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
        throw ex;
    }
    finally {
        // Clean up any resources used by a multipart request.
        if (processedRequest instanceof MultipartHttpServletRequest) {
            if (multipartResolver != null) {
                multipartResolver.cleanupMultipart((MultipartHttpServletRequest) processedRequest);
            }
        }
        request.removeAttribute(MultipartHttpServletRequest.class.getName());

        // Reset thread-bound holders
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
            if (previousRequestAttributes instanceof GrailsWebRequest) {
                WebUtils.storeGrailsWebRequest((GrailsWebRequest) previousRequestAttributes);
            }
            else {
                RequestContextHolder.setRequestAttributes(previousRequestAttributes);
            }
        }

        LocaleContextHolder.setLocaleContext(previousLocaleContext);

        if (logger.isDebugEnabled()) {
            logger.debug("Cleared thread-bound request context: " + request);
        }
    }
}