SpringMVC原理

一、SpringMVC的主要组件

• 前端控制器（DisatcherServlet）：接收请求，响应结果，返回可以是json,String等数据类型，也可以是页面（Model）。
• 处理器映射器（HandlerMapping）：根据URL去查找处理器，一般通过xml配置或者注解进行查找。
• 处理器（Handler）：就是我们常说的controller控制器啦，由程序员编写。
• 处理器适配器（HandlerAdapter）：可以将处理器包装成适配器，这样就可以支持多种类型的处理器。
• 视图解析器（ViewResovler）：进行视图解析，返回view对象（常见的有JSP,FreeMark等）。

二、SpingMVC的工作原理

 

步骤说明：

1、用户发送请求到前端控制器（DispatcherServlet）。

2、前端控制器请求处理器映射器（HandlerMapping）去查找处理器（Handler）。

3、找到以后，处理器映射器（HandlerMappering）向前端控制器返回执行链（HandlerExecutionChain）。

4、前端控制器（DispatcherServlet）调用处理器适配器（HandlerAdapter）去执行处理器（Handler）。

5、处理器适配器去执行Handler。

6、处理器执行完给处理器适配器返回ModelAndView。

7、处理器适配器向前端控制器返回ModelAndView。

8、前端控制器请求视图解析器（ViewResolver）去进行视图解析。

9、视图解析器向前端控制器返回View。

10、前端控制器对视图进行渲染。

11、前端控制器向用户响应结果。

三、实现原理

DispatcherServlet动作大致可以分为两个部分：初始化部分和对Http的请求进行响应

1. 初始化：

HttppServletBean.init()---->FrameworkServlet.initServletBean()

　　　　　　　　　　---->initWebApplicationContext()

　　　　　　　　　　---->DispatcherServlet.onRefresh()
　　　　　　　　　　---->initStrategies()

protected void initStrategies(ApplicationContext context) { 
　　//初始化多媒体解析器 
　　initMultipartResolver(context); 
　　//初始化位置解析器 
　　initLocaleResolver(context); 
　　//初始化主题解析器 
　　initThemeResolver(context); 
　　//初始化HandlerMappings 
　　initHandlerMappings(context); 
　　// 初始化HandlerAdapters 
　　initHandlerAdapters(context); 
　　//初始化异常解析器 
　　initHandlerExceptionResolvers(context); 
　　//初始化请求到视图名转换器 
　　initRequestToViewNameTranslator(context); 
　　//初始化视图解析器 
　　initViewResolvers(context); 
　　//初始化FlashMapManager 
　　initFlashMapManager(context); 
}

2. 对Http的请求进行响应

作为一个Servlet，web容器会调用Servlet的doGet()和doPost()方法，在经过FrameServlet的processRequest（）简单处理后，会调用DispatcherServlet的doService（）方法，在这个方法中封装了doDispatch()。

doDispatch方法

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 {
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                mappedHandler = getHandler(processedRequest);　　//查找handler及其拦截器
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());　　//查找handler的适配器

                // 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;
                }

                // Actually invoke the handler.
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());　　//通过适配器执行handler，并返回ModelAndView对象

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

                applyDefaultViewName(processedRequest, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            catch (Throwable err) {
                // As of 4.3, we're processing Errors thrown from handler methods as well,
                // making them available for @ExceptionHandler methods and other scenarios.
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", 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);
                }
            }
        }
    }

HandlerExecutionChain的属性

public class HandlerExecutionChain {

    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);

    private final Object handler;

    private HandlerInterceptor[] interceptors;

    private List<HandlerInterceptor> interceptorList;

    private int interceptorIndex = -1;
}

参考：https://blog.csdn.net/wdehxiang/article/details/77619512