DispatcherServlet解读

DispatcherServlet浅析 介绍 ​ DispatcherServlet是一个Servlet,在springmvc中被称为前端控制器,根据请求的路径、类型等进行请求的分发。 分析 DispatcherServlet类图 ​ 上图中的红色部分为Servlet接口,在Springmvc中实现并扩展了该Servlet接口。在我最早学javaweb开发时,并不是上来就使用各种MVC框架,而是从编写简单的Servlet开始,就是继承HttpServlet后,重写它的service方法。而Springmvc的设计同理,它也继承... 阅读详情

  SpringMVC的核心就是DispatcherServlet,DispatcherServlet实质也是一个HttpServlet。DispatcherSevlet负责将请求分发,所有的请求都有经过它来统一分发。

  大致看下SpringMVC请求处理的流程:

  用户向服务器发送请求,请求会到DispatcherServlet,DispatcherServlet 对请求URL进行解析,得到请求资源标识符(URI),然后根据该URI,调用HandlerMapping获得该Handler配置的所有相关的对象(包括一个Handler处理器对象、多个HandlerInterceptor拦截器对象),最后以HandlerExecutionChain对象的形式返回。
  DispatcherServlet 根据获得的Handler,选择一个合适的HandlerAdapter。提取Request中的模型数据,填充Handler入参,开始执行Handler(Controller)。 在填充Handler的入参过程中,根据你的配置,Spring将帮你做一些额外的工作:

  • HttpMessageConveter: 将请求消息(如Json、xml等数据)转换成一个对象,将对象转换为指定的响应信息
  • 数据转换:对请求消息进行数据转换。如String转换成Integer、Double等
  • 数据格式化:对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
  • 数据验证: 验证数据的有效性(长度、格式等),验证结果存储到BindingResult或Error中

  Handler执行完成后,向DispatcherServlet 返回一个ModelAndView对象;根据返回的ModelAndView,选择一个适合的ViewResolver返回给DispatcherServlet;ViewResolver 结合Model和View,来渲染视图,最后将渲染结果返回给客户端。



  DispatcherSevlet中最重要的是doService方法:

    //获取请求,设置一些request的参数,然后分发给doDispatch
	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isDebugEnabled()) {
			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
					" processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
		}
 
		// Keep a snapshot of the request attributes in case of an include,
		// to be able to restore the original attributes after the include.
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<String, Object>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}
 
		// Make framework objects available to handlers and view objects.
		/* 设置web应用上下文**/
		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());
		//请求刷新时保存属性
		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		//Flash attributes 在对请求的重定向生效之前被临时存储(通常是在session)中,并且在重定向之后被立即移除
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
		//FlashMap 被用来管理 flash attributes 而 FlashMapManager 则被用来存储,获取和管理 FlashMap 实体.
		request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
 
		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);
				}
			}
		}
	}

  doService方法对Request设置了一些全局属性,最终接下来的操作是在doDispatcher:

     /**
	 *将Handler进行分发,handler会被handlerMapping有序的获得
	 *通过查询servlet安装的HandlerAdapters来获得HandlerAdapters来查找第一个支持handler的类
	 *所有的HTTP的方法都会被这个方法掌控。取决于HandlerAdapters 或者handlers 他们自己去决定哪些方法是可用
	 *@param request current HTTP request
	 *@param response current HTTP response
	 */
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		/* 当前HTTP请求**/
		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);
 
				// getHandler中遍历HandlerMapping,获取对应的HandlerExecutionChain
                // HandlerExecutionChain,包含HandlerIntercrptor和HandlerMethod
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
 
				
				//获得HandlerAdapter
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
 
				//获得HTTP请求方法
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (logger.isDebugEnabled()) {
						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				//如果有拦截器的话,会执行拦截器的preHandler方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
 
				//返回ModelAndView
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
				//当view为空时,,根据request设置默认view
				applyDefaultViewName(processedRequest, mv);
				//执行拦截器的postHandle
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Error err) {
			triggerAfterCompletionWithError(processedRequest, response, mappedHandler, 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);
				}
			}
		}
	}

  

HandlerInterceptor拦截器

  在doDispatcher方法中:

mappedHandler = getHandler(processedRequest);
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   for (HandlerMapping hm : this.handlerMappings) {
      if (logger.isTraceEnabled()) {
         logger.trace(
               "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
      }
      HandlerExecutionChain handler = hm.getHandler(request);
      if (handler != null) {
         return handler;
      }
   }
   return null;
}

  遍历HandlerMapping,获取对应的HandlerExecutionChain,HandlerExecutionChain中有3个变量:

private final Object handler; // HandlerMethod
private HandlerInterceptor[] interceptors; //所有的HandlerInterceptor的数组
private List<HandlerInterceptor> interceptorList; //所有的HandlerInterceptor的链表

  在执行Controller的方法调用之前先执行:

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

  HandlerExecutionChain#applyPreHandle即调用HandlerInterceptor# preHandler方法。在Controller的方法调用之后:

mappedHandler.applyPostHandle(processedRequest, response, mv);

  HandlerExecutionChain#applyPostHandle即调用HandlerInterceptor# postHandle方法。最后

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

  方法会调用:

mappedHandler.triggerAfterCompletion(request, response, null);

  调用HandlerInterceptor#afterCompletion方法。
  详细用法参考 https://blog.csdn.net/zero__007/article/details/80028720

  

HandlerExceptionResolver异常处理

  在doDispatcher方法中会catch住Controller方法调用的异常,之后再处理:

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {

   boolean errorView = false;

   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);
      }
   }
   // …
}

  如果有exception,调用processHandlerException:

protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
      Object handler, Exception ex) throws Exception {

   // Check registered HandlerExceptionResolvers...
   ModelAndView exMv = null;
   for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
      exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
      if (exMv != null) {
         break;
      }
   }
   if (exMv != null) {
      if (exMv.isEmpty()) {
         request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
         return null;
      }
      // We might still need view name translation for a plain error model...
      if (!exMv.hasView()) {
         exMv.setViewName(getDefaultViewName(request));
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Handler execution resulted in exception - forwarding to resolved error view: " + exMv, ex);
      }
      WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
      return exMv;
   }

   throw ex;
}

  SpringMVC启动加载时会将所有的异常处理HandlerExceptionResolver实现类存放到handlerExceptionResolvers中,当默认执行时,只要返回的exMv不为空就中止执行其他的异常处理实现类。
  可以实现多个HandlerExceptionResolver的异常处理类,执行顺序由其order属性决定, order值越小,越是优先执行, 在执行到第一个返回不是null的ModelAndView的Resolver时,不再执行后续的尚未执行的Resolver的异常处理方法。

  

HandlerMethodArgumentResolver参数解析器

  HandlerMethodArgumentResolver是用来为处理器解析参数的,主要用在HandlerMethod中,每个Resolver对应一种类型的参数,其实现类特别的多。HandlerMethodArgumentResolver的接口定义如下:

  • supportsParameter 用于判断是否支持对某种参数的解析
  • resolveArgument 将请求中的参数值解析为某种对象

  参数的处理是在InvocableHandlerMethod类中,当执行具体的请求处理时执行invokeForRequest:

public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer,
      Object... providedArgs) throws Exception {
   //获取执行Controller的函数的参数对象
   Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
   if (logger.isTraceEnabled()) {
      logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
            "' with arguments " + Arrays.toString(args));
   }
   Object returnValue = doInvoke(args);
   if (logger.isTraceEnabled()) {
      logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
            "] returned [" + returnValue + "]");
   }
   return returnValue;
}

  具体的参数解析器的选择和使用参数解析器去解析参数的实现都在getMethodArgumentValues中。SpringMVC在启动时会将所有的参数解析器放到HandlerMethodArgumentResolverComposite,然后从HandlerMethodArgumentResolverComposite参数解析器集合中选择一个支持对parameter解析的参数解析器,之后就使用支持参数解析的解析器进行参数解析。

private Object[] getMethodArgumentValues(NativeWebRequest request, ModelAndViewContainer mavContainer,
			Object... providedArgs) throws Exception {
		//获取执行的具体函数的参数
		MethodParameter[] parameters = getMethodParameters();
		Object[] args = new Object[parameters.length];
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());
			//获取参数值对象
			args[i] = resolveProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
			//首先判断是否有参数解析器支持参数parameter,采用职责链的设计模式
			if (this.argumentResolvers.supportsParameter(parameter)) {
				try {
					//如果参数解析器支持解析参数parameter,那么解析参数成Controller的函数需要的格式
					args[i] = this.argumentResolvers.resolveArgument(
							parameter, mavContainer, request, this.dataBinderFactory);
					continue;
				}
				catch (Exception ex) {
					if (logger.isDebugEnabled()) {
						logger.debug(getArgumentResolutionErrorMessage("Error resolving argument", i), ex);
					}
					throw ex;
				}
			}
			if (args[i] == null) {
				String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);
				throw new IllegalStateException(msg);
			}
		}
		//返回参数值
		return args;
	}

  以上代码会将URL链接提交的参数值转换为对象值。

  

HandlerMethodReturnValueHandler返回值解析器

  HandlerMethodReturnValueHandler是用于对Controller中函数执行的返回值进行处理操作的。接口HandlerMethodReturnValueHandler定义的抽象方法如下:

  • supportsReturnType用于判断是否支持对返回值的处理。
  • handleReturnValue实现对返回值的处理操作。

  执行过程是在ServletInvocableHandlerMethod的invokeAndHandle中:

public void invokeAndHandle(ServletWebRequest webRequest,
			ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
		// 获取返回值
		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		.......
		//对返回值进行处理操作
		this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		.........
	}

  具体实现是在HandlerMethodReturnValueHandlerComposite中,HandlerMethodReturnValueHandlerComposite中包含了所有springMVC提供的返回值处理器。

public void handleReturnValue(Object returnValue, MethodParameter returnType,
      ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
   //选择可以处理返回值的处理器
   HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
   if (handler == null) {
      throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
   }
    //处理返回值
   handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
private HandlerMethodReturnValueHandler selectHandler(Object value, MethodParameter returnType) {
   boolean isAsyncValue = isAsyncReturnValue(value, returnType);
   for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) {
      if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) {
         continue;
      }
      if (handler.supportsReturnType(returnType)) {
         return handler;
      }
   }
   return null;
}
SpringMVC源码之解读DispatcherServlet初始化流程 SpringMVC的配置流程并不复杂,但每个步骤所涉及的东西比较多,一不小心配错可就糟糕了。但这参与感十足的配置方式除了它的灵活性外,也能让我们更加清楚框架在为我们服务之前,到底做了哪些事情,接下来我们就到源码中去看看SpringMVC的核心入口类DispatcherServlet在Web容器启动后做了哪些准备。 阅读详情

相关推荐

Cadence IC 618实战:从与非门到环形振荡器的完整版图设计流程(含DRC/LVS避坑点)

本文详细介绍了使用Cadence IC 618进行从与非门到环形振荡器的完整版图设计流程,包括环境准备、基础设计规范、层次化设计、DRC/LVS验证及后仿真优化。特别提供了实战中的避坑技巧和优化建议,帮助工程师高效完成集成电路设计任务。

weixin_26886855的博客 407

DispatcherServlet详解

一、DispatcherServlet作用DispatcherServlet是前端控制器设计模式的实现,提供Spring Web MVC的集中访问点,而且负责职责的分派,而且与Spring IoC容器无缝集成,从而可以获得Spring的所有好处。 DispatcherServlet主要用作职责调度工作,本身主要用于控制流程,主要职责如下: 文件上传解析,如果请求类型是multipart将通过Mu

bear_wr的专栏 1万+

【吐血整理-历时两个月,长达万字】FDTD Solutions学习笔记

原教学视频来自于Ansys-Lumerical官方的FDTD100,所看视频来自B站大佬UP主 【Nestor_呐等】 的幸苦翻译,本文内容粘贴自我个人在学习FDTD100时,通过字幕和一些个人理解总结的一份word。整理不易,强烈建议收藏!...

weixin_45719141的博客 10万+

SpringMVC中DispatcherServlet详解

DispatcherServlet是Spring MVC框架的核心组件之一,它负责请求的接收、处理和响应。DispatcherServlet在整个请求处理过程中扮演着调度者的角色,将请求分发到相应的处理器进行处理,并将处理结果返回给客户端

技术人集结地 5282

硬件学习笔记(器件篇)—— 磁珠与磁环

因为有这些差别,所有经常会让人们觉得他们并不是一类器件,但实际上他们的原理是一样的。我们使用磁珠是为了利用损耗消耗高频能量,所以如果我们理解了磁珠是如何消耗高频能量的,我们就能理解磁珠的工作原理。

y_u_yu_yu_的博客 1万+

Disk Drill 使用教程

Disk Drill只需单击几下,即可恢复USB闪存驱动器上已删除的数据,包括丢失的照片,文档和其他文件类型。Disk Drill是真正的多合一应用程序,可在Mac上恢复闪存驱动器。Disk Drill将自动应用最佳的笔式驱动器恢复算法来恢复Mac数据。 USB闪存驱动器是一种传输和存储信息的好方法,但是如果错误地丢失或删除了存储在其中的文件,会发生什么呢?当您需要Mac的闪存驱动器数据恢复软件时,Disk Drill是您的最佳选择。Disk Drill将扫描您的USB闪存驱动器(也称为笔式驱动器)并查找

zjj778899的博客 1万+

springmvc源码之DispatcherServlet前端控制器

国际化处理AcceptHeaderLocaleResolver 基于URL参数的配置,可以读取url中locale=zh_CN来控制国际化参数CookieLocaleResolver 基于cookie的配置,可以通过浏览器的cookie设置获取Locale对象SessionLocaleResolver 基于session的配置,可以公国检验session的预置的属性来解析,如果没有则会根据请求头中的accept-language来确定主题处理,根据主题控制网页风格。

Lxn2zh的博客 1062

不用写代码!3个免费在线工具教你完成Lasso回归分析(含生存资料处理)

本文介绍3款免费在线工具,帮助用户无需编程即可完成临床数据的Lasso回归分析,特别适合处理生存资料。通过详细的操作指南和实战技巧,读者可以轻松掌握变量筛选、模型优化及结果解读,提升临床研究的效率和准确性。

weixin_33738555的博客 349

spring mvc DispatcherServlet解读

spring mvc DispatcherServlet解读 DispatcherServlet的继承和实现 IDEA按快捷键:ctrl+alt+u,就可以查看DispatcherServlet的继承的类和实现的接口。 从继承图可以得知: DispatcherServlet本质是一个HttpServlet HttpServletBean,FrameworkServlet,DispatcherServlet是属于SpringMVC的类 DispatcherServlet初始化 DispatcherSer

qq_43203949的博客 702

magic-api的鉴权机制配置 (附实战代码)

引入magic-api及相关数据库驱动依赖 配置yml文件和编辑器JS文件 实现登录鉴权逻辑,包括用户验证和Token处理 接口鉴权拦截器设计,确保接口访问安全性 文章提供了完整的代码示例,帮助开发者快速集成magic-api框架并实现权限控制功能。

码农研究僧的博客 228

【C++】【STL算法】数据窄化及代码安全性

本文系统探讨了C++工程中数据窄化(narrowing conversion)的隐患与解决方案。数据窄化指将高精度/大范围类型转换为低精度/小范围类型,虽语法合法但会导致静默精度损失。其危险性体现在:错误隐蔽、STL会放大问题、数值错误具有传播性。现代C++要求窄化必须显式声明,文中提出四种工程解决方案:显式转换、边界统一转换、范围检查转换和使用GSL工具。建议在系统边界集中处理窄化,保持计算链路类型一致性,并通过分层策略(建模用double,控制用float)确保数值稳定性。核心思想是让窄化成为清晰可控的

Double Galaxy 80

SpringMVC源码解读 --- DispatcherServlet的doDispatch方法

经过一系列的源码解读,现在终于到了这个SpringMVC对于请求的核心流转逻辑处理的方法doDispatch了。我们在讲DispatcherServlet这个类的实时,一直强调将其看为是一个普通的Servlet。这个DispatcherServlet类,我们前面有梳理其的init方法(DispatcherServlet类的一些初始化内容),然后为了梳理其的doDispatch方法,我们整个又梳理了处理器映射器(HandlerMapping)、处理器适配器(HandlerAdapter)、视图解...

Feverasa的博客 437

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

spring学习笔记之DispatcherServlet源码解读

DispatcherServlet--翻译spring-framework-reference.pdf及源码解读。 最近在看spring源码,同时也看着英文版的spring-framework-reference.pdf。顺便花点时间翻译下来,一方面记录下学习路程,另一方面加深印象。 spring web MVC 框架,就像其他web MVC框架一样,是请求驱动,围绕一个核心的...

xlsky0713的博客 285

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

Spring Boot DispatcherServlet 自动配置源码深度解读

位于包下,是 Spring Boot 对 Spring的自动配置实现。独立应用(Standalone Application):使用嵌入式 Web 服务器(如 Tomcat、Jetty、Undertow)的场景;可部署应用(Deployable Application):使用部署到外部容器的场景。// ...中定义了两个自定义条件类,它们共同决定了自动配置是否生效。通过源码分析,我们可以总结出。

m0_37607945的博客 259

SpringMVC原理:解读DispatcherServlet源码

SpringMVC原理:解读DispatcherServlet源码

Leon_Jinhai_Sun的博客 266

SpringMVC-解读DispatcherServlet源码

SpringMVC 学习完Spring框架技术之后,差不多会出现两批人: 一批是听得云里雾里,依然不明白这个东西是干嘛的; 还有一批就是差不多理解了核心思想,但是不知道这些东西该如何去发挥它的作用。 在SpringMVC阶段,你就能逐渐够体会到Spring框架为我们带来的便捷之处了。 此阶段,我们将再次回到Tomcat的Web应用程序开发中,去感受SpringMVC为我们带来的巨大便捷。 MVC理论基础 在之前,我们给大家讲解了三层架构,包括: 每一层都有着各自的职责,其中最关键的当属..

HongYu012的博客 737

深入解读springmvc--1,摸清DispatcherServlet

一,前言 很惭愧最近没更新博客,闲的慌废寝忘食地看了几本小说,还好一周时间就看吐了,上周空闲之余粗略看了下Spring MVC的源码,先把上周的一些思路整理一下,走一下springmvc的流程。 打算写一个springmvc系列的博客,从源码解读,到自己实现一个处理请求,生成视图和模型并且可以进行视图的解析的A货MVC框架。DispatcherServlet是整个SpringMvc框架的核心,...

rubbertree的专栏 256

Spring源码解读之DispatcherServlet处理请求流程

这里主要讲下java原生的servlet和Spring下DispatcherServlet对http请求的处理流程做一个梳理! 原生Servlet 我们先看下Servlet的实现关系图解 DispatcherServlet

ccccc202的博客 397

SpringMVC源码解读--DispatcherServlet类

DispatcherServelet继承自FrameworkServlet类,然后FrameworkServlet类继承自HttpServletBean类,HttpServletBean类继承了HttpServlet类。那么接收来的请求将会从GenericServelt进而传递给HttpServelt然后传递给HttpServeltBean来,然后接下来是FrameworkServlet类。初始化

王洋的专栏 1059

关于Spring中的DispatcherServlet和ContextLoaderListener的配置源码解读

 在我们的spring项目搭建的过程中通常会使用web.xml会经常看到如下的配置:  在web.xml中我们配置了一个ContextLoaderListener和一个DispatcherServlet,但是我们从来没有关心过为什么要在这里配置一个监听器和一个servlet,并且也没有考虑过如果不使用web.xml能不能实现这个功能。今天我们就来讲解一下这两个东西到底做了什么,再就是有没有其他的...

TankyZhang的博客 555

深入解读Spring Framework Web MVC(第二弹:DispatcherServlet详解)

DispatcherServlet简介Spring web MVC框架基于请求驱动,用一个核心Servlet转发请求到对应的Controller。然而Spring的DispatcherServlet并不仅仅拥有这些,因为Spring MVC框架集成了Spring IOC容器,因此,Spring MVC可以使用Spring 提供的其他功能。DispatcherServlet的声明DispatcherS

艺术就是爆炸的专栏 874

深入解读springmvc--2,处理Http请求以及自定义一个DispatcherServlet

一,一个Http请求进入SpringMVC的完整流程: 首先看下动态请求的处理:(静态资源请求的处理其实比较简单,只是以流的方式把静态资源写入response中而已) 在Servlet容器中,一个请求的完整流程是: 1.Servlet容器调用Servlet.service() 2.HttpServlet.service()分发get,post等 3.FrameworkServlet....

rubbertree的专栏 891
上一篇: Mysql索引
下一篇: 缓存更新
zero__007
博客等级 码龄12年 326粉丝 247原创
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值