springmvc备忘录 概念

1 spring-mvc 是spring提供的一个mvc框架，与struts差不多，都是为了更好的将视图与逻辑进行分离的框架。

2、Spring Web MVC能帮我们做什么

√让我们能非常简单的设计出干净的Web层和薄薄的Web层； √进行更简洁的Web层的开发；
√天生与Spring框架集成（如IoC容器、AOP等）； √提供强大的约定大于配置的契约式编程支持； √能简单的进行Web层的单元测试；
√支持灵活的URL到页面控制器的映射；
√非常容易与其他视图技术集成，如Velocity、FreeMarker等等，因为模型数据不放在特定的API里，而是放在一个Model里（Map数据结构实现，因此很容易被其他框架使用）；
√非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API；
√提供一套强大的JSP标签库，简化JSP开发； √支持灵活的本地化、主题等解析； √更加简单的异常处理； √对静态资源的支持；
√支持Restful风格。

下面是spring官网给出的一张图，我们可以简单的了解以下概念

1.当我们收到一个请求的时候，会交给前端控制器，当此时的前端控制器front controller并不处理，而是直接交给代理控制器

2.代理控制器处理好model与其他逻辑关系时，会将处理好的model渲染返回给前端控制器

3.前端控制器进一步的渲染为相应的视图，返回给我们

以上是由大方向开始谈的，那么我们再由小方向上去看
1.我发了一个请求，那么springmvc怎么知道我要去找那个controller来处理
2.返回的视图是那个，又是怎么找到的解析的？

了解这些时，首先我们得知道几个概念
在我们启动web服务时，我们的web服务会去绑定springmvc的上下文容器，一般都会继承WebApplicationContext这个类对象，而该类对象有几种特殊的类型要我们注意：

Bean类型说明 处理程序映射
根据一些标准将传入的请求映射到处理程序和前处理程序和后处理程序列表（处理程序拦截器），其细节由HandlerMapping实现而异。最流行的实现支持注释控制器，但其他实现也存在。
HandlerAdapter
帮助DispatcherServlet调用映射到请求的处理程序，而不管实际调用哪个处理程序。例如，调用带注释的控制器需要解析各种注释。因此，HandlerAdapter的主要目的是屏蔽DispatcherServlet和这些细节。
HandlerExceptionResolver 映射视图的异常也允许更复杂的异常处理代码。 ViewResolver
将基于逻辑字符串的视图名称解析为实际的View类型。 LocaleResolver＆LocaleContextResolver
解决客户端正在使用的区域设置以及可能的时区，以便能够提供国际化的视图 ThemeResolver
解决您的Web应用程序可以使用的主题，例如，提供个性化的布局 MultipartResolver
解析多部分请求，以支持从HTML表单处理文件上传。 FlashMapManager
存储并检索可以用于将属性从一个请求传递到另一个请求的“输入”和“输出”FlashMap，通常是通过重定向。

再回到我们原来的问题，我们由官网文档知道，我们的请求会经过一个叫DispatcherServlet的类，该类负责对我们的请求做解析相应，我们来看看它是如何实现的。

/**
     * Process the actual dispatching to the handler.
     * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
     * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
     * to find the first that supports the handler class.
     * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
     * themselves to decide which methods are acceptable.
     * @param request current HTTP request
     * @param response current HTTP response
     * @throws Exception in case of any kind of processing failure
     */
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

        try {
            ModelAndView mv = null;
            Exception dispatchException = null;

            try {
              //检查是否是请求是否是multipart（如文件上传）
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                //请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 适配器，对相应的handler做转换，使其可以被使用
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (logger.isDebugEnabled()) {
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 由适配器执行处理器（调用处理器相应功能处理方法
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                applyDefaultViewName(request, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Error err) {
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

核心架构的具体流程步骤如下：
1、 首先用户发送请求->DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
2、 DispatcherServlet->HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、 DispatcherServlet->HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，使其可以支持很多类型的处理器；
4、 HandlerAdapter->处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
5、 ModelAndView-> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View；
6、 View->渲染，View会根据传进来的Model模型数据进行渲染
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

网上的图解