Spring MVC Dispatcher说明
SpringMVC工作流程的说明
SpringMVC⼯作流程的说明 感谢你的到来，这是我第⼀篇尝试⽤故事性的⽅式来记录⾃⼰对编码中⼀些东西的理解。
本⽂只关注过程，不注重解析实现细节。
如果想了解具体的实现细节，请⾃⾏百度或追踪源码学习。
如果在记录中存在不合理的地⽅，请不吝指教。
嘻嘻 当作为⼈类的你在浏览器点击⼀个连接时就会激活⼀个HTTP请求，这个HTTP⼩伙计就开始了它为你寻找资源的旅程。
中间略掉繁琐的HTTP解析，直接来到我们的服务器，被SpringMVC中的门卫DispatcherServlet(核⼼控制器)拦截下来。
门卫：喂，⼩⼦！你要去哪⼉？⼩伙计吓了⼀哆嗦，颤抖着拿出来他的路条⼉(HttpServletRequest)交给了门卫。
门卫拿着路条去到⼀个⼩⿊屋⾥，只听叮叮当当⼀阵⼦后，满头⼤汗的出来⼜⾛进⼀间挂着HandlerMappings的房间，⾥⾯有差不多8个黄⾊的看起来满眼疲惫的⼩盆友。
看到门卫进去⽴马满眼敬畏的盯着他，门卫从第⼀个⼩⼈⼉开始，依次把⼿⾥的路条扔给他们进⾏对⽐，当⾛到头上挂着RequestMappingHandlerMapping的⼩⼈⼉时，他⽐对成功了。
接着门卫就从这个⼩⼈⼉的屁股⾥抠出⼀条说是叫做HandlerExecutionChain的链⼦，门卫看着⼿⾥链⼦莫名的笑了。
接着门卫从这个叫HandlerMappings的房间⾥出来，转⾝来到⼀间叫HandlerAdapters的屋⾥。
这个屋⼦很⼩灯光昏暗，⼩伙计隐隐能看见⾥⾯有三个⼩⼈⼉被锁在三个笼⼦⾥。
只见门卫从⼿⾥的链⼦上扣下⼀个像⼿⼀样的东西，狠狠地把它扔个第⼀个⼩⼈⼉，恶恶地说：“这个Handler你能不能处理？”第⼀个⼩⼈看了看摇摇头，门卫⼀把拿回来扔给第⼆个叫做RequestMappingHandlerAdapter的⼩⼈⼉。
这个⼩⼈⼉⼀看，喜颜悦⾊的说：“我可以搞”。
“嗯，那你跟我出来吧！”门卫没好⽓地说。
门卫把RequestMappingHandlerAdapter从⼩⿊屋带到门卫室，关好门。
springmvc的执行流程
springmvc的执行流程SpringMVC的执行流程。
SpringMVC是一种基于Java的Web框架，它提供了一种简单、灵活的方式来开发Web应用程序。
在使用SpringMVC开发Web应用程序时，了解其执行流程是非常重要的。
本文将详细介绍SpringMVC的执行流程，帮助读者更好地理解和应用这一框架。
1. 客户端发送请求。
SpringMVC的执行流程始于客户端发送请求。
客户端可以是浏览器、移动应用或其他Web应用程序。
当客户端发送请求时，请求首先被发送到DispatcherServlet。
2. DispatcherServlet接收请求。
DispatcherServlet是SpringMVC的核心控制器，它接收所有的客户端请求。
一旦DispatcherServlet接收到请求，它将根据请求的URL来确定要调用的Controller。
3. HandlerMapping确定处理器。
HandlerMapping是用来确定请求URL对应的处理器的组件。
它会根据请求的URL来查找合适的处理器，然后将请求分发给该处理器进行处理。
4. Controller处理请求。
一旦HandlerMapping确定了处理器，请求就会被分发给对应的Controller。
Controller是SpringMVC框架中用来处理请求的组件，它会根据请求的类型和参数来执行相应的业务逻辑。
5. ModelAndView处理数据。
在Controller中处理完请求后，通常会返回一个ModelAndView对象。
这个对象包含了处理结果的数据以及展示这些数据的视图名称。
ModelAndView会被传递给DispatcherServlet。
6. ViewResolver解析视图。
ViewResolver是SpringMVC中用来解析视图名称的组件。
它会根据Controller返回的视图名称来查找对应的视图，然后将数据填充到视图中。
7. 视图渲染。
SpringMVC之DispatcherServlet初始化详解
SpringMVC之DispatcherServlet初始化详解Spring作为一个优秀的web框架，其运行是基于Tomcat的。
在我们前面的讲解中，Spring的驱动都是使用的ClassPathXmlApplicationContext，并且都是直接在main方法中启动的，但是在Tomcat容器中，我们是无法Servlet规范的支持，其DispatcherServlet则是Servlet规范的具体实现。
因而在web开发过程中，当我们启动Tomcat容器时其会根据Servlet规范启动Spring实现的DispatcherServlet，这样也就驱动了Spring的运行。
1. web.xml配置在配置web容器时，我们都会配置一个web.xml，而在配置web.xml时，最主要的两个组件就是ContextLoaderListener和DispatcherServlet的配置。
如下是一个典型的web.xml文件的配置：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><servlet><servlet-name>myservlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>myservlet</servlet-name><url-pattern>/</url-pattern></servlet-mapping>这里ContextLoaderListener的作用是对对Servlet Context的行为进行监听，其实现了ServletContextListener接口，这个接口声明如下：public interface ServletContextListener extends EventListener {// 用于在Servlet Context初始化事前执行default public void contextInitialized(ServletContextEvent sce) {}// 用于在Servlet Context被销毁之后执行default public void contextDestroyed(ServletContextEvent sce) {}}这里ServletContextListener是Servlet规范中提供的一个接口，该接口中的contextInitialized()会在servlet context初始化之前执行，而contextDestroyed()方法则会在servlet context被销毁之后执行。
SpringMVC框架详解
SpringMVC框架详解随着Web应用程序变得越来越复杂，使用适当的框架变得越来越重要。
SpringMVC是一个流行的Java Web框架，它提供了许多功能，使开发Web应用程序更容易和更快速。
本文将对SpringMVC框架进行详细介绍，包括其架构、工作流程、控制器、视图和模型等方面的内容。
1. SpringMVC架构SpringMVC框架基于Model-View-Controller（MVC）架构。
在这种架构中，应用程序被分为三个组件，分别是：1. Model：负责管理数据的处理和存储。
2. View：负责呈现数据给用户的界面。
3. Controller：负责接收用户的请求和处理数据，控制应用程序的行为。
SpringMVC通过DispatcherServlet实现了这种MVC架构。
DispatcherServlet是一个前端控制器（Front Controller），它接收所有的客户端请求并将其分配给相应的处理程序。
2. SpringMVC的工作流程SpringMVC框架具有以下的工作流程：1. 用户发送请求到DispatcherServlet。
2. DispatcherServlet收到请求后，根据配置文件中的URL映射找到相应的Controller。
3. Controller接收请求，并将数据传递给Service层。
4. Service层对数据进行处理，并将处理结果返回给Controller。
5. Controller根据视图解析器的配置选择相应的视图，将处理结果传递给视图并渲染。
6. 视图呈现处理结果，并将其返回给客户端。
3. SpringMVC的控制器控制器是SpringMVC架构中最重要的组件之一。
它负责接收客户端请求，并根据请求的类型执行相应的逻辑。
SpringMVC提供了以下几种类型的控制器：1. @Controller：该注解标注的类被SpringMVC视为控制器。
2. @RestController：可以理解为@Controller和@ResponseBody的组合注解。
springmvc工作流程
springmvc工作流程SpringMVC工作流程。
SpringMVC是一个轻量级的MVC框架，它是基于Spring框架的一个模块，采用了经典的MVC架构模式，它的设计是高度灵活的，而且具有很强的可扩展性。
SpringMVC的工作流程主要包括请求的分发、处理器映射、执行处理器、视图解析和视图渲染等步骤。
首先，当客户端发送请求到服务器时，SpringMVC的DispatcherServlet（前端控制器）将会拦截到所有的请求。
DispatcherServlet是整个SpringMVC的核心，它负责将请求分发给不同的处理器进行处理。
在web.xml文件中配置DispatcherServlet，指定它拦截的url-pattern。
接下来，DispatcherServlet会根据请求的URL，通过HandlerMapping（处理器映射器）找到合适的处理器（Controller）来处理请求。
HandlerMapping会根据请求的URL映射到对应的处理器，这个映射关系通常是通过配置文件或注解来完成的。
一旦找到了合适的处理器，DispatcherServlet就会将请求交给处理器进行处理。
处理器会根据请求的内容进行相应的处理，处理完毕后会返回一个ModelAndView对象，其中包括处理结果的数据和视图的逻辑名称。
接着，DispatcherServlet会通过ViewResolver（视图解析器）来解析ModelAndView中的视图逻辑名称，找到具体的视图对象。
视图解析器会根据逻辑名称找到对应的视图，视图可以是JSP、HTML、JSON等不同的类型。
最后，DispatcherServlet将ModelAndView中的数据传递给视图对象，视图对象将数据渲染到客户端，返回给客户端展示。
这样，整个请求的处理流程就完成了。
总的来说，SpringMVC的工作流程可以概括为，请求分发、处理器映射、执行处理器、视图解析和视图渲染。
SpringMVC源码解析-DispatcherServlet启动流程和初始化
SpringMVC源码解析-DispatcherServlet启动流程和初始化在使⽤springmvc框架，会在web.xml⽂件配置⼀个DispatcherServlet,这正是web容器开始初始化，同时会在建⽴⾃⼰的上下⽂来持有SpringMVC的bean对象。
先从DispatcherServlet⼊⼿，从名字来看，它是⼀个Servlet。
它的定义如下：public class DispatcherServlet extends FrameworkServlet {它是继承FrameworkServlet,来看⼀下整个的继承关系。
从继承关系来看，DispatcherServlet继承FrameworkServlet和HttpServletBean⽽继承HttpServlet,通过使⽤Servlet API 来对HTTP请求进⾏响应，成为SpringMVC的前端处理器。
先看⼀个时序图注：作为Servlet,DispatcherServlet的启动和Servlet的启动相关联的。
在Servlet初始化过程中，Servlet的init⽅法会被调⽤，以进⾏初始化，然⽽DispatcherServlet的基类，所以从HttpServletBean中的初始化过程开始。
DispatcherServlet的⼯作分为2部分，⼀部分是初始化（也就是图的上半部分），有initServletBean()启动，通过initWebApplicationContext()⽅法最终调⽤DispatcherServlet中的initStrategies()⽅法。
另⼀部分(也就是图的下半部分),是对HTTP请求进⾏响应，作为Servlet，Web容器会调⽤Servlet的doGet()和doPost()⽅法,在经过FrameworkServlet的processRequest()简单处理后，会调⽤DispatcherServlet的doService⽅法，在这个⽅法调⽤中封装了doDispatch(),继续调⽤processDispatchResult⽅法返回调⽤信息。
springmvc流程
springmvc流程SpringMVC流程。
SpringMVC是一种基于Java的Web框架，它使用了MVC （Model-View-Controller）的设计模式，能够帮助开发者快速、高效地构建Web应用程序。
在本文中，我们将详细介绍SpringMVC的流程，包括请求的处理、视图的渲染以及数据的传递等方面。
1. DispatcherServlet的初始化。
SpringMVC的核心是DispatcherServlet，它是一个Servlet，负责接收所有的HTTP请求并将它们分发给相应的处理器。
当Web应用程序启动时，容器会加载DispatcherServlet，并且根据配置文件对其进行初始化。
在初始化过程中，DispatcherServlet会读取配置文件，包括Web应用程序的上下文配置、处理器映射、视图解析器等，并进行相应的初始化工作。
2. 请求的处理。
当客户端发送一个HTTP请求时，DispatcherServlet会根据请求的URL找到相应的处理器，并将请求委托给它。
处理器会根据请求的内容进行相应的处理，包括调用业务逻辑、处理数据等。
处理器可以是一个Controller类，也可以是一个实现了Handler接口的类，它们负责处理请求并生成相应的结果。
3. 视图的渲染。
一旦处理器处理完请求并生成了结果，DispatcherServlet会将结果传递给视图解析器，并且根据配置找到相应的视图。
视图解析器会将结果渲染成HTML、JSON或其他格式，并将其返回给客户端。
视图可以是JSP、Thymeleaf、Freemarker等，它们负责将处理器生成的结果展示给用户。
4. 数据的传递。
在整个流程中，数据的传递是非常重要的。
SpringMVC提供了多种方式来传递数据，包括请求参数、Session、ModelAndView等。
处理器可以通过这些方式来获取客户端发送的数据，并且将处理结果传递给视图。
视图也可以通过这些方式来获取数据，并且将其展示给用户。
springmvc的工作流程
springmvc的工作流程SpringMVC是一个基于Java的Web框架，它是Spring框架的一部分，用于简化Web应用程序的开发。
SpringMVC的工作流程主要包括请求的分发和处理，视图的渲染等步骤。
下面将详细介绍SpringMVC的工作流程。
首先，当用户发送一个请求时，请求将被DispatcherServlet接收。
DispatcherServlet是SpringMVC的核心，它充当前端控制器的角色，负责接收所有的请求并将其分发到相应的处理器上。
DispatcherServlet是通过Servlet的映射来配置的，当请求到达时，DispatcherServlet将根据配置的映射找到对应的处理器。
接下来，DispatcherServlet将请求发送给处理器映射器（HandlerMapping）。
处理器映射器根据请求的URL和其他条件来确定应该由哪个处理器来处理请求。
处理器映射器将返回一个处理器执行链（HandlerExecutionChain），其中包含了处理器以及拦截器（HandlerInterceptor）。
然后，DispatcherServlet将请求发送给处理器适配器（HandlerAdapter）。
处理器适配器负责执行处理器，并将请求的处理结果封装成一个ModelAndView对象返回给DispatcherServlet。
接着，DispatcherServlet将ModelAndView对象发送给视图解析器（ViewResolver）。
视图解析器根据ModelAndView中的视图名称解析出具体的视图对象。
视图解析器将返回一个视图对象，DispatcherServlet将使用该视图对象来渲染视图。
最后，DispatcherServlet将渲染好的视图返回给用户。
用户将看到处理结果，整个请求-处理-响应的流程就完成了。
总的来说，SpringMVC的工作流程可以概括为，请求到达DispatcherServlet -> DispatcherServlet发送请求给处理器映射器 -> 处理器映射器确定处理器 -> DispatcherServlet发送请求给处理器适配器 -> 处理器适配器执行处理器并返回ModelAndView -> DispatcherServlet发送ModelAndView给视图解析器 -> 视图解析器解析视图并返回视图对象 -> DispatcherServlet渲染视图并返回给用户。
简述springmvc的原理
简述springmvc的原理Spring MVC是一个基于MVC(Model-View-Controller)设计模式的轻量级Web框架，它是Spring框架的一部分。
Spring MVC的核心原理是通过DispatcherServlet来处理请求，它充当了前端控制器的角色，将请求转发给合适的处理器(Controller)进行处理，并将处理结果发送给相应的视图(View)进行展示。
S p r i n g M V C的工作流程可以分为以下几个步骤：1.请求到达Di s p a t c h e r S e r v l e t：当一个请求进入应用的时候，D i s p a t c h e r S e r v l e t是第一个接收到请求的对象。
它充当了应用的前门，负责分发请求。
2.D i s p a t c h e r S e r v l e t根据U R L映射找到对应的H a n d l e r M a p p i n g：在请求进入Di s p a t c h e r S e r v l e t之后，它会根据配置的UR L映射找到对应的H a n d l e r M a p p i n g。
H a n d l e r M a p p i n g是一个接口，不同的实现类可以有不同的映射策略，比如基于注解的@C o n t r o l l e r注解方式、基于配置文件的H a n d l e r M a p p i n g方式等。
3.D i s p a t c h e r S e r v l e t将请求转发给合适的H a n d l e r(C o n t r o l l e r)：一旦找到了映射到的H a n d l e r(C o n t r o l l e r)，D i s p a t c h e r S e r v l e t将请求转发给这个Ha n d l e r 进行处理。
H a n d l e r是一个处理请求的组件，通常是一个带有@C o n t r o l l e r注解的J a v a类。
springmvc的DispatcherServlet源码——doDispatch方法解析
springmvc的DispatcherServlet源码——doDispatch⽅法解析DispatcherServlet的doDispatch⽅法主要⽤作职责调度⼯作，本⾝主要⽤于控制流程，主要职责如下：1、⽂件上传解析，如果请求类型是multipart将通过MultipartResolver进⾏⽂件上传解析；2、通过HandlerMapping，将请求映射到处理器（返回⼀个HandlerExecutionChain，它包括⼀个处理器、多个HandlerInterceptor拦截器）；3、通过HandlerAdapter⽀持多种类型的处理器(HandlerExecutionChain中的处理器)；4、调⽤HandlerExecutionChain的interceptor和handler5、解析视图、处理异常，渲染具体的视图等； 1. 1：doDispatch⽅法中：如下：/*** Process the actual dispatching to the handler. //处理实际调度处理器* <p>The handler will be obtained by applying the servlet's HandlerMappings in order. //处理程序将通过按顺序的servlet的处理器映射器获得。
* The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters //处理器适配器将通过查询servlet的安装的处理器适配器来获得* to find the first that supports the handler class. //找到⽀持处理程序类的第⼀个。
* <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers //所有HTTP⽅法都由此⽅法处理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
DispatcherServlet说明使用Spring MVC,配置DispatcherServlet是第一步。
DispatcherServlet是一个Servlet,所以可以配置多个DispatcherServlet。
DispatcherServlet是前置控制器，配置在web.xml文件中的。
拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(我们写的Action)来处理。
“某某规则”：是根据你使用了哪个HandlerMapping接口的实现类的不同而不同。
先来看第一个例子：Xml代码1.<web-app>2.<servlet>3.<servlet-name>example</servlet-name>4.<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>5.<load-on-startup>1</load-on-startup>6.</servlet>7.<servlet-mapping>8.<servlet-name>example</servlet-name>9.<url-pattern>*.form</url-pattern>10.</servlet-mapping>11.</web-app><load-on-startup>1</load-on-startup>是启动顺序，让这个Servlet随Servletp容器一起启动。
<url-pattern>*.form</url-pattern> 会拦截*.form结尾的请求。
指明了配置文件的文件名，不使用默认配置文件名，而使用springMVC.xml配置文件。
其中<param-value>**.xml</param-value> 这里可以使用多种写法1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml2、<param-value>/WEB-INF/classes/springMVC.xml</param-value>3、<param-value>classpath*:springMVC-mvc.xml</param-value>4、多个值用逗号分隔Servlet拦截匹配规则可以自已定义，Servlet拦截哪种URL合适？当映射为@RequestMapping("/user/add")时：1、拦截*.do，例如：/user/add.do，弊端：所有的url都要以.do结尾。
不会影响访问静态文件。
2、拦截/app/*，例如：/app/user/add，弊端：请求的url都要包含/app，@RequestMapping("/user/add")中不须要包含/app。
3、拦截/，例如：/user/add，弊端：对jpg,js,css静态文件的访问也被拦截不能正常显示。
后面有解决办法。
4、拦截/*，可以走到Action中，但转发到jsp时再次被拦截，不能访问到jsp。
五、双亲上下文的说明如果你使用了listener监听器来加载配置，一般在Struts+Spring+Hibernate的项目中都是使用listener监听器的。
如下Java代码1.<listener>2. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>3.</listener>Spring会创建一个全局的WebApplicationContext上下文，称为根上下文，保存在ServletContext中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE属性的值。
可以使用工具类取出上下文：WebApplicationContextUtils.getWebApplicationContext(ServletContext);DispatcherServlet是一个Servlet,可以同时配置多个，每个DispatcherServlet有一个自己的WebApplicationContext上下文，这个上下文继承了根上下文中所有东西。
保存在ServletContext中，key是"org.springframework.web.servlet.FrameworkServlet.CONTEXT"+Servlet名称。
当一个Request对象产生时，会把这个WebApplicationContext上下文保存在Request对象中，key是DispatcherServlet.class.getName() + ".CONTEXT"。
可以使用工具类取出上下文：RequestContextUtils.getWebApplicationContext(request);Spring中的ApplicationContext实例可以被限制在不同的作用域（scope）中。
在web MVC框架中，每个DispatcherServlet有它自己的WebApplicationContext ，这个context继承了根WebApplicationContext 的所有bean定义。
这些继承的bean也可以在每个serlvet自己的所属的域中被覆盖（override），覆盖后的bean 可以被设置上只有这个servlet实例自己使用的属性。
总结：不使用listener监听器来加载spring的配置，改用DispatcherServlet来加载spring 的配置，不要双亲上下文，只使用一个DispatcherServlet，事情就简单了，什么麻烦事儿也没有了。
六、springMVC-mvc.xml 配置文件片段讲解（未使用默认配置文件名）Xml代码1.<!-- 自动扫描的包名 -->2.<context:component-scan base-package="com.app,com.core,JUnit4"></context:component-scan>3.4.<!-- 默认的注解映射的支持 -->5.<mvc:annotation-driven/>6.7.<!-- 视图解释类 -->8.<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">9.<property name="prefix"value="/WEB-INF/jsp/"/>10.<property name="suffix"value=".jsp"/><!--可为空,方便实现自已的依据扩展名来选择视图解释类的逻辑 -->11.<property name="viewClass"value="org.springframework.web.servlet.view.JstlView"/><context:component-scan/> 扫描指定的包中的类上的注解，常用的注解有：@Controller 声明Action组件@Service 声明Service组件@Service("myMovieLister")@Repository 声明Dao组件@Component 泛指组件, 当不好归类时.@RequestMapping("/menu") 请求映射@Resource 用于注入，( j2ee提供的) 默认按名称装配，@Resource(name="beanName")@Autowired 用于注入，(srping提供的) 默认按类型装配@Transactional( rollbackFor={Exception.class}) 事务管理@ResponseBody@Scope("prototype") 设定bean的作用域<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。
<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的。
并提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）。
后面，我们处理响应ajax请求时，就使用到了对json的支持。
后面，对action写JUnit单元测试时，要从spring IOC容器中取DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean，来完成测试，取的时候要知道是<mvc:annotation-driven />这一句注册的这两个bean。
<mvc:interceptors/> 是一种简写形式。
通过看前面的大图，知道，我们可以配置多个HandlerMapping。
<mvc:interceptors/>会为每一个HandlerMapping，注入一个拦截器。
其实我们也可以手动配置为每个HandlerMapping注入一个拦截器。
<mvc:default-servlet-handler/> 使用默认的Servlet来响应静态文件。