SpringMVC源码-DispatcherServlet

news2024/11/26 10:48:29

一、SpringMVC请求处理流程

在这里插入图片描述

  • DispatcherServlet：DispatcherServlet是SpringMVC中的前端控制器，负责接收request并将request转发给对应的处理组件。
  • HandlerMapping：HanlerMapping是SpringMVC中完成url到Controller映射的组件。
  • Handler：Handler处理器，其实就是我们的Controller，它的具体表现形式有很多，可以是类，也可以是方法，如果你能想到别的表现形式也可以使用，它的类型是Object。带有@RequestMapping 的所有方法都可以看成一个Handler。只要可以实际处理请求就可以是Handler。
  • HandlerAdapter: 处理器适配器。因为SpingMVC中的Handler可以是任意的形式，只要能处理请求就OK，但是Servlet需要的处理方法的结构却是固定的，都是以request和response为参数的方法(如doService方法)。怎么让固定的Servlet处理方法调用灵活的Handler来进行处理呢?这就是HandlerAdapter要做的事情。
  • ModelAndView：ModelAndView是封装结果视图的组件。
  • ViewResolver：ViewResolver视图解析器，解析ModelAndView对象，并返回对应的视图View给客户端。

通俗点的解释就是Handler 是用来干活的工具，HandlerMapping用于根据需要干的活找到相应的工具，HandlerAdapter 是使用工具干活的人。

处理流程：
1、请求进入DispatcherServlet中，通过request 找到对应的handler
2、根据handler找到对应的HandlerAdapter
3、HandlerAdapter处理handler
4、调用processDispatchResult方法处理上面处理结果（包括找到view渲染输出给用户）

对应代码如下：

1、HandlerExecutionChain mappedHandler = getHandler(processedRequest);
2、HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
3、ModelAndView mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
4、processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

二、SpringMVC的工作机制

流程图

请添加图片描述
1、在IOC容器初始化时会建立所有url和controller的对应关系,保存到Map<url,controller>中。
tomcat启动时会通知spring初始化容器(加载bean的定义信息和初始化所有单例bean)，
然后springmvc会遍历容器中的bean，获取每一个controller中的所有方法访问的url，然后将url和controller保存到一个Map中；
2、这样就可以根据request快速定位到controller，因为最终处理request的是controller中的方法，Map中只保留了url和controller中的对应关系，所以要根据request的url进一步确认controller中的method，这一步工作的原理就是拼接controller的url(controller上@RequestMapping的值)和方法的url(method上@RequestMapping的值)，与request的url进行匹配，找到匹配的那个方法;　　
3、确定处理请求的method后，接下来的任务就是参数绑定，把request中参数绑定到方法的形式参数上,这一步是整个请求处理过程中最复杂的一个步骤。springmvc提供了两种request参数与方法形参的绑定方法:
① 通过注解进行绑定,@RequestParam
② 通过参数名称进行绑定.
　　使用注解进行绑定,我们只要在方法参数前面声明@RequestParam(“a”),就可以将request中参数a的值绑定到方法的该参数上。使用参数名称进行绑定的前提是必须要获取方法中参数的名称，Java反射只提供了获取方法的参数的类型，并没有提供获取参数名称的方法。springmvc解决这个问题的方法是用asm框架读取字节码文件，来获取方法的参数名称。使用注解来完成参数绑定，这样就可以省去asm框架的读取字节码的操作。

  1. ApplicationContext初始化时建立所有url和controller类的对应关系(用Map保存);
  2. 根据请求url找到对应的controller，并从controller中找到处理请求的方法;
  3. request参数绑定到方法的形参，执行方法处理请求，并返回结果视图。

2.1、ApplicationContext初始化时建立Map<url,controller>

第一部分的入口类为ApplicationObjectSupport的setApplicationContext方法.setApplicationContext方法中核心部分就是初始化容器initApplicationContext(context),子类AbstractDetectingUrlHandlerMapping实现了该方法,所以我们直接看子类中的初始化容器方法.

public abstract class AbstractDetectingUrlHandlerMapping extends AbstractUrlHandlerMapping {

	private boolean detectHandlersInAncestorContexts = false;

	public void setDetectHandlersInAncestorContexts(boolean detectHandlersInAncestorContexts) {
		this.detectHandlersInAncestorContexts = detectHandlersInAncestorContexts;
	}

	@Override
	public void initApplicationContext() throws ApplicationContextException {
		super.initApplicationContext();
		// 检测出handler
		detectHandlers();
	}

  /**
　　  * 建立当前ApplicationContext中的所有controller和url的对应关系
　　　 */
	protected void detectHandlers() throws BeansException {
		ApplicationContext applicationContext = obtainApplicationContext();
		// 获取ApplicationContext容器中所有Bean的Name
		String[] beanNames = (this.detectHandlersInAncestorContexts ?
				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
				applicationContext.getBeanNamesForType(Object.class));

		// 遍历beanNames,并找到这些bean对应的url
		for (String beanName : beanNames) {
		// 找bean上的所有Url（Controller上的Url + 方法上的Url），该方法由对应的子类实现
			String[] urls = determineUrlsForHandler(beanName);
			if (!ObjectUtils.isEmpty(urls)) {
				// URL paths found: Let's consider it a handler.
				// 注册handler（重点）
				// 保存url和beanName的对应关系
				// put it to Map<urls,beanName>,该方法在父类AbstractUrlHandlerMapping中实现
				registerHandler(urls, beanName);
			}
		}

		if (mappingsLogger.isDebugEnabled()) {
			mappingsLogger.debug(formatMappingName() + " " + getHandlerMap());
		}
		else if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
			logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
		}
	}


    /** 获取controller中所有方法的url,由子类实现,典型的模板模式 **/
	protected abstract String[] determineUrlsForHandler(String beanName);

}

determineUrlsForHandler(String beanName)方法的作用是获取每个controller中的url，不同的子类有不同的实现,这是一个典型的模板设计模式。


public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
	//检查给定bean的名称和别名，查找以“/”开头的url。
	@Override
	protected String[] determineUrlsForHandler(String beanName) {
		List<String> urls = new ArrayList<>();
		if (beanName.startsWith("/")) {
			urls.add(beanName);
		}
		String[] aliases = obtainApplicationContext().getAliases(beanName);
		for (String alias : aliases) {
			if (alias.startsWith("/")) {
				urls.add(alias);
			}
		}
		return StringUtils.toStringArray(urls);
	}

}

到这里HandlerMapping组件就已经建立所有url和controller的对应关系。

2.1、根据访问url找到对应controller中处理请求的方法

DispatcherServlet 是 SpringMVC最核心的类。DispatcherServlet的执行方法的入口是doService()，不过doService()并没有直接处理，而是交给doDispatch()去实现核心逻辑

2.1.1 SpringMVC初始化流程

请添加图片描述

2.1.2 DispatcherServlet入口

请添加图片描述

2.1.3 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 {
　　　　　　　　　// 1.检查是否是文件上传的请求
                processedRequest = checkMultipart(request);
 
                // 2.取得处理当前请求的controller,这里也称为hanlder,处理器,第一个步骤的意义就在这里体现了.这里并不是直接返回controller,而是返回的HandlerExecutionChain请求处理器链对象,该对象封装了handler和interceptors.
                mappedHandler = getHandler(processedRequest, false);
　　　　　　　　　// 如果handler为空,则返回404
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }
                //3. 获取处理request的处理器适配器handler adapter 
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                // 处理 last-modified 请求头
                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;
                    }
                }
 
                // 4.拦截器的预处理方法
                HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
                if (interceptors != null) {
                    for (int i = 0; i < interceptors.length; i++) {
                        HandlerInterceptor interceptor = interceptors[i];
                        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
                            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
                            return;
                        }
                        interceptorIndex = i;
                    }
                }
 
                // 5.实际的处理器处理请求,返回结果视图对象
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 
                // 结果视图对象的处理
                if (mv != null && !mv.hasView()) {
                    mv.setViewName(getDefaultViewName(request));
                }
 
                // 6.拦截器的后处理方法
                if (interceptors != null) {
                    for (int i = interceptors.length - 1; i >= 0; i--) {
                        HandlerInterceptor interceptor = interceptors[i];
                        interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
                    }
                }
            }
            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);
            }
 
            
            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");
                }
            }
 
            // 请求成功响应之后的方法
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
        }

第2步:getHandler(processedRequest)方法实际上就是从HandlerMapping中找到url和controller的对应关系。这也就是第一个步骤:建立Map<url,Controller>的意义。
我们知道，最终处理request的是controller中的方法，我们现在只是知道了controller，还要进一步确认controller中处理request的方法。

2.3反射调用处理请求的方法，返回结果视图

ha.handle(processedRequest, response, mappedHandler.getHandler());

handle是实际的处理器处理请求到controller实现业务逻辑，返回模型和视图，
AbstractHandlerMethodAdapter#handle（）==> RequestMappingHandlerAdapter#handleInternal() ==>invokeHandlerMethod()

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
			if (this.argumentResolvers != null) {
				invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
			}
			if (this.returnValueHandlers != null) {
				invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
			}
			invocableMethod.setDataBinderFactory(binderFactory);
			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
			mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
			mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

			AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
			asyncWebRequest.setTimeout(this.asyncRequestTimeout);

			WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
			asyncManager.setTaskExecutor(this.taskExecutor);
			asyncManager.setAsyncWebRequest(asyncWebRequest);
			asyncManager.registerCallableInterceptors(this.callableInterceptors);
			asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

			if (asyncManager.hasConcurrentResult()) {
				Object result = asyncManager.getConcurrentResult();
				mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
				asyncManager.clearConcurrentResult();
				LogFormatUtils.traceDebug(logger, traceOn -> {
					String formatted = LogFormatUtils.formatValue(result, !traceOn);
					return "Resume with async result [" + formatted + "]";
				});
				invocableMethod = invocableMethod.wrapConcurrentResult(result);
			}

			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}

			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/720624.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

智能汽车时代，产业如何“软硬兼施”

智能汽车时代，产业如何“软硬兼施”

摘要&#xff1a; 智能汽车时代&#xff0c;以车用芯片、基础软件为代表的卡脖子关键技术&#xff0c;牵动着国内整个汽车供应链的安全。“软硬兼施”正成为从企业到汽车全行业的共同重大行动。 汽车产业链、供应链安全问题近两年已经引起全行业前所未有的关注。进入智能汽车时…
阅读更多...
互联网医院资质申请难吗|互联网医院+医药机构

互联网医院资质申请难吗|互联网医院+医药机构

互联网医院牌照申请的具体流程可能因国家和地区的法规和政策而有所不同。下面是一个一般性的流程介绍&#xff1a; 　　准备材料&#xff1a;根据当地的法规和政策要求&#xff0c;准备申请互联网医院牌照所需要的相关材料。这些材料可能包括但不限于&#xff1a;公司注册证明、…
阅读更多...
【已解决】cc1plus: fatal error: cuda_runtime.h: No such file or directory

【已解决】cc1plus: fatal error: cuda_runtime.h: No such file or directory

文章目录 前因解决方案后果 前因 我是在conda环境下创建stable diffusion的虚拟环境&#xff0c;虚拟环境下pytorch、cuda和cudnn的版本如下所示。服务器上的CUDA版本是11.2&#xff0c;GPU是P40&#xff0c;内存22G。 import torch >>> torch.__version__ 1.12.0 &…
阅读更多...
JavaEE语法第二章之多线程（初阶四）

JavaEE语法第二章之多线程（初阶四）

一、wait 和 notify 由于线程之间是抢占式执行的, 因此线程之间执行的先后顺序难以预知.但是实际开发中有时候我们希望合理的协调多个线程之间的执行先后顺序. 球场上的每个运动员都是独立的 "执行流" , 可以认为是一个 "线程". 而完成一个具体的进攻得分…
阅读更多...
【数据结构课程设计系列】农夫过河问题操作演示

【数据结构课程设计系列】农夫过河问题操作演示

农夫过河 1、题目要求 1.1设计目的 掌握广度优先搜索策略&#xff0c;并用队列求解农夫过河问题。 1.2设计内容 一个农夫带着一只狼、一只羊和一棵白菜&#xff0c;身处和的南岸&#xff0c;他要把这些东西全部运到北岸&#xff0c;遗憾的是他只有一只小船&#xff0c;小船只能…
阅读更多...
从小白到大神之路之学习运维第53天--------tomcat-web应用——————供开发的商城框架

从小白到大神之路之学习运维第53天--------tomcat-web应用——————供开发的商城框架

第三阶段基础 时 间&#xff1a;2023年7月5日 参加人&#xff1a;全班人员 内 容&#xff1a; Tomcat应用服务 WEB服务 目录 实验环境&#xff1a;&#xff08;四台服务器&#xff09; 安装tomcat服务&#xff1a; NginxTomcat 负载均衡集群部署&#xff1a; 安装ng…
阅读更多...
【JavaWeb基础】分层解耦

【JavaWeb基础】分层解耦

一、知识点整理 1、IOC与DI入门 1&#xff09;控制反转: Inversion 0f Control&#xff0c;简称I0C。对象的创建控制权由程序自身转移到外部(容器)&#xff0c;这种思想称为控制反转。 2&#xff09;依赖注入: Dependency lnjection&#xff0c;简称DI。容器为应用程序提供运…
阅读更多...
vue 访问第三方 跨域, 配置vue.config.js

vue 访问第三方 跨域, 配置vue.config.js

目录 0 config 文件被修改 一个要重启vscode 配置文件才会生效 1 第一种 (有两种写法) 1.1 配置vue.config.js 1.2 axios 使用 1.3 终端打印 2 第二种方法 --> 错误 --> 没有运行成功 2.1 配置vue.config.js --> 就是api 不被设置成 替换为 / 2.2 axios 使用…
阅读更多...
【Linux初阶】理解一切皆文件 文件属性结构体底层 引用记数

【Linux初阶】理解一切皆文件 文件属性结构体底层 引用记数

&#x1f31f;hello&#xff0c;各位读者大大们你们好呀&#x1f31f; &#x1f36d;&#x1f36d;系列专栏&#xff1a;【Linux初阶】 ✒️✒️本篇内容&#xff1a;理解一切皆文件&#xff0c;文件属性结构体底层理解&#xff08;struct file、引用记数&#xff09; &#x1…
阅读更多...
记一次被通报的挖矿事件应急响应

记一次被通报的挖矿事件应急响应

为方便您的阅读&#xff0c;可点击下方蓝色字体&#xff0c;进行跳转↓↓↓ 01 事件背景介绍02 定位挖矿主机03 挖矿主机分析04 入侵路径梳理05 安全加固建议 01 事件背景介绍 某单位被上级单位通报&#xff0c;单位的出口IP和境外IP有异常通信行为&#xff0c;要求进行紧急处置…
阅读更多...
【MySQL】何为MySQL，一文告诉你答案

【MySQL】何为MySQL，一文告诉你答案

文章目录 前言Oracle&#xff08;甲骨文公司&#xff09;MySQL关系型数据库应用环境特性 前言 在认识JAVA一文中我们有谈到过收购Sun公司的Oracle&#xff08;甲骨文公司&#xff09;1&#xff0c;今天我们要介绍的MySQL就属于 Oracle 旗下产品。 Oracle&#xff08;甲骨文公司…
阅读更多...
远航汽车：坚持合作共赢经营理念 携手志同道合者共创美好未来

远航汽车：坚持合作共赢经营理念 携手志同道合者共创美好未来

智能汽车时代&#xff0c;想要打造一款真正符合用户需求的新能源车&#xff0c;势必要具备硬核技术实力以及敢于突破、不断求变的思维&#xff0c;始终做到以用户为中心&#xff0c;打造属于自己的品牌核心力&#xff0c;才能从激烈的市场竞争中脱颖而出。在此背景下&#xff0…
阅读更多...
【电路原理学习笔记】第2章：电压、电流和电阻：2.6 电路

【电路原理学习笔记】第2章：电压、电流和电阻：2.6 电路

第2章&#xff1a;电压、电流和电阻 2.6 电路 2.6.1 电流的方向 电流方向有两种说法&#xff0c;一种按电子流动方向&#xff0c;另一种是传统的认为从正极流出到负极&#xff0c;这本教材采用传统电流方法。&#xff08;事传统派&#xff0c;维新派输了&#xff0c;1&#…
阅读更多...
全新QQ架构的“NT”版来袭

全新QQ架构的“NT”版来袭

最近&#xff0c;全新发布的"NT"架构的QQ迎来了更新&#xff0c;同时面向用户开放了下载渠道&#xff0c;有些用户戏称为NT为脑瘫版本&#xff08;bushi&#xff09;苏音体验了以后&#xff0c;描述为&#xff1a;清爽简约还很流畅。 先来看看原来的QQ与现在的NT版本…
阅读更多...
【Linux】Selinux基本了解

【Linux】Selinux基本了解

文章目录 SElinux1.简介2.基本概念3.规则4.策略5.工作模式 SElinux 1.简介 SELinux是一个内核级别的安全机制&#xff0c;从Linux2.6内核之后就将SELinux集成在了内核当中。因为SELinux是内核级别的&#xff0c;所以我们对于其配置文件的修改都是需要重新启动操作系统才能生效…
阅读更多...
仿真模拟-Abaqus2021、Abaqus2022 安装下载教程

仿真模拟-Abaqus2021、Abaqus2022 安装下载教程

ABAQUS 是一套功能强大的工程模拟的有限元软件&#xff0c;其解决问题的范围从相对简单的线性分析到许多复杂的非线性问题。 ABAQUS 包括一个丰富的、可模拟任意几何形状的单元库。并拥有各种类型的材料模型库&#xff0c;可以模拟典型工程材料的性能&#xff0c;其中包括金属、…
阅读更多...
Addressable 资源管理全解

Addressable 资源管理全解

这里写目录标题 一、什么是Addresables二、导入Addressables三、创建Addressables Settings 资产包管理四、资源集合Group的基本操作&#xff08;资源分包&#xff09;五、设置远程资源包六、如何打包七、加载方式7-1. Mono脚本指定和实例化&#xff1a;7-2. 直接实例化指定物体…
阅读更多...
Neo4j docker 部署

Neo4j docker 部署

想要运行简单测试一下neo4j&#xff0c;就直接使用docker创建了一个容器&#xff0c;并用cypher-shell本地连接neo4j&#xff0c;创建图进行测试。 1 开启docker sudo systemctl start docker2 拉取镜像源 sudo docker pull neo4j # 默认latest版本3 查看本地镜像&#xff0…
阅读更多...
二叉树之按之字形顺序打印二叉树

二叉树之按之字形顺序打印二叉树

主要看队列的应用与了解&#xff0c;就是利用先进先出的特点。先把每个节点塞入队列&#xff0c;再根据先进先出的特点来把自身值传入一维vector数组中去。 /*** struct TreeNode {* int val;* struct TreeNode *left;* struct TreeNode *right;* TreeNode(int x) : val(x), l…
阅读更多...
作为爬虫工程师，自动化和抓包你说不了解的selenium采集内容篇！

作为爬虫工程师，自动化和抓包你说不了解的selenium采集内容篇！

前言 作为爬虫工程师&#xff0c;掌握Selenium采集是非常有用的&#xff0c;因为有些网站采用了动态加载、javascript渲染或AJAX技术&#xff0c;这些技术使得使用传统的静态HTML解析库难以获取到完整的数据。Selenium是一个自动化测试工具&#xff0c;它可以模拟用户在浏览器…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023