Spring MVC 基础源码学习
2018-03-03 本文已影响23人
jwfy
spring MVC是严格遵守java servlet规范的一种web框架，可以打包成war包交由web容器（Tomcat或者jetty）运行。接下来就来学习下spring mvc的运行过程以及其中的细节，如何和Tomcat无缝合作，如何和spring 本身的核心功能IOC、AOP合作。
MVC 实例
接下来就搭建一个基于maven的spring mvc的实例。
项目结构
image.png
StudentController 类
@Controller
@RequestMapping
public class StudentController {
@RequestMapping(value = "/h")
@ResponseBody
public String getStudentInfo() {
return "hello world";
}
}
web.xml 文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/applicationContext.xml</param-value>
</context-param>
<servlet>
<servlet-name>demo</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>WEB-INF/applicationContext.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>demo</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
</web-app>
applicationContext.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package="com.demo.web" />
</beans>
pom.xml
// 插件部分
<build>
<finalName>demo</finalName>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<path>/</path>
<uriEncoding>${file_encoding}</uriEncoding>
<port>9912</port>
<server>tomcat7</server>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.5</version>
</plugin>
<!-- Java Compiler -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.3</version>
<configuration>
<source>${java_source_version}</source>
<target>${java_target_version}</target>
<encoding>${file_encoding}</encoding>
</configuration>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
</resources>
</build>
然后通过mvn tomcat7:run就可以正常启动了
Tomcat 基础
在介绍spring mvc的工作原理之前，有必要介绍下web容器的一种Tomcat。Tomcat是一个开源的web容器，严格准守servlet规范，在Tomcat中包含了各种各样的组件，层层嵌套依赖，如下图所示。
image.png
catalina是最核心的组件，也可以认为Tomcat是从它开始启动的，他持有1个server容器，server容器可以包含了多个service容器，每个service容器都持有了一个connector连接器以及一个engine，engine有层层包含了host、context、wrapper等。
其中engine、host、context、wrapper又分别存在各自的一个管道pipeline以及至少一个阀门valve，阀门可以为request和response添加任何外置的功能。
Tomcat启动是由各自容器的监听器调用启动的，按照上面所说的顺序依次执行启动的。
那我们常用的servlet是在哪里的么？他是被wrapper包装的，每一个wrapper持有一个servlet,所以在xml中配置了几个servlet，则就会存在多少个wrapper。并且servlet是通过ServletContext传递上下文的。在具体的URL映射的时候，会先根据各自的servlet的URL配置在Tomcat的mappingdata中体现，经过host、context、再到选择不同类型的wrapper(包含了wildcardWrappers、extensionWrappers、defaultWrapper、exactWrappers四种wrapper类型）最后才具体到某一个servlet请求上。
DispatcherServlet init 过程
DispatcherServlet类是spring mvc中实现的了servlet规范的实体类，实现了HttpServlet类，如下图
image.png
首先需要明确一点的是，DispatcherServlet也只是一个HttpServlet类，他是被wrapper调用的init(ServletConfig config)方法进入的，设置好config之后，进入到init()方法。
PS:在当前环境中，ServletConfig是StandardWrapperFacade类，可以从中获取到在xml配置的例如contextConfigLocation数据
HttpServletBean 类
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
}
// Set bean properties from init parameters.
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
// 获取xml配置的属性，在下面贴的图片中可以看到，当DispatcherServlet没有任何配置的时候，就会抛出异常，说缺少必备的配置属性
if (!pvs.isEmpty()) {
try {
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
// 这一步就是设置DispatcherServlet的属性值的操作
}
catch (BeansException ex) {
if (logger.isErrorEnabled()) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
}
throw ex;
}
}
// 开始真正的初始化DispatcherServlet类了
initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
}
}
image.png
FrameworkServlet 类
protected final void initServletBean() throws ServletException {
try {
this.webApplicationContext = initWebApplicationContext();
// 这个是初始化当前dispatchservlet的webApplicationContext参数
// 然后该参数中会持有spring的IOC容器等信息，通过这个参数可以获取bean数据
// 具体细节可看下面的代码
initFrameworkServlet();
// 未做任何事情，由子类实现，不过暂时为空
}
catch (ServletException ex) {
this.logger.error("Context initialization failed", ex);
throw ex;
}
catch (RuntimeException ex) {
this.logger.error("Context initialization failed", ex);
throw ex;
}
}
protected WebApplicationContext initWebApplicationContext() {
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
// 从当前的上下文中查找是否存在跟上下文信息（通过ContextLoaderListener加载的都会存在的）
WebApplicationContext wac = null;
if (this.webApplicationContext != null) {
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
cwac.setParent(rootContext);
}
// 重新再刷新一次WebApplicationContext持有的内容信息
configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
wac = findWebApplicationContext();
}
if (wac == null) {
// 创建一个新的WebApplicationContext信息，并设置好其parent
// 这里需要好好看看，同样的拆分为两部分执行
// 1、创建WebApplicationContext类，也就是XmlWebApplicationContext实体类，并设置好其环境、配置属性、父类等信息
// 2、调用configureAndRefreshWebApplicationContext，同样的设置好其关于servlet的上下文的属性信息，最后调用wac.refresh()
// PS: refresh()就开始了spring IOC的解析存储操作了
wac = createWebApplicationContext(rootContext);
// 不过这里有一步需要注意到，在refresh()中，最后会有onApplicationEvent()的操作，他会调用在DispatcherServlet类的initStrategies方法，完成URL映射、Template等操作
// 并且设置this.refreshEventReceived为true
}
if (!this.refreshEventReceived) {
// 完成了上面的刷新操作就不要再刷新了
// 这里的onRefresh还是会调用initStrategies方法
// 殊途同归罢了
onRefresh(wac);
}
if (this.publishContext) {
// 把当前的上下文信息也保存到ServletContext中
// 如果注意到的函数开头的rootContext的获取方法会发现也是通过这样的方式获取的
String attrName = getServletContextAttributeName();
getServletContext().setAttribute(attrName, wac);
}
return wac;
}
这样就完成了DispatcherServlet的初始化操作了，接下来就可以具体处理http请求了，当前这其中遗漏了很多重要的的点，例如
- rootContext 这是怎么一回事，是必须的么，和applicationContext.xml又有什么关系呢？
- xml配置的context-param和servlet的init-param有什么区别？
这几个点会在后续的学习笔记中再了解其原理，当前主要是介绍DispatcherServlet以及相关的东西。
DispatcherServlet URL映射以及请求处理 过程
Tomcat会通过的DispatcherServlet的servlet-mapping的属性匹配到合适的wrapper，再关联到具体的DispatcherServlet，也就意味着在web.xml确实可以配置多个servlet，只是在spring mvc中常用的就这一个而已。
HTTP请求，最后都会打到DispatcherServlet类的doService方法中，设置一些属性之后，又来到了doDispatch方法中,这个方法是核心也是最重要的http请求处理的方法，通过URL选择合适的controller，选择具体的modelandview，再渲染生成数据回调等等操作
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);
mappedHandler = getHandler(processedRequest);
// 通过URL找到合适的controller,并存储在HandlerExecutionChain对着中
// 还会检测是否进行cors跨域操作，如果存在跨域就会按照跨域的要求去处理
// @CrossOrigin(origins="http://test.com") 可以直接放在controller的注解上
if (mappedHandler == null || mappedHandler.getHandler() == null) {
// 没有找到合适的处理handle，就是404了
// 这就可以自定义配置404页面以及跳转等信息
// response.sendError(HttpServletResponse.SC_NOT_FOUND)
// 这里又可以引出一个问题了，如何配置404页面
noHandlerFound(processedRequest, response);
return;
}
// 检测当前获取的controller是否合适,并且得到合适的HandlerAdapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// 如果符合可以使用缓存机制，减少不必要的请求
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;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
// 使用spring本身的拦截器前置处理
return;
}
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
// 真正的处理请求，在本demo中会调到AnnotationMethodHandlerAdapter类中执行handle方法，返回的mv是ModelAndView
// 解析当前handler中包含了所有的方法，匹配其中合适的方法之后，invoke调用
// 不过这里需要注意到，类似于返回json的请求，是不需要模板渲染的，此时mv返回的是null，不过具体的json数据已经填入到了responseBody中
applyDefaultViewName(processedRequest, mv);
// 如果mv
mappedHandler.applyPostHandle(processedRequest, response, mv);
// spring 拦截器的后置处理
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
// 处理结果了，如果存在异常会把exception带上，例如500错误等，按照异常处理
// 如果存在了模板，需要经过render处理
// 否则就直接把得到的数据当做body返回
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);
}
}
}
}
到这里就完成了对一个普通的http请求的处理全过程，不过还是存在诸多问题没有去分析，如图
- cors跨域是什么，如何使用
- URL映射规则是如何完成的，以及和Tomcat的URL映射有什么关联么？
- 模板是如何被渲染的，在xml中如何设置不同的模板的？
还有个问题一直疏忽了，在spring mvc中存在大量的if(***.debug)这种操作，那么该如何配置使用日志系统呢？
接下来会再写笔记去分析上述提到的各种问题~
