SpringMVC学习笔记（一）——SpringMVC框架原理

版权声明：转载请注明来源 https://blog.csdn.net/qq_24598601/article/details/84724744

一、SpringMVC概述

  SpringMVC 是 Spring 框架的一个模块，SpringMVC 和 Spring 无需通过中间整合层进行整合。SpringMVC 是一个基于 MVC 的轻量级 web 框架。
  Spring MVC 框架提供了 MVC (模型 - 视图 - 控制器)架构和用于开发灵活和松散耦合的 web 应用程序的组件。MVC 模式导致应用程序的不同方面(输入逻辑，业务逻辑和UI逻辑)分离，同时提供这些元素之间的松散耦合。

二、SpringMVC原理

  SpringMVC 框架原理图下图所示，序号代表顺序。

当用户发来一个 request 请求时，Spring MVC 将执行上图的流程顺序，具体是：
第一步：request 请求到达前端控制器（DispatcherServlet）；
第二步：前端控制器请求处理器映射器（HandlerMapping）来查找处理器（Handler）；可根据 xml 配置或注解进行查找；
第三步：处理器映射器返回一条执行链（HandlerExecutionChain）给前端控制器，执行链包括有拦截器（Interceptor）和处理器；
第四步：前端控制器调用处理器适配器（HandlerAdapter）去执行 Handler；
第五步：处理器适配器去执行 Handler；
第六步：Handler 执行完成给处理器适配器返回 ModelAndView（ModelAndView 是 SpringMVC 框架的一个底层对象，包括 Model 和 View）；
第七步：处理器适配器向前端控制器返回 ModelAndView；
第八步：前端控制器请求视图解析器（View Resolver）去进行视图解析，根据逻辑视图名解析成真正的视图（View）；
第九步：视图解析器向前端控制器返回 View；
第十步：前端控制器进行视图渲染，视图渲染是将模型数据（在ModelAndView对象中）填充到 request 域；
第十一步：返回给前端控制器；
第十二步：前端控制器向用户响应结果。

其中包括有一些组件：
1、前端控制器（DispatcherServlet）(不需要程序员开发)
作用：接收请求，响应结果，相当于转发器，中央处理器，通过 DispatcherServlet 能够减少其它组件之间的耦合度。

2、处理器映射器（HandlerMapping）(不需要程序员开发)
作用：根据请求的 URL查找 Handler。

3、处理器适配器（HandlerAdapter）(不需要程序员开发)
作用：按照 HandlerAdapter 要求的规则去执行 Handler。

4、处理器（Handler）(需要程序员开发)
编写 Handler 时要按照 HandlerAdapter 的规定去编写，这样适配器才可正确执行。

5、视图解析器（View Resolver）(不需要程序员开发)
作用：进行视图解析，根据逻辑视图名解析成真正的视图。

6、视图（View）(需要程序员开发)
View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）。

三、前端控制器（DispatcherServlet）

前端控制器核心源码：

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;

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest, false);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				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 (logger.isDebugEnabled()) {
						String requestUri = urlPathHelper.getRequestUri(request);
						logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
					}
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

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

				try {
					// Actually invoke the handler.
					mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
				}
				finally {
					if (asyncManager.isConcurrentHandlingStarted()) {
						return;
					}
				}

				applyDefaultViewName(request, mv);
				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
				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				return;
			}
			// Clean up any resources used by a multipart request.
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
	}

前端控制器配置：

<!-- 前端控制器 -->
 <servlet>
 	<servlet-name>SpringMVC</servlet-name>
 	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
 	<!-- contextConfigLocation配置springmc加载配置文件 -->
 	<!--
 		 如果不配置，默认加载的是/WEB-INF/servlet名称-servlet.xml文件，
 		 ，在这里就是 SpringMVC-servlet.xml文件
 	 -->
 	<init-param>
 		<param-name>contextConfigLocation</param-name>
 		<param-value>classpath:spring/springmvc.xml</param-value>
 	</init-param>
 </servlet>
 
 <servlet-mapping>
 	<servlet-name>SpringMVC</servlet-name>
 	<!-- 
 		第一种：*.action : 访问以 .action 结尾的由DispatcherServlet进行解析
 		第二种：/. : 所有访问的地址都由DispatcherServlet进行解析，所以对于静态资源就需要不让它解析
 		使用此方法可以实现RESTful风格额url
 		第三种：/* : 此方法不对。原因是使用此方法在最终转发到jsp页面时，仍会由DispatcherServlet解析jsp，
 		不能根据jsp 页面找到handle 而报错
 	 -->
 	<url-pattern>*.action</url-pattern>
 </servlet-mapping>

上述配置可在 web.xml 中配置多个，互不影响。

四、处理器映射器（HandlerMapping）

在同一个项目中，Spring MVC 允许多个处理器映射器同时存在并互不影响，常用的非注解处理器映射器有：BeanNameUrlHandlerMapping，SimpleUrlHandlerMapping，ControllerClassNameHandlerMapping，注解处理器映射器有：RequestMappingHandlerMapping

五、处理器适配器（HandlerAdapter）

在同一个项目中，Spring MVC 允许多个处理器适配器同时存在并互不影响，常用的非注解处理器适配器有：SimpleControllerHandlerAdapter，HttpRequestHandlerAdapter；注解处理器适配器：RequestMappingHandlerAdapter
注意：注解处理器映射器和注解处理器适配器必须配对使用！
如果使用注解开发只需要配置如下配置，就不需要再配置映射器和适配器。

<mvc:annotation-driven></mvc:annotation-driven>

六、视图解析器（View Resolver）

最常用的是InternalResourceViewResolver，视图解析器配置：

<!-- 视图解析器  -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<!-- 前缀 -->
	<property name="prefix" value="/WEB-INF/jsp/" />
	<!-- 后缀 -->
	<property name="suffix" value=".jsp" />
</bean>