Spring 源码解析之HandlerAdapter源码解析(三)

前言

这篇文章主要是解决上篇遗留的问题，主要是因为内容比较多

Spring 源码解析之HandlerAdapter源码解析(二)遗留问题

1. WebAsyncManager 和AsyncWebRequest 这些都是异步请求的管理？

先来看看使用的方式上有什么不同

    @RequestMapping("/call")     @ResponseBody     public WebAsyncTask<String> asyncCall() {             //借助mvcTaskExecutor在另外一个线程调用             //此时Servlet容器线程已经释放,可以处理其他的请求             Callable<String> callable = new Callable<String>() {                     @Override                     public String call() throws Exception {                             Thread.sleep(5000);                             return "Callable result";                     }             };             logger.debug("asyncCall()");             return new WebAsyncTask<String>(5500, callable);//允许指定timeout时间     }

上面代码适合代码消耗时间长的业务处理，一开始看到这种代码的时候我也比较懵懂，大致想了这种适合这样的场景，可能是一些需要超时的情况下需要这样的场景，防止调用时间过长把系统的线程给耗尽。流程上并没有什么好讲的，这里就不在特殊去详细讲了，大家有时间可以看看WebAsyncManager 其实逻辑差不多，只不过执行controller方法返回的时候把WebAsyncTask对象到这里去执行了而已。

2. Spring是如何知道请求对应Controller的方法的？

这个主要分两种情况处理，一种是静态请求，一种是动态请求。

2.1 静态文件处理

按照下面代码逻辑，咱们先讲静态文件处理流程,现在有一个静态请求/static/bootstrap_module/css/bootstrap.min.css，首先来看DispatcherServlet中的mappedHandler = getHandler(processedRequest);方法，这里会按照顺序便利所有的HandlerMapping，通过request去查找到相应的HandlerExecutionChain，这里流程可以看文章《Spring 源码解析之HandlerAdapter源码解析(二)》,HandlerExecutionChain包含了处理请求的handler，按照静态文件请求，这里处理静态文件请求的HandlerMapping是org.springframework.web.servlet.handler.SimpleUrlHandlerMapping,得到HandlerExecutionChain是包含了org.springframework.web.servlet.resource.ResourceHttpRequestHandler，的代码如下所示：

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {        for (HandlerMapping hm : this.handlerMappings) {            if (logger.isTraceEnabled()) {                logger.trace(                        "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");            }            HandlerExecutionChain handler = hm.getHandler(request);            if (handler != null) {                return handler;            }        }        return null;    }

拿到HandlerExecutionChain后，会继续通过HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());去获取相应处理的HandlerAdapter，通过supports方法来判断是哪个HandlerAdapter第一个支持，根据上面的静态请求来说这里得到的Adapter是org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter具体代码如下所示：

protected 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 +                "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");    }

当通过路径找到了所有的处理类时，这个时候代码执行到了mv = ha.handle(processedRequest, response, mappedHandler.getHandler());ha是HttpRequestHandlerAdapter 这里的mappedHandler.getHandler()是ResourceHttpRequestHandler,具体调用方法实现逻辑如下代码所示：

//HttpRequestHandlerAdapter 中 handle方法@Override    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)            throws Exception {        ((HttpRequestHandler) handler).handleRequest(request, response);        return null;    }    //ResourceHttpRequestHandler 中handleRequest    @Override    public void handleRequest(HttpServletRequest request, HttpServletResponse response)            throws ServletException, IOException {        // Supported methods and required session    //校验请求支持的方法和session需要情况        checkRequest(request);        // Check whether a matching resource exists    //获取到resource        Resource resource = getResource(request);    //如果没有获取到就404        if (resource == null) {            logger.trace("No matching resource found - returning 404");            response.sendError(HttpServletResponse.SC_NOT_FOUND);            return;        }        // Header phase        if (new ServletWebRequest(request, response).checkNotModified(resource.lastModified())) {            logger.trace("Resource not modified - returning 304");            return;        }        // Apply cache settings, if any    //设置缓存时间        prepareResponse(response);        // Check the resource's media type    //获取MediaType 比如我这里是css文件那么MediaType就是        MediaType mediaType = getMediaType(resource);        if (mediaType != null) {            if (logger.isTraceEnabled()) {                logger.trace("Determined media type '" + mediaType + "' for " + resource);            }        }        else {            if (logger.isTraceEnabled()) {                logger.trace("No media type found for " + resource + " - not sending a content-type header");            }        }        // Content phase        if (METHOD_HEAD.equals(request.getMethod())) {            setHeaders(response, resource, mediaType);            logger.trace("HEAD request - skipping content");            return;        }        if (request.getHeader(HttpHeaders.RANGE) == null) {      //设置头部            setHeaders(response, resource, mediaType);      //把图片写到response里面            writeContent(response, resource);        }        else {            writePartialContent(request, response, resource, mediaType);        }    }

上面代码是spring处理静态文件的机制，先从技术上来说writeContent(response, resource)这里是直接把流写到了response里面，而且每次都是从硬盘去加载文件，spring默认是使用PathResourceResolver去加载文件的，以前在使用spring的做项目的时候，jvm经常内存溢出，基本上每刷两到三次页面都会young gc，oldgc也会经常发生，通过这里就能够解释清楚了，Spring本身也有解决方案，Spring本身也提供了CachingResourceResolver，但是总的来说最好还是把静态文件的处理分离出去，这样可以提升jvm的处理速度。

2.2动态请求处理

现在有一个动态请求http://localhost:8080/detail/8，根据上面代码来看，这里动态请求获取到的HandlerMapping是org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,这里获取到的HandlerExecutionChain是包含了HandlerMethod,HandlerMethod里面包含了Controller class和对应处理/detail/8请求的Method.这个就是大概的逻辑，详细获取HandlerMethod的流程可以看看这篇文章《Spring 源码解析之HandlerAdapter源码解析(二)》。

2.3问题总结

说到这里可能需要一个大致的流程图，说实话看了上面自己写的文字描述，感觉确实不太好理解，可以通过简单的流程图分别出两种请求的不同处理方式,具体流程如下图所示：

3. Spring模板的渲染机制？

这块逻辑是问题2的续篇，问题2和《Spring 源码解析之HandlerAdapter源码解析(二)》主要讲的是调用机制，但是调用完之后，是需要返回界面或者json数据,下面代码就是DispatcherServlet中处理这块逻辑的方法

/**     * Handle the result of handler selection and handler invocation, which is     * either a ModelAndView or an Exception to be resolved to a ModelAndView.     */    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,            HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {        boolean errorView = false;        //判断是否有是异常view        if (exception != null) {            if (exception instanceof ModelAndViewDefiningException) {                logger.debug("ModelAndViewDefiningException encountered", exception);                mv = ((ModelAndViewDefiningException) exception).getModelAndView();            }            else {                //调用处理异常Handler                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);                mv = processHandlerException(request, response, handler, exception);                errorView = (mv != null);            }        }        // Did the handler return a view to render?        if (mv != null && !mv.wasCleared()) {            //实际渲染view的地方            render(mv, request, 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");            }        }        if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {            // Concurrent handling started during a forward            return;        }        if (mappedHandler != null) {            mappedHandler.triggerAfterCompletion(request, response, null);        }    }    protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,                HttpServletRequest request) throws Exception {            for (ViewResolver viewResolver : this.viewResolvers) {                //遍历所有的viewResolver 直到找到可以处理的View                View view = viewResolver.resolveViewName(viewName, locale);                if (view != null) {                    return view;                }            }            return null;        }    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {        // Determine locale for request and apply it to the response.        //获取Locale对象        Locale locale = this.localeResolver.resolveLocale(request);        response.setLocale(locale);        View view;        //判断view是否是string        if (mv.isReference()) {            // We need to resolve the view name.            //查找到对应的ViewResolver 去渲染view            view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);            if (view == null) {                throw new ServletException("Could not resolve view with name '" + mv.getViewName() +                        "' in servlet with name '" + getServletName() + "'");            }        }        else {            //直接获取到对应的view            // No need to lookup: the ModelAndView object contains the actual View object.            view = mv.getView();            if (view == null) {                throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +                        "View object in servlet with name '" + getServletName() + "'");            }        }        // Delegate to the View object for rendering.        if (logger.isDebugEnabled()) {            logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");        }        try {            // 直接渲染数据            view.render(mv.getModelInternal(), request, response);        }        catch (Exception ex) {            if (logger.isDebugEnabled()) {                logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" +                        getServletName() + "'", ex);            }            throw ex;        }    }

来看看ViewResolver初始化的地方，按照这块逻辑来说，这里是获取所有ViewResolver的子类，所以Spring可以使用多种ViewResolver，只要定义了FreeMarkerViewResolver，InternalResourceViewResolver等多种都会被使用，而且可以通过设置<property name="order" value="1"/> 这个属性决定使用的顺序。

private void initViewResolvers(ApplicationContext context) {        this.viewResolvers = null;        if (this.detectAllViewResolvers) {            // Find all ViewResolvers in the ApplicationContext, including ancestor contexts.            Map<String, ViewResolver> matchingBeans =                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);            if (!matchingBeans.isEmpty()) {                this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());                // We keep ViewResolvers in sorted order.                AnnotationAwareOrderComparator.sort(this.viewResolvers);            }        }        else {            try {                ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);                this.viewResolvers = Collections.singletonList(vr);            }            catch (NoSuchBeanDefinitionException ex) {                // Ignore, we'll add a default ViewResolver later.            }        }        // Ensure we have at least one ViewResolver, by registering        // a default ViewResolver if no other resolvers are found.        if (this.viewResolvers == null) {            this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);            if (logger.isDebugEnabled()) {                logger.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default");            }        }    }

上面就是大概的流程

总结

这一篇保留两个问题：
1. 如何根据viewname找到合适的ViewResolver,这里面有什么优化逻辑。
2. view.render(mv.getModelInternal(), request, response);这部进行渲染的时候有什么不同（先漏出一些基础，jstlview委托tomcat进行渲染，也就是使用Servlet＋jsp那种模式，FreeMarkerView 则使用response输出流对接FreeMarker的模板处理）