Spring MVC实现原理解析

Spring MVC基于MVC设计模式设计，其实现基于Spring IOC容器和Servlet。Spring MVC的启动Spring MVC通常运行在Web容器（如Tomcat）中，其启动由Web容器触发。以下是一个常规的Web应用部署描述文件Web.xml：&lt;?xml version="1.0" encoding="U

john_lw

9892人浏览 · 2018-07-10 17:14:53

john_lw · 2018-07-10 17:14:53 发布

Spring MVC基于MVC设计模式设计，其实现基于Spring IOC容器和Servlet。

Spring MVC的启动

Spring MVC通常运行在Web容器（如Tomcat）中，其启动由Web容器触发。
以下是一个常规的Web应用部署描述文件Web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    id="WebApp_ID" version="3.0">
    <display-name></display-name>
    <!-- 配置Spring MVC DispatcherServlet -->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 初始化参数 -->
        <init-param>
            <!-- 加载SpringMVC的xml到 spring的上下文容器中 -->
            <param-name>contextConfigLocation</param-name>
            <param-value>  
                classpath:spring/springmvc.xml 
            </param-value>
        </init-param>
    </servlet>
    <!-- 配置DispatcherServlet所需要拦截的 url -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- 监听spring上下文容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 加载spring的xml配置文件到 spring的上下文容器中 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext-*.xml</param-value>
    </context-param>

主要分为两部分：

DispatcherServlet的配置
ContextLoaderListener的配置

这两部分的配置为Spring MVC启动的入口，也是Web容器与Spring IOC/MVC相耦合的点（通过ServletContext耦合）。其中DispatcherServlet是一个Servlet，具备Servlet的生命周期，ContextLoaderListener实现了ServletContextListener接口，该接口提供了关于ServletContext生命周期的回调方法。在Web容器启动时，将调用Servlet生命周期的init方法，同时其作为宿主环境的上下文ServletContext将触发事件信息使得ServletContextListener监听器调用contextInitialized方法。

首先来看ContextLoaderListner：

@Override
    public void contextInitialized(ServletContextEvent event) {
        //启动了Spring IOC容器，其配置文件位置在web.xml中已经设定
        //通常这个容器中的Bean主要是web开发中的Service层和DAO层相关的类
        initWebApplicationContext(event.getServletContext());
    }

再看DispatcherServlet，在Servlet启动时将调用init方法。其继承结构如下图：
这里写图片描述
init()方法在HttpServletBean中定义，该方法调用了在FrameworkServlet中定义的initServletBean()方法，部分代码如下：

@Override
    protected final void initServletBean() throws ServletException {
        getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
        try {
        //启动另外一个IOC容器，该IOC容器配置文件在web.xml中设定过
            this.webApplicationContext = initWebApplicationContext();
            initFrameworkServlet();
        }
        catch (ServletException ex) {
            this.logger.error("Context initialization failed", ex);
            throw ex;
        }
        catch (RuntimeException ex) {
            this.logger.error("Context initialization failed", ex);
            throw ex;
        }
    }

该IOC容器中包含的通常是web开发中的Controller层相关的Bean，启动过程中将会将ContextLoaderListener中启动的容器设置为父容器，形成IOC容器体系，在容器体系中获取Bean时，先在子容器中查找，再去父容器中查找。如Controller层中Service的注入，即需要去父容器中查找。

至此，Spring MVC启动了两个IOC容器，其中ContextLoaderListener启动的为父容器（通常负责Service层和DAO层的相关Bean管理），而DispatcherServlet启动的为子容器（通常负责Controller层的相关Bean管理），IOC容器体系建立完毕，同时两个IOC容器通过ServletContext与Web容器（Tomcat）相耦合。

HttpServletBean的init方法最终将调用DispatcherServlet的initStrategies方法，该方法主要用来初始化Spring MVC的主要支持部件：

protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

重点分析HandlerMapping/HandlerAdapters/ViewResolvers这三者。

initStrategies中的主要工作就是设置DispatcherServlet中相关属性的值，对于handlerMapping/handlerAdapters/ViewResolvers这三者来说，都是先在IOC容器中查找是否已经有配置的各类实例，如果没有则启用默认类。默认值在DispatcherServlet.properties文件中有定义。至此，Spring MVC已经启动完毕。

可见，SpringMVC由tomcat以web.xml里一个Servlet一个Listener的配置触发启动，然后以这两个建立IOC容器体系，最终进行组件的初始化工作，启动完成。

Spring MVC重要组件

HandlerMapping

HandlerMapping接口只有一个方法，getHandler，但是返回的是HandlerExecutionChain，一个执行链。其主要作用是将Http请求的URL映射到对应的handler上，返回的执行链中同时包含了handler本身和对应的拦截器链。handler的类型是多样的，在源码中handler类型为Object，可以是实现了Controller接口的对象，也可以是某个方法。因此，也有多种实现类，有直接以类作为handler的，有以方法作为handler的。

在web开发中在方法上常见的RequestMapping注解handleMethod类型的handler，对应的handlerMapping为RequestMappingHandlerMapping。继承AbstractHandlerMethodMapping，持有请求URL与HandlerMethod之间的映射表。

HandlerAdapter

由于handler的多样性，需要为框架提供更好的可拓展性，使用了适配器模式，通过handlerAdapter来调用handler的handle方法。在handlerMapping中获取到HandlerExecutionChain后，从中取出handler本身，遍历已经DispatcherServlet中初始化过的handlerAdapter找到可以适配的HandlerAdapter。

以RequestMappingHandlerMapping为例，对应的Adapter为RequestMappingHandlerAdapter，该Adapter知道handler类型为HandlerMethod，最终通过反射调用完成请求的处理，返回ModelAndView结果。

ViewResolver/View

视图解析器，ViewResolver接口只有一个方法，即resolveViewName，将一个视图名解析为一个View对象。View对象只是视图在Spring MVC中的表示，并非实际意义上的视图。由于视图的多样化，一类视图解析图解析一类视图对象。以JSP视图为例，其ViewResolver为InternalResourceViewResolver，通常都会如下配置：

<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>

InternalResourceViewResolver持有View对象的缓存，如果缓存中不存在，则根据viewname新建View，InternalResourceViewResolver处理的视图对象类为InternalResourceView。

@Override
    protected View createView(String viewName, Locale locale) throws Exception {
        // If this resolver is not supposed to handle the given view,
        // return null to pass on to the next resolver in the chain.
        if (!canHandle(viewName, locale)) {
            return null;
        }
        // 处理视图名称中的重定向前缀
        // Check for special "redirect:" prefix.
        if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
            String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
            RedirectView view = new RedirectView(redirectUrl, isRedirectContextRelative(), isRedirectHttp10Compatible());
            return applyLifecycleMethods(viewName, view);
        }
        // 处理视图名称中的转发前缀
        // Check for special "forward:" prefix.
        if (viewName.startsWith(FORWARD_URL_PREFIX)) {
            String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
            return new InternalResourceView(forwardUrl);
        }
        // Else fall back to superclass implementation: calling loadView.
        return super.createView(viewName, locale);
    }

protected AbstractUrlBasedView buildView(String viewName) throws Exception {
//通过反射新建了View对象，并设置其URL等属性
        AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(getViewClass());
        view.setUrl(getPrefix() + viewName + getSuffix());

        String contentType = getContentType();
        if (contentType != null) {
            view.setContentType(contentType);
        }

        view.setRequestContextAttribute(getRequestContextAttribute());
        view.setAttributesMap(getAttributesMap());

        Boolean exposePathVariables = getExposePathVariables();
        if (exposePathVariables != null) {
            view.setExposePathVariables(exposePathVariables);
        }
        Boolean exposeContextBeansAsAttributes = getExposeContextBeansAsAttributes();
        if (exposeContextBeansAsAttributes != null) {
            view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
        }
        String[] exposedContextBeanNames = getExposedContextBeanNames();
        if (exposedContextBeanNames != null) {
            view.setExposedContextBeanNames(exposedContextBeanNames);
        }

        return view;
    }

视图解析完成之后，就是最后的视图渲染工作了，渲染工作由View对象来完成。
InternalResourceView的render方法实现在其基类AbstractView中定义：

@Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
    //整合Model对象
        Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
        //设置response响应头
        prepareResponse(request, response);
        //最终渲染
        renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
    }

最终渲染部分代码：

@Override
    protected void renderMergedOutputModel(
            Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

        // 将各种Model值都设置到Http请求的请求属性中去，这里的Model已经
        //是经过应用处理过的值，将其巧妙地加入Request的属性中继续传递给视图
        exposeModelAsRequestAttributes(model, request);

        // Expose helpers as request attributes, if any.
        exposeHelpers(request);

        // 通过View对象的URL即可获取到真正的视图路径
        String dispatcherPath = prepareForRendering(request, response);

        // 这里获取RequestDispatcher，即JSP对应的Servlet对象，并调用service方法响应请求
        RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
        if (rd == null) {
            throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
                    "]: Check that the corresponding file exists within your web application archive!");
        }

        // If already included or response already committed, perform include, else forward.
        if (useInclude(request, response)) {
            response.setContentType(getContentType());
            if (logger.isDebugEnabled()) {
                logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
            }
            rd.include(request, response);
        }

        else {
            // Note: The forwarded resource is supposed to determine the content type itself.
            if (logger.isDebugEnabled()) {
                logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
            }
            rd.forward(request, response);
        }
    }

View对象并不是真正的视图对象，只是视图对象在SpringMVC中的表示，持有了真正视图对象的路径，渲染时通过RequestDispatcher将Model数据传给真正的视图。

Spring MVC对Http请求的处理

DispatcherServlet是spring mvc的核心Servlet，承担了请求转发处理的工作。它的本质是Servlet，其可以处理的请求在web.xml中定义，处理方法即service方法，该方法在父类HttpServlet中实现，并提供了钩子给子类。在DispatcherServlet中，主要处理逻辑在doDispatch方法中，部分代码如下：

    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
            ModelAndView mv = null;
            Exception dispatchException = null;
            try {
                // 根据请求获取handler
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 获取相应的handlerAdapter
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                //调用handler的拦截器链的preHandle方法，不符合则返回
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }
                // 将请求交给handler处理
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                applyDefaultViewName(request, mv);
                //调用handler的拦截器链的postHandler方法
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            //处理最终结果，主要是将ModelAndView渲染至相应视图
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
    }

processDispatchResult部分代码如下：

    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
            HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
        // 渲染视图
        if (mv != null && !mv.wasCleared()) {
            render(mv, request, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
    }

总结

Spring MVC启动了两个IOC容器用于构建Spring应用，通过DispatcherServlet拦截Http请求，通过handlerMapping和handlerAdapter获取handler处理得到ModelAndView后，再通过View对象将Model包装在Http请求中，通过RequestDispatcher完成请求的进一步转发给真正的视图进行处理并返回http响应。

https://www.javatpoint.com/requestdispatcher-in-servlet
spring技术内幕

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

云原生

所有评论(0)

查看更多评论

john_lw

@john_lw

已为社区贡献1条内容