SpringMVC源码流程(一)

最新推荐文章于 2022-08-06 15:11:21 发布
最新推荐文章于 2022-08-06 15:11:21 发布
阅读量319 收藏 4
点赞数
文章标签： java springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48088904/article/details/118093093
版权

目录

一、先来看SpringMVC的初始化（前奏）

1、SpringMVC的九大组件：

2、对于九大组件，前端控制器DispatcherServlet会进行初始化

        二、SpringMVC执行流程

1）找到源码入口

2）进入到DispatcherServlet的doDispatch()

3）各方法的具体实现细节

①getHandler()获取处理器

②getHandlerAdapter()获取适配器

③执行目标方法的细节；

一、先来看SpringMVC的初始化（前奏）

1、SpringMVC的九大组件：

（这是mvc核心的部分，后面的mvc的流程以及其他功能都需要依靠这九大组件）

multipartResolver：文件上传解析器

localeResolver：区域信息解析器，和国际化有关

themeResolver：主题解析器

handlerMappings：handler的映射器

handlerAdapters：handler的适配器

handlerExceptionResolvers：异常解析功能

viewNameTranslator：请求到视图名的转换器

flashMapManager：SpringMVC中允许重定向携带数据的功能

viewResolvers：视图解析器

2、对于九大组件，前端控制器DispatcherServlet会进行初始化

DispatcherServlet中：onRefresh()->initStrategies()
  
protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

例如：初始化HandlerMapping（后面需要用到，先了解知道一下就可以哦）

private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;
        if (this.detectAllHandlerMappings) {
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerMapping> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                OrderComparator.sort(this.handlerMappings);
            }
        }
        else {
            try {
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerMapping later.
            }
        }

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
        if (this.handlerMappings == null) {
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isDebugEnabled()) {
                logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
            }
        }
    }

***********关键点来喽~~~

组件的初始化： 有些组件初始化在容器中是使用类型找的，有些组件是使用id找的；
去容器中找这个组件，如果没有找到就用默认的配置；
注意点：如果后面需要自己实现的组件需要在ioc容器中注册，而注册的时候有些组件就需要专门指定的id才可以去注入成功（否则注入不上的）

二、SpringMVC执行流程

1）找到源码入口

  1. 当客户端发送请求时，会被tomcat拦截，进入到doGet或者doPost的方法中去
  2. 根据继承关系，FrameworkServlet会将基类的HttpServlet的doGet和doPost重写，并且调用doService()
  3. 前端控制器DispatcherServlet继承FrameworkServlet后重写了doService()方法，经过调用，进入到doDispatch（）经过这么一些曲折的寻找，最后终于可以根据源码来探究mvc的流程了

2）进入到DispatcherServlet的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 {
                
                 //1、检查是否文件上传请求
                processedRequest = checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
                
                // Determine handler for the current request.
                 //2、根据当前的请求地址找到那个类能来处理；
                mappedHandler = getHandler(processedRequest);
 
 
                 //3、如果没有找到哪个处理器（控制器）能处理这个请求就404，或者抛异常
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }
 
 
                // Determine handler adapter for the current request.
                 //4、拿到能执行这个类的所有方法的适配器；（反射工AnnotationMethodHandlerAdapter）
                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()) {
                        String requestUri = urlPathHelper.getRequestUri(request);
                        logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }
                try {
                    
                    // Actually invoke the handler.处理（控制）器的方法被调用
                    //控制器（Controller），处理器（Handler）
                     //5、适配器来执行目标方法；
                     //将目标方法执行完成后的返回值作为视图名，设置保存到ModelAndView中
                    //目标方法无论怎么写，最终适配器执行完成以后都会将执行后的信息封装成ModelAndView
                    
                    mv = ha.handle(processedRequest,response,mappedHandler.getHandler());
                } finally {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                }
                applyDefaultViewName(request, mv);//如果没有视图名设置一个默认的视图名；
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            } catch (Exception ex) {
                dispatchException = ex;
            }
            
             //转发到目标页面；
            //6、根据方法最终执行完成后封装的ModelAndView；
            //转发到对应页面，而且ModelAndView中的数据可以从请求域中获取
            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
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
            }
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }

******由此，可以总结为如下几个大概方面

1.用户发出请求，DispatcherServlet接收请求并拦截请求。
2.调用doDispatch()方法进行处理:
        1. getHandler():根据当前请求地址中找到能处理这个请求的目标处理器类(处理器);
            1.根据当前请求在HandlerMapping中找到这个请求的映射信息，获取到目标处理器类
            2. mappedHandler = getHandler(processedRequest);
        2. getHandlerAdapter():根据当前处理器类找到能执行这个处理器方法的适配器;
            1.根据当前处理器类,找到当前类的HandlerAdapter (适配器)
            2. HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler();
        3.使用刚才获取到的适配器(AnnotationMethodHandlerAdapter)执行目标方法;
             mv = ha.handle(processedRequest,response,mappedHandler.getHandler());
        4.目标方法执行后，会返回-个ModerAndView对象
             mv = ha.handle(processedRequest,response,mappedHandler.getHandler();
        5.根据ModerAndView的信息转发到具体页面，并可以在请求域中取出ModerAndView中的模型数据
           processDispatchResult(processedRequest, response, mappedHandler, mv,dispatchException);

根据前面的doDispatch()，有两个组件我们需要使用到，那么再来强调一下这两个组件是干嘛的呢？

HandlerMapping为处理器映射器，保存了每一个处理器能处理哪些请求的映射信息，handlerMap

HandlerAdapter为处理器适配器，能解析注解方法的适配器，其按照特定的规则去执行Handler
 

3）各方法的具体实现细节

①getHandler()获取处理器

     **怎么根据当前请求就能找到哪个类能来处理？**
  • getHandler()会返回目标处理器类的执行链
  • HandlerMapping：处理器映射：他里面保存了每一个处理器能处理哪些请求的映射信息
  • handlerMap：ioc容器启动创建Controller对象的时候扫描每个处理器都能处理什么请求，保存在HandlerMapping的handlerMap属性中；下一次请求过来，就来看哪个HandlerMapping中有这个请求映射信息就行
循环遍历拿到能处理url的类
  
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;
    }

注意点：遍历循环的this.handlerMappings里面在初始化前端控制器的时候就有东西了，有指定的处理器能处理就拿到该处理器，并直接返回。

②getHandlerAdapter()获取适配器

拿到适配器，通过适配器来调用目标方法

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");
    }
RequestMappingHandlerAdapter适配器：

  • 能解析注解方法的适配器；

  • 处理器类中只要有标了注解的这些方法就能用；

③执行目标方法的细节；

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
          //拿到方法的解析器
        ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
           //方法解析器根据当前请求地址找到真正的目标方法
        Method handlerMethod = methodResolver.resolveHandlerMethod(request);
           //创建一个方法执行器；
        ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
           //包装原生的request, response，
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
           //创建了一个，隐含模型
        ExtendedModelMap implicitModel = new BindingAwareModelMap() ;//**重点
 
 
         //真正执行目标方法；目标方法利用反射执行期间确定参数值，提前执行modelattribute等所有的操作都在这个方法中；
        Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
      
        ModelAndView mav = methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
    
        methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
    
        return mav;
    }

接下来深入到执行目标方法，来看看他们是如何执行的吧

Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);

publicfinal Object invokeHandlerMethod (Method handlerMethod, Object handler,
            NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
        Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
        try {
            boolean debug = logger.isDebugEnabled();
            for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
                Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
                if (attrValue != null) {
                    implicitModel.addAttribute(attrName, attrValue);
                }
            }
               
          //找到所有@ModelAttribute注解标注的方法；
            for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
                Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
                //先确定modelattribute方法执行时要使用的每一个参数的值；
               Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
                if (debug) {
                    logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
                }
                String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
                
                if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
                    continue;
                }
                
                ReflectionUtils.makeAccessible(attributeMethodToInvoke);
               
               //提前运行ModelAttribute
                Object attrValue = attributeMethodToInvoke.invoke(handler, args);
                if ("".equals(attrName)) {
                    Class<?> resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
                    attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
                }
              
                //把提前运行的ModelAttribute方法的返回值也放在隐含模型中
                if (!implicitModel.containsAttribute(attrName)) {
                    implicitModel.addAttribute(attrName, attrValue);
                }
            }
 
 
               //再次解析目标方法参数是哪些值
             Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
            if (debug) {
                logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
            }
            ReflectionUtils.makeAccessible(handlerMethodToInvoke);
 
 
            
            //执行目标方法
            return handlerMethodToInvoke.invoke(handler, args);
        }
        catch (IllegalStateException ex) {
            // Internal assertion failed (e.g. invalid signature):
            // throw exception with full handler method context...
            throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex);
        }
        catch (InvocationTargetException ex) {
            // User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception...
            ReflectionUtils.rethrowException(ex.getTargetException());
            return null;
        }
    }
对于前期的框架，相信大家应该有了一个框图，知道大概的流程模样。
接下来，对于到底具体如何执行目标方法的呢，请看SpringMVC流程(二)
 
 
希可诺、
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring MVC的流程及源码分析
BorisCao的博客
04-27 1144
1.Spring MVC通过前置控制器DispatcherServlet处理客户端请求,这里用到了DispatcherServlet的doService方法中的doDispatch DispatcherServlet.java protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { logRequest(request);` .....省略其他代码 t
SpringMVC 入口及父子容器源码解析
qq_34125999的博客
03-27 1801
1 工程简介 描述： web工程 1.1 pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http:
No bug（一）org.springframework.web.servlet.DispatcherServlet.noHandlerFound No mapping ...
krain的博客
07-29 3155
错误描述： org.springframework.web.servlet.DispatcherServlet.noHandlerFound No mapping found for HTTP request with URI [*.do(请求地址)] in DispatcherServlet with name ‘中央调度器名称’ 错误分析： 发生该错误的原因是由于Spring没有成功创建对应的controller类对象。 之所以没有成功创建对应的controller类对象是因为未成功指定controll
【SpringMVC源码解析】 ServletContainerInitializer && SpringMVC源码入口解析
qq_34125999的博客
03-06 3805
1 ServletContainerInitializer 在web容器启动时为提供给第三方组件机会做一些初始化的工作，servlet规范(JSR356)中通过ServletContainerInitializer实现此功能。每个框架要使用ServletContainerInitializer就必须在对应的jar包的META-INF/services 目录创建一个名为javax.servlet.S...
SpringMVC执行流程源码分析
yoobig的博客
08-06 408
这货,太干了!!!
springmvc源码流程解析
最新发布
04-22
springmvc源码流程解析
springMVC源码详解
11-23
《看透SpringMVC源代码分析与实践》这...总的来说，深入学习SpringMVC源码能够提升我们的技术水平，使我们在面对复杂业务场景时更有信心。《看透SpringMVC源代码分析与实践》这本书无疑是实现这一目标的重要参考资料。
spring及springmvc源码
06-05
Spring MVC 的源码解析则会涉及Web应用的请求处理流程。当请求到达时，DispatcherServlet 负责调度，根据请求映射找到合适的控制器（Controller）。Controller 通常是实现了 `Controller` 接口或使用了 `@Controller...
springmvc框架源码.zip
12-18
SpringMVC是Spring框架的...通过深入研究压缩包中的源码，你可以了解这些组件如何协同工作，理解SpringMVC的请求处理流程，以及自定义和扩展其功能的方法。这将有助于提升你的Web开发技能，特别是在大型企业级应用中。
springmvc源码
06-24
- 小项目源码：可以直接运行和调试，加深对实际开发流程的理解。 - 整合 Hibernate：理解如何在 Spring MVC 中配置和使用 Hibernate，实现数据访问。 在学习过程中，你可以逐步理解 Spring MVC 的组件和工作原理...
org.springframework.web.servlet.DispatcherServlet.noHandlerFound No mapping found for HTTP request
weixin_43949154的博客
03-07 3461
控制台报了这么个错：org.springframework.web.servlet.DispatcherServlet.noHandlerFound No mapping found for HTTP request with URI [/springmvc_response/js/jquery-2.1.0.min.js] in DispatcherServlet with name 'dispa...
DispatcherServlet的doDispatch方法解析
Feverasa的博客
09-16 1024
先看下整个方法： protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHan...
Spring MVC静态资源拦截（No mapping found for HTTP request with URI in DispatcherServlet with name ' '）问题
勿忘初心
08-17 2万+
程序加载或用浏览器访问静态资源时出现以下的警告： No mapping found for HTTP request with URI [/] in DispatcherServlet with name ” 问题原因：默认的访问的URL都会被DispatcherServlet所拦截，从web.xml下对spring mvc的DispatcherServlet请求url映射的配置可以看出，具体配
springmvc No mapping found for HTTP request with URI in Dispatc
evilcry2012的专栏
08-10 1275
springmvc No mapping found for HTTP request with URI in Dispatc 博客分类：  Java Web springmvcspring MVCNo mapping foundurl-pattern 项目是使用spring MVC （1）在浏览器中访问，后台总报错： Java代码  
关于Spring一个配置问题的解决noHandlerFound
上善若水，取之有道
03-14 1万+
在做Spring框架学习时，遇到一个练习题，始终爆出错误 org.springframework.web.servlet.DispatcherServlet noHandlerFound 我的Spring是3.1.0的，这里没有采用注解方式   我的web.xml配置如下 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-ap...
Spring源码解析 - springMVC核心代码（一）
热门推荐
平凡之路无尽路的博客
10-25 3万+
一、首先来讲解下springMVC的底层工作流程 1、首先我们重点放在前端控制器（DispatcherServlet） 其类图： 因为从流程图看，用户的请求最先到达就是DispatcherServlet。他是springmvc的核心，也是中央出处理器。因此我们分析源码，先看看他是什么样的流程：通过源码可看到：他是继承FrameworkServlet，它也是springmvc提...
SpringMVC源码总结（一）HandlerMapping和HandlerAdapter入门
weixin_33918114的博客
02-07 250
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring MVC源码分析
woshiwanxin102213的专栏
07-14 3254
1、MVC模式： 2、Web环境中使用Spring MVC Spring Mvc是建立在IOC容器基础上的，所以需要在web环境中进行配置，在tomcat中web.xml相关的代码： 3、在Web环境启动过程详解 ContentLoaderListener-->ContextLoader，ContentLoaderListener通过ContextLoader完成实
spring源码：入口
不会吃萝卜的兔子
02-08 2085
11.
springmvc源码图解
09-11
通过对SpringMVC源码的图解，我们可以更加深入地了解框架的实现原理，掌握其工作流程和关键组件的相互关系。这对于我们开发基于SpringMVC的Web应用来说非常有帮助，可以更加高效地利用框架的功能和特性，提升开发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值