Springmvc的请求处理

最新推荐文章于 2024-05-11 23:15:03 发布
最新推荐文章于 2024-05-11 23:15:03 发布
阅读量149 收藏
点赞数
分类专栏： springmvc源码解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41001945/article/details/111355831
版权

在上两篇中，我们简单的介绍了web模式下bean的注入以及ioc容器的创建时间。那么，在容器创建之后，servletContext会持有ioc容器，以便在后面去处理业务逻辑

这一篇我们就仔细分析一下springmvc是怎么处理请求，又是如何去使用ioc容器中的bean的

我们都知道，springmvc也是基于servlet去处理请求。那么他就应该符合servlet的执行流程与规范

在使用servlet的时候，我们需要在web.xml文件中去配置servlet的名字与类路径以及他需要处理的请求。同样，我们也为DispatcherServlet做了相关配置

<servlet>
	<servlet-name>dispatcherServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
	<servlet-name>dispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>

//简单说明一下
<url-pattern>/</url-pattern>  会匹配到/login这样的路径型url，不会匹配到模式为*.jsp这样的后缀型url

<url-pattern>/*</url-pattern> 会匹配所有url：路径型的和后缀型的url(包括/login,*.jsp,*.js和*.html等)

所以我们的DispatcherServlet会处理我们的所有的请求。 servlet处理请求都是在service（）里面

dispatcherServlet的请求处理

FrameworkServlet   431 line

protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		//获取请求方式 
        HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
        //进行请求判断  对于 get post  put  delete  options  trace 等进行处理  略过
        if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
            super.service(request, response);
        } else {
            this.processRequest(request, response);
        }

    }

最终都会走到这个方法

FrameworkServlet  487   line

protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       //构建了一系列参数
        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
        LocaleContext localeContext = this.buildLocaleContext(request);
        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes);
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor());
        //将本次请求的信息保存在threadLocal中
        this.initContextHolders(request, localeContext, requestAttributes);

        try {
        	//业务处理  往下看
            this.doService(request, response);
        } catch (IOException | ServletException var16) {
            failureCause = var16;
            throw var16;
        } catch (Throwable var17) {
            failureCause = var17;
            throw new NestedServletException("Request processing failed", var17);
        } finally {
            this.resetContextHolders(request, previousLocaleContext, previousAttributes);
            if (requestAttributes != null) {
                requestAttributes.requestCompleted();
            }

            this.logResult(request, response, (Throwable)failureCause, asyncManager);
            this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause);
        }

    }

业务处理

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ......
		//设置一些请求信息
        request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext());
        request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
        request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
        request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource());
        if (this.flashMapManager != null) {
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }

            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
        }

        try {
        	//请求分发
            this.doDispatch(request, response);
        } 
        ......

    }

请求分发

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

                try {
                	//如果请求带有文件  则进行request的一个简单包装
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    //获取handler  也就是我们的控制器？？ 直接就获取了？
                    //那么handler什么时候注册的呢？稍后介绍
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                    	//不存在对应handler  返回404
                        this.noHandlerFound(processedRequest, response);
                        return;
                    }
					//handler是从HandlerMapping中拿到的 根据handler获取HandlerAdapter
					//HandlerAdapter也是具体执行handle的执行类  也就是业务方法的执行类
                    HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
                    //请求方式  请求类型
                    String method = request.getMethod();
                    boolean isGet = "GET".equals(method);
                    //判断是否已经被处理 处理过的话，直接返回
                    if (isGet || "HEAD".equals(method)) {
                        long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                        if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
                            return;
                        }
                    }
					
					//调用拦截器，判断这个请求是否需要被拦截！！！这里涉及到了拦截器哦
					//DispatcherServlet持有拦截器的引用
                    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                        return;
                    }

					//调用handle方法，这里会生成modelAndView  后续分析
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }

                    this.applyDefaultViewName(processedRequest, mv);
                    //业务执行之后，再次调用拦截器的post方法
                    mappedHandler.applyPostHandle(processedRequest, response, mv);
                } 
                
                ......异常处理哦
                //这里会进行结果处理  也就是视图渲染...... 后续分析
                this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);

        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else if (multipartRequestParsed) {
                this.cleanupMultipart(processedRequest);
            }

        }
    }

获取handlerMapping 从中获取handler

DispatcherServlet    628  line

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
        	//从handlerMappings中取   handlerMappings是一个arrayList
            Iterator var2 = this.handlerMappings.iterator();
            while(var2.hasNext()) {
                HandlerMapping mapping = (HandlerMapping)var2.next();
                //获取hander   往下看
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }

        return null;
    }

AbstarctHandlerMapping   224 line

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        //获取handler  等会研究  继续往里面看
        Object handler = this.getHandlerInternal(request);
        if (handler == null) {
            handler = this.getDefaultHandler();
        }

        if (handler == null) {
            return null;
        } else {
            if (handler instanceof String) {
                String handlerName = (String)handler;
                handler = this.obtainApplicationContext().getBean(handlerName);
            }
			//包装成HandlerExecutionChain  这里面会将HandlerMapping中的一些拦截器拿到HandlerExecutionChain中
            HandlerExecutionChain executionChain = this.getHandlerExecutionChain(handler, request);
            //看样子是跨域相关配置的处理
            if (this.hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
                CorsConfiguration config = this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null;
                CorsConfiguration handlerConfig = this.getCorsConfiguration(handler, request);
                config = config != null ? config.combine(handlerConfig) : handlerConfig;
                executionChain = this.getCorsHandlerExecutionChain(request, executionChain, config);
            }
			//返回
            return executionChain;
        }
    }

获取handler

AbstractHandlerMethodMapping  201 line

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		//获取请求uri
        String lookupPath = this.getUrlPathHelper().getLookupPathForRequest(request);
        request.setAttribute(LOOKUP_PATH, lookupPath);
        //获取一个独占锁
        this.mappingRegistry.acquireReadLock();
        HandlerMethod var4;
        try {
        	//获取handler  往下看
            HandlerMethod handlerMethod = this.lookupHandlerMethod(lookupPath, request);
            var4 = handlerMethod != null ? handlerMethod.createWithResolvedBean() : null;
        } finally {
            this.mappingRegistry.releaseReadLock();
        }

        return var4;
    }

还是这个文件    218  line
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
        List<AbstractHandlerMethodMapping<T>.Match> matches = new ArrayList();
        //这一块其实也就是在本bean中，以一个map来保存接口以及接口处理的类与方法
        List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
        if (directPathMatches != null) {
        	//将匹配的handler保存在上面创建的matches集合中
            this.addMatchingMappings(directPathMatches, matches, request);
        }

        if (matches.isEmpty()) {
            this.addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
        }

        if (!matches.isEmpty()) {
            AbstractHandlerMethodMapping<T>.Match bestMatch = (AbstractHandlerMethodMapping.Match)matches.get(0);
            //如果一个接口有多个方法与其对应 直接报错 
            if (matches.size() > 1) {
                Comparator<AbstractHandlerMethodMapping<T>.Match> comparator = new AbstractHandlerMethodMapping.MatchComparator(this.getMappingComparator(request));
                matches.sort(comparator);
                bestMatch = (AbstractHandlerMethodMapping.Match)matches.get(0);
                (CorsUtils.isPreFlightRequest(request)) {
                	//如果请求方式是Origin  则返回一个默认的hander  因为这个请求来判断是否可以跨域
                    return PREFLIGHT_AMBIGUOUS_MATCH;
                }

                AbstractHandlerMethodMapping<T>.Match secondBestMatch = (AbstractHandlerMethodMapping.Match)matches.get(1);
                if (comparator.compare(bestMatch, secondBestMatch) == 0) {
                    Method m1 = bestMatch.handlerMethod.getMethod();
                    Method m2 = secondBestMatch.handlerMethod.getMethod();
                    String uri = request.getRequestURI();
                    //抛出异常信息
                    throw new IllegalStateException("Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
                }
            }

            request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
            //将一些信息放置在请求域中
            this.handleMatch(bestMatch.mapping, lookupPath, request);
            //返回匹配到的hander
            return bestMatch.handlerMethod;
        } else {
        	//没有匹配到，直接返回null
            return this.handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
        }
    }

稍微总结一下：

在这里插入图片描述

到目前位置，已经拿到对应的hander

下一篇分析 springmvc是什么时候将接口与对应的业务处理bean来结合放置在HandlerMapping中的map里面

以及springmvc如何使用hander来获取ModelAndView。以及渲染时怎么进行的

mist蒙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
springmvc请求处理流程.md
04-28
springmvc请求处理流程
SpringMVC
qq_26786441的博客
05-20 176
1.概述 1.1 SpringMVC与Struts2的区别 1.SpringMVC参数绑定在形参上，而struts2是绑定属性上 2.SpringMVC是单例的（每次一个副本），而Strusts2是多例的（每一个请求创建一个线程） 3.SpringMVC存数据与request域，没有值栈 4.SpringMVC入口是Servlet，Struts2入口是Filter 1.2 Spring...
springMVC处理请求全过程
最新发布
Supreme13的博客
05-11 996
总的来说，Spring MVC 的请求处理流程是一个经典的 MVC 模式的实现，通过各个组件的配合，实现了请求的接收、处理、响应的完整流程，为开发者提供了一种简单、灵活且可扩展的方式来构建 Web 应用程序。熟悉这些流程和组件对于理解 Spring MVC 的工作原理和实现机制非常重要，有助于更加高效地开发和调试应用程序。
Spring源码解析 - springMVC核心代码（一）
热门推荐
平凡之路无尽路的博客
10-25 3万+
一、首先来讲解下springMVC的底层工作流程 1、首先我们重点放在前端控制器（DispatcherServlet） 其类图： 因为从流程图看，用户的请求最先到达就是DispatcherServlet。他是springmvc的核心，也是中央出处理器。因此我们分析源码，先看看他是什么样的流程：通过源码可看到：他是继承FrameworkServlet，它也是springmvc提...
Spring MVC之处理请求的过程
m0_67322837的博客
07-31 3036
springMVC是遵循MVC架构思想，基于SpringContainerCore和AOP等技术，实现的轻量级web框架，用于简化我们日常Web开发。
Spring | SpringMVC异步请求源码分析
程序员阿康
02-12 1418
1）Spring 异步请求使用示例： @RequestMapping(value =&amp;amp;quot;/{id}&amp;amp;quot;,method = RequestMethod.GET) public Callable&amp;amp;amp;lt;Contents&amp;amp;amp;gt; getContentById(@PathVariable(&amp;amp;quot;id&amp;amp;qu
springmvc的请求
qq_53876295的博客
04-09 899
springmvc框架
一文读懂 spring MVC 请求处理流程
澎湖Java架构师的博客
07-29 2709
主要了解请求处理的流程，在DispatcherServlet中，先通过请求从handlerMappings中获取对应的handler,然后通过handler找到对应的handlerAdapter然后通过handlerAdapter的handle()方法真正执行我么controller层的业务逻辑。并返回一个ModeAndView然后通过ViewResolver解析成view并渲染到界面上。httpshttpshttpshttpshttpshttpshttps。...
SpringMVC流程
m0_58984702的博客
12-08 555
1.流程图 第一步：用户发送请求到前端控制器（DispatcherServlet）。 第二步：前端控制器请求 HandlerMapping 查找 Handler，可以根据 xml 配置、注解进行查找。 第三步： 处理器映射器 HandlerMapping 向前端控制器返回 Handler 第四步：前端控制器调用处理器适配器去执行 Handler 第五步：处理器适配器执行 Handler 第六步：Handler 执行完成后给适配器返回 ModelAndView 第七步：处理器适配器向.
SpringMVC处理请求流程
weixin_66107774的博客
12-31 336
1.用户先发送请求，请求被springMvc前端控制器捕获。 2.前端控制器对请求URL解析获取请求URL，根据URL，调用HandlerMapping。 3.前端控制器获得返回的HandlerExecutionChain。 4.DispatcherServlet根据获得的HandlerExecutionChain，选择一个合适的HandlerAdapter。 5.HandlerAdapter根据请求的Handler适配并执行对应的Handler。 6.Handler执行完毕后，返回一个模型和视图
基于Spring MVC接收并处理HTTP请求
03-31
NULL 博文链接：https://ajita.iteye.com/blog/1396264
Springmvc请求处理方法参数
05-17
Springmvc请求处理方法参数Springmvc请求处理方法参数
SpringMVC请求乱码处理的2种方式
08-25
主要介绍了SpringMVC请求乱码处理的2种方式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringMVC处理multipart请求的示例代码
08-28
本篇文章主要介绍了SpringMVC处理multipart请求的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springmvc处理异步请求的示例
08-31
主要介绍了springmvc处理异步请求的示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringMVC 如何实现异步处理及内置异步请求类介绍
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
07-25 3268
在 SpringMvc 中为了方便使用异步请求专门提供了以下几种类型：在 SpringMvc 中，对异步请求的处理中提供了四个地方的支持：1、FrameworkServlet 中给当前请求的 WebAsyncManager 添加了 CallableProcessingInterceptor 类型的拦截器->RequestBindingInterceptor，目的是为了在请求处理前将当前请求的 LocaleContext 和 ServletRequestAttributes 设置到 LocaleContext
Spring MVC 源码-运行调用阶段
Leon_Jinhai_Sun的博客
11-21 198
这一步步是由请求触发的，所以入口为DispatcherServlet 的核心方法为doService()，doService()中的核心逻辑由doDispatch()实现，源代码如下： /** 中央控制器,控制请求的转发 **/ protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest
面试官：小伙汁，你画的SpringMVC请求处理过程是从网上抄的吧？
Java知音
09-14 556
作者：Sicimikeblog.csdn.net/Baisitao_/article/details/107471719前言 SpringMVC请求处理相信大家都很熟悉了，本篇主要是基于...
springmvc请求处理执行流程?
08-12
总之，SpringMVC的执行流程是通过DispatcherServlet来控制请求的处理，根据请求的URL和HandlerMapping获取处理器对象，执行处理器并返回结果，最后通过ViewResolver将结果渲染并返回给客户端。<span class="em">1...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值