SpringMVC 执行流程源码解析

最新推荐文章于 2022-10-29 23:59:31 发布
最新推荐文章于 2022-10-29 23:59:31 发布
阅读量450 收藏
点赞数
分类专栏： Spring 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42346558/article/details/121967014
版权

文章目录


办公设备租赁，深圳惠源.

前言

SpringMVC提供了统一的入口DispatcherServlet，有该Servlet分发到各处理器并返回视图，所以从DispatcherServlet开始分析即可。

一、DispatcherServlet

包含了SpringMVC 的整个执行流程，从DispatcherServlet的继承结构和方法调用栈可以看到最终会到DispatcherServlet的doServcie方法开始执行，所以从doServcie方法开始分析。
在这里插入图片描述
在这里插入图片描述

1、doServcie

		// 设置常用实例到request属性域
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
		try {
			// 分发处理请求
			doDispatch(request, response);
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}

2、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 {
			    // 判断并处理文件请求-MultipartHttpServletRequest contentType.toLowerCase().startsWith("multipart/");
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// 获取Handler 
				mappedHandler = getHandler(processedRequest);

				// 获取处理器适配器，由于处理器不一样，有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;
					}
				}
				
				// 执行MVC拦截器得前置方法 如果前置方法返回false，则表示不执行业务方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// 适配器执行handler业务方法 以 RequestMappingHandlerAdapter 分析
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

				applyDefaultViewName(processedRequest, mv);
				// 执行MVC拦截器得后置方法
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
			// 处理返回结果 ModelView
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
		// 执行MVC 拦截器得afterCompletion
			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);
				}
			}
		}
	}

3、getHandler

遍历循环当前所有HandlerMapping获取处理器
在这里插入图片描述

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;
	}

4、getHandlerAdapter

获取处理器适配器，由于Handler，可能是Controller，也可能是Method，所以需要适配器进行适配。
在这里插入图片描述

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				// 判断是否是该适配器进行适配 以HttpRequestHandlerAdapter进行分析
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}

5、applyPreHandle

执行拦截器前置处理。

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)) {
					// 触发执行拦截器的afterCompletion
					triggerAfterCompletion(request, response, null);
					return false;
				}
				this.interceptorIndex = i;
			}
		}
		return true;
	}

6、handle

业务方法执行。

public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return handleInternal(request, response, (HandlerMethod) handler);
	}

6、processDispatchResult

处理返回结果/异常/MV

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

		boolean errorView = false;
		
		// 处理异常 HandlerExceptionResolver
		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);
			}
		}

		// 是否返回了一个ModelAndView
		if (mv != null && !mv.wasCleared()) {
			// 渲染ModelAndView
			render(mv, request, response);
			if (errorView) {
				WebUtils.clearErrorRequestAttributes(request);
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("No view rendering, null ModelAndView returned.");
			}
		}

		if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
			// Concurrent handling started during a forward
			return;
		}

		if (mappedHandler != null) {
			// 执行拦截器的AfterComplete方法
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

7、render

渲染视图

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) {
			// 通过ViewResolver解析View
			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来具体实现渲染视图
			view.render(mv.getModelInternal(), request, response);
		}
		catch (Exception ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Error rendering view [" + view + "]", ex);
			}
			throw ex;
		}
	}

二、AbstractHandlerMapping

抽象AbstractHandlerMapping，由具体子类去实现getHandlerInternal，并封装返回执行器链

1、getHandler

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		// 获取具体得Handler，由子类实现，以下分析下通用得RequestMappingHandlerMapping
		Object handler = getHandlerInternal(request);
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		// Bean name or resolved handler?
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}

		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

		if (logger.isTraceEnabled()) {
			logger.trace("Mapped to " + handler);
		}
		else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
			logger.debug("Mapped to " + executionChain.getHandler());
		}

		if (hasCorsConfigurationSource(handler)) {
			CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			config = (config != null ? config.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}

		return executionChain;
	}

三、RequestMappingHandlerMapping

1、afterPropertiesSet

由于RequestMappingHandlerMapping实现了InitializingBean，该方法在RequestMappingHandlerMapping实例化后会被Spring调用。设置urlHelper，pathMatche，建立url和method的映射

public void afterPropertiesSet() {
		this.config = new RequestMappingInfo.BuilderConfiguration();
		this.config.setUrlPathHelper(getUrlPathHelper());
		this.config.setPathMatcher(getPathMatcher());
		this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
		this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
		this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
		this.config.setContentNegotiationManager(getContentNegotiationManager());		// 执行父类方法
		super.afterPropertiesSet();
	}

    public void afterPropertiesSet() {
		initHandlerMethods();
	}

2、initHandlerMethods

初始化HandlerMethod，建立url和method的映射

protected void initHandlerMethods() {
		// 获取当前spring所有Bean名称，处理所有候选Bean
		for (String beanName : getCandidateBeanNames()) {
			if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
				processCandidateBean(beanName);
			}
		}
	}

// 处理候选Bean
protected void processCandidateBean(String beanName) {
		Class<?> beanType = null;
		try {
		// 获取Handler类型
			beanType = obtainApplicationContext().getType(beanName);
		}
		catch (Throwable ex) {
			// An unresolvable bean type, probably from a lazy bean - let's ignore it.
			if (logger.isTraceEnabled()) {
				logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
			}
		}
		// 判断是否Handler
		if (beanType != null && isHandler(beanType)) {
			// 处理并映射HandlerMethods
			detectHandlerMethods(beanName);
		}
	}


// 判断是否Handler
	protected boolean isHandler(Class<?> beanType) {
	//判断是否有RequestMapping注解或者是否实现了Controller
		return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
				AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
	}

3、detectHandlerMethods

protected void detectHandlerMethods(Object handler) {
		// 获取Handler类型
		Class<?> handlerType = (handler instanceof String ?
				obtainApplicationContext().getType((String) handler) : handler.getClass());

		if (handlerType != null) {
		// 获取Handler真正的类型，存在被代理
			Class<?> userType = ClassUtils.getUserClass(handlerType);
			// 获取Handler中所有被@RequestMpping注解的方法
			Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
					(MethodIntrospector.MetadataLookup<T>) method -> {
						try {
							return getMappingForMethod(method, userType);
						}
						catch (Throwable ex) {
							throw new IllegalStateException("Invalid mapping on handler class [" +
									userType.getName() + "]: " + method, ex);
						}
					});
			if (logger.isTraceEnabled()) {
				logger.trace(formatMappings(userType, methods));
			}
			// 奖所有methods以HandlerMethod的方式注册到mappingRegistry中，
			// HandlerMethod = Handler + Method
			methods.forEach((method, mapping) -> {
				Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
				registerHandlerMethod(handler, invocableMethod, mapping);
			});
		}
	}

3、getHandlerInternal

获取HandlerMethod

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		// 获取截取host+contextPath后的url
		// 比如请求url: http://localhost/backend/login，context-path为/backend，则lookupPath=/login
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		// 放入request域
		request.setAttribute(LOOKUP_PATH, lookupPath);
		// 加读锁
		this.mappingRegistry.acquireReadLock();
		try {
		// 查找HandlerMethod，业务执行方法
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
		// 释放读锁
			this.mappingRegistry.releaseReadLock();
		}
	}

4、lookupHandlerMethod

查找HandlerMethod

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
		// 获取截取host+contextPath后的url
		// 比如请求url: http://localhost/backend/login，context-path为/backend，则lookupPath=/login
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		// 放入request域
		request.setAttribute(LOOKUP_PATH, lookupPath);
		// 加读锁
		this.mappingRegistry.acquireReadLock();
		try {
		// 查找HandlerMethod，业务执行方法
			HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
			return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
		}
		finally {
		// 释放读锁
			this.mappingRegistry.releaseReadLock();
		}
	}

四、HttpRequestHandlerAdapter

执行器适配器

1、supports

判断是否该适配器适配

public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}

2、handle

执行子类业务方法

public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return handleInternal(request, response, (HandlerMethod) handler);
	}

3、handleInternal

执行业务方法

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

		// 判断是否需要session锁进行同步处理
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// 执行业务方法
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// 执行业务方法
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}

		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}

3、invokeHandlerMethod

执行业务方法

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

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {
			// 将所有有@InitBinder注解的方法封装
			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
			// 将binderFactory和@ModelAndAttribute的封装起来
			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));
			// 执行@ModelAndAttribute的方法
			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
			mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
            // 执行业务方法
			invocableMethod.invokeAndHandle(webRequest, mavContainer);
			if (asyncManager.isConcurrentHandlingStarted()) {
				return null;
			}

			// 获取ModelAndView
			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
        // 获取参数，执行业务方法
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
	    try {
	    	// ReturnValueHandler处理返回值
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}
		catch (Exception ex) {
			if (logger.isTraceEnabled()) {
				logger.trace(formatErrorForReturnValue(returnValue), ex);
			}
			throw ex;
		}
	}

// 获取ModelAndView
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
			ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {

		modelFactory.updateModel(webRequest, mavContainer);
		// 如果已经被ReturnValueHandler处理过的，不需要由SpringMVC处理了
		if (mavContainer.isRequestHandled()) {
			return null;
		}
		ModelMap model = mavContainer.getModel();
		ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
		if (!mavContainer.isViewReference()) {
			mav.setView((View) mavContainer.getView());
		}
		if (model instanceof RedirectAttributes) {
			Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
			HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
			if (request != null) {
				RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
			}
		}
		return mav;
	}

办公设备租赁，深圳惠源.

weixin_42346558
关注
专栏目录
Spring MVC的流程及源码分析
BorisCao的博客
04-27 1168
1.Spring MVC通过前置控制器DispatcherServlet处理客户端请求,这里用到了DispatcherServlet的doService方法中的doDispatch DispatcherServlet.java protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { logRequest(request);` .....省略其他代码 t
带你深入最新版本SpringMVC执行流程底层源码解析
DramaLifes的博客
12-04 513
SpringMVC执行流程 首先我们学过SpringMVC的一定会去学习SpringMVC的执行流程，而且那个流程如此复杂，各种步骤各个模块，流程繁杂，首先千篇一律的介绍流程。 本人也从网上查找到部分的讲解 版本一： （1）用户发送请求至前端控制器DispatcherServlet； （2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle； （3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并
SpringMVC执行流程（源码分析）
qq_43600166的博客
10-16 1631
SpringMVC大体流程，请求URL如何与HandlerMethod对应？AbstractHandlerMethodMapping初始化HandlerMethod。源码分析AbstractHandlerMethodMapping初始化HandlerMethod流程。一个请求到SpringMVC的完整流程，DispatcherServlet如何接收用户请求？ 分析DispatchServlet.doDispatch方法如何处理请求
SpringMVC执行流程源码分析
yoobig的博客
08-06 459
这货,太干了!!!
SpringMVC的工作流程源码解读
李哈zzz的博客
01-05 768
SpringMVC工作流程超级仔细的源码解读，1、用户发送请求首先会到SpringMVC中央处理器dispatcherServlet接收到请求，2、HandleMapping解析请求，3、HandleAdpater执行请求返回ModelAndView，4、ViewResolver视图解析器解析ModelAndView返回View，5、View获取真正的视图返回给dispatcherServlet，6、dispatcherServlet返回给前段！
springmvc工作流程（一）（源码解读）
西木风落
12-23 482
springmvc是对servlet的封装，核心的DispatcherServlet最终继承自HttpServlet。同时，springmvc做为spring家族一员，将和web相关的处理器托付给springmvc容器，使得对象的管理和spring保持一致。
SpringMvc主要流程源码解析（1）.zip
08-16
在 SpringMvc 主要流程源码解析（1）.vep 文件中，可能详细分析了以上各个步骤的源码实现，包括 DispatcherServlet、HandlerMapping、Controller、HandlerAdapter、DataBinder、ViewResolver 和 View 的工作原理。...
SpringMVC源码深度解析
最新发布
weixin_56644618的博客
10-29 3150
springmvc的源码解析，建议收藏，多看几遍！！！
SpringMVC请求流程源码分析.doc
07-09
### SpringMVC请求流程源码分析 #### 一、SpringMVC使用与配置 ##### 1. 工程创建 为了构建一个支持SpringMVC框架的项目，首先需要创建一个Maven工程。在这个过程中，我们需要完成以下几个步骤： - **创建项目...
SpringMVC demo 完整源码实例下载
05-02
通过分析和运行这个示例，你将能更深入地理解和掌握SpringMVC框架的各个方面，包括但不限于模型绑定、数据验证、视图解析、AOP（面向切面编程）、依赖注入以及MVC的完整流程。这将为你的Java Web开发技能打下坚实的...
springmvc 的工作流程.docx
05-19
springmvc的常见流程，让初学者简单容易理解明白，更深层次再看源码
springMVC工作流程及源码剖析
http://itzones.cn
07-05 1017
一、首先了解springMVC的组件定义及用途    1.DisPatcherServlet：前端控制器（不需要程序员开发）       用户请求到达前端控制器，它相当于MVC模式中的C（Controller），DispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet的存       在降低了组件之间的耦合性。
SpringMVC执行流程源码解析
u010215318的博客
03-30 222
SpringMVC执行过程 模型图 整体流程 Springmvc细节部分 现在我们从DispatchServlet开始分析 在DispatchServlet的父类FrameworkServelt中有doget,dopost,doput,dodelete等方法，这些方法都执行了processRequest方法，这个方法又执行了doService方法，doService在FrameworkServelt中是个虚方法，真正的实现在DispatchServlet中,在这个方法中定义了一些request属性，然后
Spring MVC 执行流程和源码分析
刘剑峰的博客
01-31 1454
一、Spring MVC的执行流程第一步：发起请求到前端控制器(DispatcherServlet) 第二步：前端控制器请求HandlerMapping查找 Handler（相当于Struts2的Action） 可以根据xml配置、注解进行查找 第三步：处理器映射器HandlerMapping处理查找Handler 第四步：处理器映射器HandlerMapping返回一个执行器链，
Spring-MVC流程及源码解析(二) SpringMVC的执行流程
欢迎来到wise哲的博客空间
05-09 1654
    上篇文章(https://blog.csdn.net/f1004145107/article/details/78590847)    介绍了一下SpringMVC的初始化过程,本篇文章我们正式开始进入SpirngMVC的执行流程   首先,还是先进入DispatcherServlet中,跳过要加载的组件(如需看加载的组件请看上一篇博客文章微博)我们直接来到doService()方法   ...
SpringMVC工作流程源码剖析
代码宇宙
03-14 539
原文链接： https://juejin.im/post/5e6b0ee3e51d4526f65cdb50. 0x0 先看名词 DispactherServlet：SpringMVC 的心脏，所有的请求从这里进入，也从这里出去 HandlerAdapter：请求处理器 HandlerMapping:请求和处理对象间的映射关系，可以理解为 地址 /api 对应 @RequestMapping("/...
五、Spring MVC主要流程和源码解析
zealon的博客
03-21 756
目录 一、spring mvc 功能特性 1、回顾servlet 与jsp 执行过程 2、spring mvc 功能特性 3、请求处理流程 4、spring mvc 示例 二、mvc 体系结构详解 1、spring mvc 框架组件 2、HandlerMapping 详解 3、HandlerAdapter 详解 4、ViewResolver 与View 详解 一、spring mvc 功能特性 1、回顾servlet 与jsp 执行过程 流程说明： 请求Serv...
SpringMVC的工作流程和源码分析
JinKin_OldWang的博客
03-20 374
SpringMVC框架是一个基于请求驱动的Web框架，并且使用了‘前端控制器’模型来进行设计，再根据‘请求映射规则’分发给相应的页面控制器进行处理。 整体流程 具体步骤： 1、 首先用户发送请求到前端控制器，前端控制器根据请求信息（如 URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；图中的 1、2 步骤； 2、 页面控制器接收到请求后，进行...
SpringMVC执行流程详解：深度剖析与入门指南
本文主要探讨了SpringMVC的执行过程，SpringMVC是Spring框架中的一个重要组件，用于构建基于模型-视图-控制器（Model-...通过了解这个执行流程，开发者能够更好地组织代码，提高开发效率，并确保应用的健壮性和扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值