DispatcherServlet源码分析（二）

最新推荐文章于 2024-02-27 19:54:36 发布
最新推荐文章于 2024-02-27 19:54:36 发布
阅读量320 收藏 3
点赞数
分类专栏： SpringMVC 源码分析 文章标签： 源码分析 SpringMVC Spring DispatcherServlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng522243062/article/details/87796361
版权

目录

以下源码分析基于 Spring的5.1.3 版本

先上SpringMVC的流程图：
在这里插入图片描述

我们知道DispatcherServlet是SpringMVC的一个关键类，关键点 是DispatcherServlet重写了FrameworkServlet的doService()方法，doService()又调用了doDispatch()方法，这两个方法是整个程序的关键点。接下来的分析会穿插SpringMVC各个组件来对DispatherServlet进行分析。

初始化组件initStrategies()

DispatcherServlet首先做的就是初始化工作，看initStrategies()方法：

	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);//初始化上传请求组件
		initLocaleResolver(context);//国际化解析器
		initThemeResolver(context);//主题解析器
		initHandlerMappings(context);//处理器映射器
		initHandlerAdapters(context);//处理器适配器
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);//视图解析器
		initFlashMapManager(context);//重定向属性管理器
	}

我们可以看到initStrategies()方法里面初始化了Multipart组件、国际化解析器、主题解析器、一堆处理器映射器、一堆处理器适配器、视图解析器、重定向属性管理器等等，这样初始化后，诸如处理器映射器、处理器适配器等的组件就可以在后面使用了。

doService()

doService()源码如下：

	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		logRequest(request);

		//1、首先判断是不是 include 请求，如果是则对 request 的 Attribute 做个快照备份
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}

		// 提供框架对象处理程序和视图对象。(也就是Spring MVC中特殊的几个bean)
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		// spring mvc支持i18n
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		// spring mvc支持主题
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
		
		// 2、重定向属性处理，对Redirect的支持，解决了POST/Redirect/GET模式问题
		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 {
			// 3、前端处理请求分发
			doDispatch(request, response);
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// 4、等 doDispatcher 处理完之后（如果不是异步调用且未完成）对已备份好的快照进行还原 ，在做完快照后又对 request设置了一些属性。
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

可以看到doService()方法里面首先判断请求是否为include请求，如果是则将request的attributes做一个快照备份。等doDispatcher()处理完后就（如果不是异步调用且未完成）进行还原 ，在做完快照后又对 request 设置了一些属性。

doDispatcher()

doDispatcher()开始真正对请求进行处理分发。这个方法是整个DispatcherServlet的重点，中间会穿插一些SpringMVC的组件来讲，篇幅较长。

上源码（里面的注释会有对源码的解释）：

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、先检查请求是不是Multipart请求，如果是则返回已处理的request，否则返回原来的request
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				//2、遍历HandlerMappings集合，根据HandlerMapping来获取HandlerExecutionChain
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);//对response进行处理，返回404
					return;
				}

				//3、根据Handler（该Handler是在由request获取回来的HandlerExecutionChain里面的）返回适配的HandlerAdapter
				// HandlerAdapter里有handle()方法，这个方法就是实际执行Controller方法的地方
				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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				
				//4、HandlerExecutionChain里注册了一系列拦截器（包括你自己定义并注册了的拦截器以及Spring的拦截器），而applyPreHandle()就是执行一系列拦截器的地方
				//如果拦截器不拦截，则继续流程（拦截器会在另一篇博文讲）
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				//5、这里调用HandlerAdapter里的handle()方法，这个方法就是实际执行Controller里的方法的地方
				// 处理完后会返回ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
				//6、用RequestToViewNameTranslator组件生成ViewName字符串并设置到ModelAndView里
				applyDefaultViewName(processedRequest, mv);
				//7、调用HandlerExecutionChain的拦截器的postHandle()方法
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				//用在下面的processDispatchResult()方法里
				dispatchException = ex;
			}
			catch (Throwable err) {
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			//8、渲染view视图，以及调用HandlerExecutionChain里的拦截器的afterCompletion()方法
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}
源码分析

以下前序与上面源码注释的前序对应

1、先利用MultipartResolver的isMultipart()来判断请求是不是multipart请求，如果是，则用resolveMultipart()将request包裹成MultipartHttpServletRequest并将其返回，否则返回原request。

	//跳转-->doDispatch()
	processedRequest = checkMultipart(request);
	//------------------------------------------
	protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
		if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
			//...
			//  
			return this.multipartResolver.resolveMultipart(request);	
			//...
		}
		return request;
	}

2、HandlerMapping有一个getHandler()方法，该方法用来获取HandlerExecutionChain。因为在DispatcherServlet里一开始已经初始化了一堆HandlerMappings，于是遍历所有的已注册HandlerMapping，并调用它的getHandler()方法来获取HandlerExecutionChain。

//跳转-->doDispatch()
mappedHandler = getHandler(processedRequest);
//---------------------------------------------
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
}

3、获取HandlerExecutionChain之后，就要获取HandlerAdapter。先从初始化得来的一堆HandlerAdapters中，调用HandlerAdapter的support()方法看看该HandlerAdapter是否支持该处理器，若支持就返回该HandlerAdapter

	//跳转-->doDispatch()
	HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
	//---------------------------------------------------------------------
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		//...
	}

4、因为HandlerExecutionChain里面有处理器Handler和拦截器，这里是在调用处理器前，先调用拦截器的preHandle()方法。

	//跳转-->doDispatch()
	if (!mappedHandler.applyPreHandle(processedRequest, response)) {
		return;
	}			
	//--------------------------------------------------------------	
	boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = 0; i < interceptors.length; i++) {
				HandlerInterceptor interceptor = interceptors[i];
				if (!interceptor.preHandle(request, response, this.handler)) {
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}

5、执行完拦截器的preHandle()后，程序就调用HandlerAdapter的handle()方法，该方法是真正执行Controller方法的入口，执行完Controller方法后就返回ModelAndView。

	//跳转-->doDispatch()
	mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
	//跳转-->HandlerAdapter
	public interface HandlerAdapter {

		boolean supports(Object handler);
	
		ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
	
		long getLastModified(HttpServletRequest request, Object handler);
	
}

关于HandlerAdapter接口，SpringMVC有具体的实现类，如：
在这里插入图片描述
我会另开一篇博文详细讲解SpringMVC的各个组件，里面会讲解HandlerAdapter的实现类。

6、这里涉及到RequestToViewNameTranslator这个组件，SpringMVC有一个实现类DefaultRequestToViewNameTranslator。用RequestToViewNameTranslator组件的getViewName()，将HttpServletRequest请求的uri转换成ViewName字符串并设置到ModelAndView里。

	//跳转-->doDispatch()
	applyDefaultViewName(processedRequest, mv);
	//跳转-->applyDefaultViewName()
	private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
		if (mv != null && !mv.hasView()) {
			String defaultViewName = getDefaultViewName(request);
			if (defaultViewName != null) {
				mv.setViewName(defaultViewName);
			}
		}
	}
	//跳转-->getDefaultViewName()
	protected String getDefaultViewName(HttpServletRequest request) throws Exception {
		return (this.viewNameTranslator != null ? this.viewNameTranslator.getViewName(request) : null);
	}
	//跳转-->DefaultRequestToViewNameTranslator # getViewName()
	public String getViewName(HttpServletRequest request) {
		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
		return (this.prefix + transformPath(lookupPath) + this.suffix);
	}

7、遍历拦截器，调用拦截器的postHandle()方法

//跳转-->doDispatch()
mappedHandler.applyPostHandle(processedRequest, response, mv);
//--------------------------------------------------------------
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)						  
		throws Exception {
		HandlerInterceptor[] interceptors = getInterceptors();
		if (!ObjectUtils.isEmpty(interceptors)) {
			for (int i = interceptors.length - 1; i >= 0; i--) {
				HandlerInterceptor interceptor = interceptors[i];
				interceptor.postHandle(request, response, this.handler, mv);
			}
		}
	}

8、这个processDispatchResult()处理Handler执行后的结果，将ModelAndView或者Exception（这里又涉及到HandlerExceptionResolver这个组件，将Exception处理成ModelAndView）渲染成视图，然后调用render()生成页面

	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
			@Nullable Exception exception) throws Exception {

		boolean errorView = false;
		//将Exception包裹成ModelAndView
		if (exception != null) {
			if (exception instanceof ModelAndViewDefiningException) {
				logger.debug("ModelAndViewDefiningException encountered", exception);
				mv = ((ModelAndViewDefiningException) exception).getModelAndView();
			}
			else {
				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
				mv = processHandlerException(request, response, handler, exception);
				errorView = (mv != null);
			}
		}
			//...
			render(mv, request, response);
			//...
		if (mappedHandler != null) {
			//执行拦截器的afterCompletion()方法
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

可以看到render()就是通过resolveViewName()来用ModelAndView里的ModelMap渲染生成View，这里涉及到ViewResolver和LocaleResolver组件。

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
		// Determine locale for request and apply it to the response.
		Locale locale =
				(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
		response.setLocale(locale);

		View view;
		String viewName = mv.getViewName();
		if (viewName != null) {
			// We need to resolve the view name.
			view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
			if (view == null) {
				throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
						"' in servlet with name '" + getServletName() + "'");
			}
		}
		else {
			// No need to lookup: the ModelAndView object contains the actual View object.
			view = mv.getView();
			if (view == null) {
				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
						"View object in servlet with name '" + getServletName() + "'");
			}
		}

		// Delegate to the View object for rendering.
		if (logger.isTraceEnabled()) {
			logger.trace("Rendering view [" + view + "] ");
		}
		try {
			if (mv.getStatus() != null) {
				response.setStatus(mv.getStatus().value());
			}
			view.render(mv.getModelInternal(), request, response);
		}
		catch (Exception ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Error rendering view [" + view + "]", ex);
			}
			throw ex;
		}
	}

ViewNameTranslator以及ViewResolver组件在生成View视图的时候会被调用

protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,
			Locale locale, HttpServletRequest request) throws Exception {
		if (this.viewResolvers != null) {
			for (ViewResolver viewResolver : this.viewResolvers) 
				View view = viewResolver.resolveViewName(viewName, locale);
				if (view != null) {
					return view;
				}
			}
		}
		return null;
}
邓冬菇
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring源码分析.rar
12-23
《Spring源码分析》 Spring框架作为Java领域最流行的开源框架之一，它的设计思想和实现方式一直是许多开发者深入研究的对象。这份"Spring源码分析"资料深入探讨了Spring的核心机制，帮助我们理解其背后的原理，从而...
springmvc源码分析
12-29
在这个源码分析中，我们将深入探讨Spring MVC的核心组件和工作流程。 1. **DispatcherServlet**：Spring MVC的入口点，它是所有请求的前端控制器。当一个HTTP请求到达服务器时，DispatcherServlet负责拦截请求，并...
DispatcherServlet核心方法doDispatch解析
shining的专栏
05-11 629
参照《跟开涛学SpringMVC》中关于springMVC的核心架构图来理解doDispatch方法： doDispatch方法及流程说明： protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServlet...
HTTP执行流程，SpringMVC执行流程，Java一次HTTP请求容器做了哪些事情，过滤器、拦截器、AOP执行流程【超详细解答】
小道仙的后宫
07-24 756
HTTP执行流程，SpringMVC执行流程，Java一次HTTP请求容器做了哪些事情，过滤器、拦截器、AOP执行流程
SpringMVC之请求处理流程
HongYu012的博客
03-09 322
SpringMVC之请求处理流程 我们知道DispatcherServlet就是一个HttpServlet,而HttpServlet的请求就从doGet/doPost开始 DispatcherServlet本身没有实现doGet/doPost,而由他的父类FrameworkServlet实现,源码如下 FrameworkServlet.doGet/doPost @Override protected final void doGet(HttpServletRequest request, Http
SpringMVC源码解析---doDispatch
gongsenlin341的博客
10-29 898
文章目录1.概述2.doDispatch2.1 getHandler2.2 getHandlerAdapter2.3 applyPreHandle2.4 handle2.5 applyDefaultViewName2.6 applyPostHandle2.7 processDispatchResult3.总结 1.概述 先提个问题：当浏览器发起http请求，SpringMVC是如何拦截的？又是如何处理请求并响应给用户的呢？ 不清楚的读者可以接着往下看。 SpringMVC是基于Servlet实现的。有一个重
Spring MVC系列（7）-DispatcherServlet处理请求流程源码分析
记录知识、锤炼自我
09-11 718
前言 在之前我们了解到了DispatcherServlet是如何初始化的，接下来我们了解下他是如何处理请求的呢？ Tomcat处理请求流程 首先，我们了解下Tomcat启动后是如何处理HTTP请求的？ 文档来源 网络通信三要素 IP地址：计算机在网络上的唯一标示,通过ip找到通信所在的机器 端口：端口是一台机器上不同程序的标示 传输协议：双方都遵守的传输数据的格式 HTTP工作原理 HTTP协议是浏览器与服务器之间的数据传送协议。作为应用层协议，HTTP是基于TCP/IP协议来传递数据的（HTML文件、
Spring源码学习九：DispatcherServlet初始化源码分析1
08-04
Spring源码学习九：DispatcherServlet初始化源码分析1 DispatcherServlet是SpringMVC的核心分发器，它实现了请求分发，是处理请求的入口，本篇将深入源码分析它的初始化过程。 首先，从DispatcherServlet的名称上...
Spring源码学习十：DispatcherServlet请求分发源码分析1
08-04
本篇文章将深入探讨DispatcherServlet的请求分发流程。 DispatcherServlet继承自HttpServlet，其核心功能在于处理HTTP请求。在Servlet的service方法中，DispatcherServlet会接收到请求并进行分发。在...
Tom_深入分析Spring源码
02-06
《Spring源码分析》这份资料深入探讨了Spring框架的核心机制，尤其聚焦于Spring5版本。Spring作为Java领域中最重要的轻量级应用框架之一，它的设计理念、实现方式以及工作原理对于任何想成为优秀Java开发者的人都至...
DispatcherServlet详解
weixin_44399827的博客
08-01 1万+
在介绍DispatcherServlet的时候，我们得先了解 ，servlet。那什么时候servlet勒。 servlet是基于http协议的，在服务端(如Tomcate)运行的，是按照servlet规范编写的一个Java类。做Java Web开发的应该都了解它。主要用于处理客户端的请求并将其结果发送至客户端。servlet的生命周期可分三个阶段：初始化、运行和销毁。 1.初始化阶段 (1) servlet容器加载servlet类，把servlet类的.class文件中的数据读至内存中。 (2) se
【JavaEE进阶】 拦截器(DispatcherServlet)源码简介
最新发布
m0_71731682的博客
02-27 1808
上一篇博客我们使用了拦截器，那么拦截器是如何实现拦截的呢？接下来我们将从源码来看一下是如何实现拦截的。适配器模式,也叫包装器模式.将⼀个类的接⼝，转换成客⼾期望的另⼀个接⼝,适配器让原本接⼝不兼容的类可以合作⽆间.简单来说就是⽬标类不能直接使⽤,通过⼀个新类进⾏包装⼀下,适配调⽤⽅使⽤.把两个不兼容的接⼝通过⼀定的⽅式使之兼容.比如下⾯两个接⼝,本⾝是不兼容的(参数类型不⼀样,参数个数不⼀样等等可以通过适配器的⽅式,使之兼容。
springmvc——DispatcherServlet源码解析
nianqingren_的博客
05-15 960
1、DispatcherServlet的类结构。   以上就是DispatcherServlet的类结构，它最终是继承了HttpServlet，所以它最终会被tomcat容器所实例化，然后具体对于DispatcherServlet的初始化和对请求的响应是通过DispacherServlet、FrameworkServlet、HttpServletBean一起联合实现。 2、DispatcherServlet的初始化 调用Dispatch erServlet的无参构造函数。 然后再调用从HttpSe
springMVC源码-DispatcherServlet源码
weixin_44044929的博客
03-04 660
DispatcherServlet介绍 DispatcherServlet 就是一个servlet 类，无非就是包装起来根据url能够映射找到我们的springMVC中定义的请求方法。 DispatcherServlet 的继承关系 DispatcherServlet 继承 FrameworkServlet 继承 HttpServlet 面向对象基本思想：重写、先走父类，再走子类 所以:先看HttpServlet类再找到我们最后的子类 DispatcherServlet 源码流程分析 框架流程 Sprin
SpringMVC-解读DispatcherServlet源码
HongYu012的博客
03-07 588
SpringMVC 学习完Spring框架技术之后，差不多会出现两批人： 一批是听得云里雾里，依然不明白这个东西是干嘛的； 还有一批就是差不多理解了核心思想，但是不知道这些东西该如何去发挥它的作用。 在SpringMVC阶段，你就能逐渐够体会到Spring框架为我们带来的便捷之处了。 此阶段，我们将再次回到Tomcat的Web应用程序开发中，去感受SpringMVC为我们带来的巨大便捷。 MVC理论基础 在之前，我们给大家讲解了三层架构，包括： 每一层都有着各自的职责，其中最关键的当属..
【Spring MVC】DispatcherServlet详解（容器初始化超详细过程源码分析）
热门推荐
Yngz_Miao的博客
03-07 1万+
也就是说，在初始化的过程中，程序会首先读取ContextLoader类的同目录下的属性文件ContextLoader.properties，并根据其中的配置提取将要实现WebApplicationContext接口的实现类，并根据这个类通过反射进行实例的创建。在initServletBean()方法中，设计了一个计时器来统计初始化的执行时间，还提供了一个initFrameworkServlet()用于子类的覆盖操作，而作为关键的初始化逻辑给了initWebApplicationContext()方法。
DispatcherServlet源码
thebigdipperbdx的博客
09-22 352
介绍 DispatcherServlet是前端控制器,配置在web.xml文件中的。 Spring版本===>spring-webmvc-4.3.12.RELEASE 源码 访问JSP页面，入口是doService方法 org.springframework.web.servlet.DispatcherServlet#doService方法 @Override protected...
详解SpringMVC请求的时候是如何找到正确的Controller[附带源码分析]
weixin_33738555的博客
05-26 689
目录 前言 源码分析 重要接口介绍 SpringMVC初始化的时候做了什么 HandlerExecutionChain的获取 实例 资源文件映射 总结 参考资料 前言 SpringMVC是目前主流的Web MVC框架之一。 如果有同学对它不熟悉，那么请参考它的入门blog：http://www.cnblogs.com/fangjian0423/p/sp...
DispatcherServlet源码解析（未完，待续）
西瓜游侠的博客
07-14 470
SpringBoot版本：2.3.1.RELEASE 1 DispatcherServletAutoConfiguration DispatcherServlet在SpringBoot中的自动装配是由DispatcherServletAutoConfiguration完成的。 源码： // 指定自动配置类的优先级顺序，DispatcherServletAutoConfiguration在自动配置类中拥有最高优先级 @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENC.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值