springboot请求映射原理（二）请求路径是如何映射到后端接口

原创 已于 2024-09-26 15:19:30 修改 · 773 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#spring boot #后端 #java
于 2024-09-07 23:28:47 首次发布

原理

通过请求路径，从内存map（Map<T, MappingRegistration>）中，取出controller，执行对应方法。

tomcat处理http请求原理

首先我们自定义servlet类，继承HttpServer，重写doGet、doPost等方法，tomcat通过判断请求方式get、post等，将请求分发到自定义的servlet中，执行我们编写的代码，返回到页面或者返回数据。springmvc帮我们封装了自定义的servlet类DispatcherServlet，首先将所有请求映射到DispatcherServlet，通过一系列的逻辑后，最终找到执行的controller，执行实际请求方法，最终返回页面或者数据。

DispatcherServlet的diagram图

在这里插入图片描述

执行顺序

DispatcherServlet继承FrameworkServlet，FrameworkServlet中重写doGet、doPost方法，直接上代码

@Override
protected final void doGet/doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
	processRequest(request, response);
}

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		long startTime = System.currentTimeMillis();
		Throwable failureCause = null;

		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
		LocaleContext localeContext = buildLocaleContext(request);

		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

		initContextHolders(request, localeContext, requestAttributes);

		try {
			//执行doService方法 FrameworkServlet是抽象类，只有一个子类DispatcherServlet
			//doService是抽象方法，实际执行是DispatcherServlet的doService方法
			doService(request, response);
		}
		catch (ServletException | IOException ex) {
			failureCause = ex;
			throw ex;
		}
		catch (Throwable ex) {
			failureCause = ex;
			throw new NestedServletException("Request processing failed", ex);
		}

		finally {
			resetContextHolders(request, previousLocaleContext, previousAttributes);
			if (requestAttributes != null) {
				requestAttributes.requestCompleted();
			}
			logResult(request, response, failureCause, asyncManager);
			publishRequestHandledEvent(request, response, startTime, failureCause);
		}
	}

@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		//...省略代码	

		try {
			//执行doDispatch方法
			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 {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// 确定当前请求的处理程序
				//实际转发到那个controller				
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					//如果找不到请求处理的controller 就会报错
					//No mapping for ***  方法找不到请求路径
					noHandlerFound(processedRequest, response);
					return;
				}

				// 确定当前请求的处理程序适配器。通过反射调用  
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// 实际调用处理程序  调用实际执行的controller程序
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			//..省略代码
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		//...省略代码
	}

	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			//this.handlerMappings是List<HandlerMapping> ,springboot内置5个映射器处理器分别是:
			//RequestMappintHandlerMapping、BeanNameUrlHandlerMapping、RouterFunctionMapping、SimpleUrlHandlerMapping、WelcomePageHandlerMapping
			//可以说RequestMappintHandlerMapping就是springboot提供的默认处理器
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

接着看RequestMappintHandlerMapping的getHandler方法，实际执行其父类AbstractHandlerMethodMapping的getHandler方法

	@Override
	@Nullable
	protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		//请求路径 比如：/test  /test/id/111(实际对应方法/test/id/{id})
		String lookupPath = initLookupPath(request);
		//上锁 通过ReentrantReadWriteLock.ReadLock加读锁 资源共享 但是不允许修改共享资源
		this.mappingRegistry.acquireReadLock();
		try {
			//获取实际请求的controller以及方法
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
			this.mappingRegistry.releaseReadLock();
		}
	}

@Nullable
	protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
		//...省略代码
		if (matches.isEmpty()) {
			//匹配请求路径
			//this.mappingRegistry.getRegistrations()返回的就是Map<T, MappingRegistration<T>>,springboot启动过程中扫描到的所有控制器路径以及springboot默认匹配的路径 比如 /error
			//this.mappingRegistry.getRegistrations().keySet() 获取所有的请求路径集合 返回RequestMappingInfo 前文提到的
			addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
		}
		if (!matches.isEmpty()) {
			Match bestMatch = matches.get(0);
			if (matches.size() > 1) {
				Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
				matches.sort(comparator);
				bestMatch = matches.get(0);
				if (logger.isTraceEnabled()) {
					logger.trace(matches.size() + " matching mappings: " + matches);
				}
				if (CorsUtils.isPreFlightRequest(request)) {
					for (Match match : matches) {
						if (match.hasCorsConfig()) {
							return PREFLIGHT_AMBIGUOUS_MATCH;
						}
					}
				}
				else {
					Match secondBestMatch = matches.get(1);
					if (comparator.compare(bestMatch, secondBestMatch) == 0) {
						Method m1 = bestMatch.getHandlerMethod().getMethod();
						Method m2 = secondBestMatch.getHandlerMethod().getMethod();
						String uri = request.getRequestURI();
						throw new IllegalStateException(
								"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
					}
				}
			}
			request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod());
			handleMatch(bestMatch.mapping, lookupPath, request);
			return bestMatch.getHandlerMethod();
		}
		else {
			return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
		}
	}

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
		//mappings内存中所有的接口地址 见下图
		for (T mapping : mappings) {		
			//匹配实际执行的controller 最终 因为这里的mapping是RequestMappingInfo  
			//getMatchingMapping(RequestMappingInfo info, HttpServletRequest request)实际执行info.getMatchingCondition(request);
			T match = getMatchingMapping(mapping, request);
			if (match != null) {
				matches.add(new Match(match, this.mappingRegistry.getRegistrations().get(mapping)));
			}
		}
	}

在这里插入图片描述

@Override
	@Nullable
	public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
	//请求方式 get/post ..
		RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
		if (methods == null) {
			return null;
		}
		//请求参数
		ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
		if (params == null) {
			return null;
		}
		//请求头
		HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
		if (headers == null) {
			return null;
		}
		ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
		if (consumes == null) {
			return null;
		}
		ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
		if (produces == null) {
			return null;
		}
		//匹配请求路径
		//执行this.pathPatternsCondition.getMatchingCondition方法
		//这里简单描述一下匹配路径的逻辑
		//把每一个接口路径地址封装成PathPattern，其中有一个属性是PathElement head
		//看到head就想到列表(实际使用双向列表方式) "/"<->"rest"<->"id"<->"{id}" 	这种形式
		//每一个PathElement 对应不同的类型, /->SeparatorPathElement("分隔符") rest->LiteralPPathElement 文字类型
		//{id}->CaptureVariablePathElement 可变路径类型 
		//然后从head开始,通过链表遍历方式 分别调用个不同类型中的match方法,匹配路径
		//匹配成功加入到 List<Match>中
		/** LiteralPPathElement match方法匹配是一个个字符对比的方式
		for (int i = 0; i < this.len; i++) {
				if (value.charAt(i) != this.text[i]) {
					return false;
				}
			}
		*/
		PathPatternsRequestCondition pathPatterns = null;
		if (this.pathPatternsCondition != null) {
			pathPatterns = this.pathPatternsCondition.getMatchingCondition(request);
			if (pathPatterns == null) {
				return null;
			}
		}
		PatternsRequestCondition patterns = null;
		if (this.patternsCondition != null) {
			patterns = this.patternsCondition.getMatchingCondition(request);
			if (patterns == null) {
				return null;
			}
		}
		RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
		if (custom == null) {
			return null;
		}
		return new RequestMappingInfo(this.name, pathPatterns, patterns,
				methods, params, headers, consumes, produces, custom, this.options);
	}
SpringBoot路径映射配置
Steven_1617的博客
10-24 2624
SpringBoot配置路径映射
Spring Boot 路径映射（两种方式）
泠青沼
03-08 4606
Spring Boot 路径映射这个功能并非是springboot特有的，只是springboot提供了更简便的方法以供使用。传统情况下我们跳转一个动态页面且并没有数据，也需要在controller中写一个跳转的controller，我们就可以使用springboot的路径映射我们只需要创建一个WebMvconfig类实现WebMvcConfigurer接口
Spring Boot 中的请求映射是什么，如何使用
程序猿徐师兄的博客
07-06 1188
请求映射是 Spring Boot 中的一个核心概念，它是指将 HTTP 请求映射到处理请求的方法上。在 Spring Boot 中，我们可以使用 @RequestMapping 注解来定义请求映射关系。@RequestMapping 注解可以用在类上或方法上，用于指定类或方法可以处理哪些请求。请求映射是 Spring Boot 中的一个核心概念，它可以帮助我们将不同的请求映射到不同的处理方法上。
SpringBoot路径映射
探索er的博客
04-03 1315
SpringBoot路径映射
SpringBoot图片上传和访问路径映射
记录我目之所及的世界
02-11 2965
静态属性的注入方法、静态资源映射
springboot请求映射原理（一）——接口路径扫如何加载内存中
扎根农村的博客
09-03 1052
springboot 接口路径 内存
SpringBoot的请求映射原理
二木成林
06-23 1127
我们在进行web开发中，每次发请求是如何找到哪个方法去处理这个请求的。所谓请求映射的原理就是来查找源码中是如何完成这个处理的。我们知道SpringBoot中每个请求都会来到DispatcherServlet，底层还是使用SpringMVC，所以我们来看DispatcherServlet类。 该类在org.springframework.web.servlet包下： 进入到该类中，按快捷键“Ctrl+H”查看该类的继承树： 是间接继承了HttpServlet，那么一定会重写doGet()和doP
Springboot之请求映射
qq_44901346的博客
08-16 919
@GetMapping、@PostMapping、@PutMapping等：他们相当于RequestMapping(value = “/xxx” , method = RequestMethod.GET)或 RequestMapping(value = “/xxx” , method = RequestMethod.POST)，即限定请求方法的简写。 请求映射原理 什么是请求映射？ 个人理解：首先在浏览器搜索一个URL会向程序发送请求，程序会对其进行处理，找到对应的页面。或 当提交表单时也会对程序发送pos
SpringBoot中请求映射的原理(源码)
cristianoxm的博客
01-15 1844
一、先看一下SpringMVC解析流程 二、SpringBoot请求映射原理 SpringBoot跟spring一脉相承，所以直接找DispatcherServlet这个类。 其继承关系如下： 从此图可以看出继承树，最终是来到HttpServlet的，也就是说必然会有doGetPost方法。而HttpServlet并没有，于是顺着关系找下去。 在FrameworkServlet中，我们发现了重写了doGet/doPost的方法： 而doGet/doPost两个方法都是调用processRequest
SpringBoot中设置静态资源映射路径
qq_65455837的博客
05-24 1704
创建WebConfig类（类名随意，最好见名知意），实现WebMvcConfigurer接口，并在WebConfig类中提供WebMvcConfigurer接口中addResourceHandlers方法的具体实现。当静态资源没放在这些默认目录下，Spring Boot应用就不能直接访问它们。而addResourceLocations则指定了这些请求应该映射到的静态资源路径。只要将静态资源放在这些默认目录下，Spring Boot应用就能直接访问它们。
小功能实现（十七）SpringBoot虚拟路径映射，前端通过后端直接获取服务器文件
qq_44648936的博客
08-13 763
前端访问服务器静态文件
【Spring Boot】Web开发 — URL映射
衍生星球的博客
07-19 1306
上节介绍介绍了@Controller和@RestController等注解，那么Spring Boot是如何将HTTP请求映射到具体方法的呢？Spring Boot支持URL路径匹配、HTTP Method匹配、params和header匹配等URL映射。本节开始介绍Spring Boot的URL映射。
SpringBoot设置文件虚拟路径映射
热门推荐
花伤情犹在的博客
11-06 1万+
前言 我们在写SpringBoot项目的时候，很大几率会遇到文件上传与下载功能。 我们一般访问服务器的资源都是resources下的公开资源，配置文件中一般会指定到类路径下的static文件夹下：spring.resources.static-locations=classpath:/static/，或者说不配置默认指定在类路径下：classpath:/，例如： # 应用服务 WEB 访问端口 server.port=8080 # 项目资源路径：必须加static作为前缀才能访问 默认为/** spring
SpringBoot -请求处理原理（浅析）
VillWow的博客
06-06 993
SpringBoot -请求处理原理（浅析）
springboot源码分析： 请求方式+请求映射原理+获取参数原理
正月看雪花的博客
03-25 646
注解相关 @AliasFor：.在同个注解中为同一个功能定义两个名称不一样的属性，那么这两个属性彼此互为别名 @RequestMapping注解里面的代码 @AliasFor("path") String[] value() default {}; @AliasFor("value") String[] path() default {}; @GetMapping @PostMapping @DeleteMapping等都是@RequestMapping修饰 @RequestMapping(met
SpringBoot常用请求方式
qq_37959253的博客
12-29 860
SpringBoot常用请求方式
SpringBoot·路径映射
qq_43308318的博客
04-15 693
路径映射 配置路径映射 需要重写WebMvcConfigurer的addViewControllers方法 将配置的复杂路径，可以直接通过自定义的映射路径进行访问 例如：http://localhost:8080/login @Configuration public class WebMvcConfig implements WebMvcConfigurer { @Override public void addViewControllers(ViewControllerRegi
SpringBoot2：请求处理原理分析-请求Path与接口的映射关系(HandlerMapping)
最新发布
Brave_heart4pzj的博客
09-05 1225
SpringBoot
springboot配置跨域、静态资源地址映射、拦截指定地址资源
进击的豌豆的博客
09-08 1859
springboot配置跨域、静态资源地址映射、拦截指定地址资源
SpringBoot---web--＞＞请求映射原理【快乐的源码】
wowo
12-26 598
Web---请求映射原理 首先，在原生servlet中处理请求的是doget和dopost方法，在spring中处理请求的首先是dispatcherservlet，所以先来到DispatcherServlet源码 发现它继承了FrameworkServlet，这个FrameworkServlet继承了HttpServletBean，说明dispatcherServlet是一个原生servlet，FrameworkServlet继承了HttpServletBean，HttpServletBean继承了Ht
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值