可赞springMVC实战总结

最新推荐文章于 2025-05-14 09:54:10 发布

原创最新推荐文章于 2025-05-14 09:54:10 发布 · 244 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring mvc

本文详细介绍了SpringMVC框架的工作原理及其核心组件的作用。从请求的处理流程出发，阐述了DispatcherServlet、HandlerMapping、HandlerAdapter等关键部分的功能，并解释了它们如何协同工作以实现高效的Web应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring MVC 模型及相关组件解析

MVC模型

Model          模型层

模型层主要负责保存和访问业务数据，执行业务逻辑和操作，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据）和服务层（行为）。这一层是现实业务功能的核心。

 View          视图层

视图层主要负责显示模型层的内容。它指定来自模型层的数据如何被显示出来，当模型变化的时候，它将自动更新。

controller     控制器

控制器接受用户的输入并调用模型和视图去完成用户的需求。控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后确定用哪个视图来显示模型处理返回的数据。也就是说控制器做了个调度员的工作。

MVC的流程图：

MVC的流程图
在Web MVC模式下，模型无法主动推数据给视图，如果用户想要视图更新，需要再发送一次请求（即请求-响应模型）。

回顾了整个web开发架构的发展历程[1]跟着开涛学spring MVC
Front Controller + Application Controller + Page Controller + Context
服务到工作者模型，运行流程：

spring MVC 是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，处理请求的流程如下：

springMVC的流程图

具体执行步骤如下：

用户发送请求，前端控制器dispatcherServlet接收
DispatcherServlet收到请求，调用HandlerMapping处理器映射器
处理器映射器根据请求信息（url）找到具体的处理器，生成处理器对象handler及处理器拦截器（如果有则生成）一并返回给DispatcherServlet
DispatcherServlet调用HandlerAdapter处理器适配器
HandlerAdapter根据配置的映射规则，找到对应的处理器（Handler）执行相应功能的处理方法
处理器处理完毕会将controller执行结果返回HandlerAdapter，一个ModelAndView类型的数据，这其中包含了处理结果的视图和模型数据
将ModelAndView类型的数据传给DispatcherServlet
DispatcherServlet根据得到的ModelAndView中的视图对象，找到一个合适的ViewResolver（视图解析器）
DispatcherServlet收回控制权，返回解析后的逻辑视图名view
DispatcherServlet根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入对应的视图
DispatcherServlet再次收回控制权，将响应返回给用户

DispatcherServlet核心代码如下：
//前端控制器分派方法  
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
        HttpServletRequest processedRequest = request;  
        HandlerExecutionChain mappedHandler = null;  
        int interceptorIndex = -1;  

        try {  
            ModelAndView mv;  
            boolean errorView = false;  

            try {  
                   //检查是否是请求是否是multipart（如文件上传），如果是将通过MultipartResolver解析  
                processedRequest = checkMultipart(request);  
                   //步骤2、请求到处理器（页面控制器）的映射，通过HandlerMapping进行映射  
                mappedHandler = getHandler(processedRequest, false);  
                if (mappedHandler == null || mappedHandler.getHandler() == null) {  
                    noHandlerFound(processedRequest, response);  
                    return;  
                }  
                   //步骤3、处理器适配，即将我们的处理器包装成相应的适配器（从而支持多种类型的处理器）  
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  

                  // 304 Not Modified缓存支持  
                //此处省略具体代码  

                // 执行处理器相关的拦截器的预处理（HandlerInterceptor.preHandle）  
                //此处省略具体代码  

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

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

                // 执行处理器相关的拦截器的后处理（HandlerInterceptor.postHandle）  
                //此处省略具体代码  
            }  
            catch (ModelAndViewDefiningException ex) {  
                logger.debug("ModelAndViewDefiningException encountered", ex);  
                mv = ex.getModelAndView();  
            }  
            catch (Exception ex) {  
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
                mv = processHandlerException(processedRequest, response, handler, ex);  
                errorView = (mv != null);  
            }  

            //步骤5 步骤6、解析视图并进行视图的渲染  
//步骤5 由ViewResolver解析View（viewResolver.resolveViewName(viewName, locale)）  
//步骤6 视图在渲染时会把Model传入（view.render(mv.getModelInternal(), request, response);）  
            if (mv != null && !mv.wasCleared()) {  
                render(mv, processedRequest, 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");  
                }  
            }  

            // 执行处理器相关的拦截器的完成后处理（HandlerInterceptor.afterCompletion）  
            //此处省略具体代码  


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

核心架构的具体流程步骤如下：

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

[1]: http://jinnianshilongnian.iteye.com/blog/1593441 开涛