SpringMVC核心源码解析——从前端请求到后端响应，全过程源码讲解

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量2.3k 收藏 18
点赞数 6
分类专栏： SpringMVC Servlet 文章标签： java springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41083377/article/details/115747606
版权

了解SpringMVC

如果你是从事JavaWeb工作的研发工程师，那么对于SpringMVC肯定不会陌生。SpringMVC框架在MVC的基础上进行了封装，很大程度上解放了后端工程师，使得前后端解耦。

使用SpringMVC

本文的目的是解析SpringMVC中的核心源码，为了方便之后的源码讲解，先来了解SpringMVC的基本使用。

项目目录：
在这里插入图片描述
pom.xml:

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
        <version>8.5.41</version>
    </dependency>
</dependencies>

web.xml（必须配置DispatcherServlet，并告诉它对应的配置文件位置，以及需要拦截的请求）:

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
    </servlet>

    <!-- /* 表示拦截所有，包括转发的Jsp页面，这是错误的，不能用-->
    <!--  / 表示拦截所有的请求，包括静态资源，不包括转发JSP -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

springmvc-servlet.xml:

<?xml version="1.0" encoding="UTF-8"?>
<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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- IOC注解解析器，扫描Controller类-->
    <context:component-scan base-package="controller"/>

    <!-- MVC注解解析器，启用注释-->
    <mvc:annotation-driven/>

    <!-- 处理静态资源文件请求 -->
    <mvc:default-servlet-handler/>
</beans>

Controller类：

@Controller
public class TestController {

    @RequestMapping("/index")
    public String index() {
        return "/WEB-INF/page/index.html";
    }
}

index.html：

<html>
<head>
    <title>SpringMVC</title>
</head>
<body>
<h1>index</h1>
</body>
</html>

到此，再配置tomcat服务器，将SpringMVC项目部署到tomcat中然后启动，访问对应的/index路径即可跳转访问到index.html页面。

SpringMVC的核心——DispatcherServlet

其实SpringMVC的底层并没有什么很高大上的实现，从配置文件中其实就可以看出，SpringMVC框架底层依赖的还是Servlet。因此如果想全面了解SpringMVC，需要有Servlet的源码基础。若有兴趣，在阅读本文之前可以先了解下我的另外一篇博客：Servlet源码解析。

有了Servlet的源码基础后，先来了解下SpringMVC的实现原理。其实SpringMVC的实现原理基于一个非常核心的Servlet——DispatchServlet。

首先了解下DispatchServlet的继承体系，如图：
在这里插入图片描述
由上图可知，DispatchServlet最终间接继承了HttpServlet这个父类，说明DispatchServlet主要也是处理http请求的一个Servlet，具体细节在后面的源码再细说。

为了能够更好的理清之后的源码讲解的思路，先来熟悉下DispatchServlet的工作流程，如图：
在这里插入图片描述
我们可以从图中看到，所有的流程都是围绕着DispatchServlet来展开。因此可以将DispatchServlet看作是请求的转发器，首先接收前端的request请求，然后根据请求路径通过HandlerMapping请求处理映射器找到对应的Handler请求处理器，再根据Handler通过HandlerAdapter请求处理适配器找到对应的适配器，并执行Handler。
最后将执行结果返回，并将其用ViewResolve视图解析器进行解析，如果解析成功，则响应视图。（在前后端主流工作模式中，通常是响应JSON数据）

SpringMVC源码讲解

了解完SpringMVC的整体执行流程后，开始对其中的流程细节进行源码讲解。
首先是核心DispatchServlet，再执行流程之前，DispatchServlet必须存在并完成初始化才能真正开始它的工作。
因此，首先需要知道DispatchServlet是如何创建并初始化：

在这里说下有关Servlet的相关流程：当一个request请求来到后端，那么就需要一个对应的Servlet来处理。这个Servlet就由相关的容器去创建并分配，而这个容器会在服务器启动时候根据配置文件的配置信息进行初始化。

因此得知，Servlet的初始化依赖于容器，而这个容器类的命名是StandarWrapper，每次请求到达后端都会首先调用allocate方法，分配对应的Servlet：
（以下的源码讲解以上面SpringMVC的使用例子为例进行讲解）

public Servlet allocate() throws ServletException {
    if (unloading) {
        throw new ServletException(sm.getString("standardWrapper.unloading", getName()));
    }
    
    boolean newInstance = false; // 标识对应的Servlet是否已创建，默认是未创建
    
    if (!singleThreadModel) { // 不是单例模式，则每次请求都返回同一个Servlet实例
        if (instance == null || !instanceInitialized) { // Servlet实例为空，或者未初始化
            synchronized (this) {
                if (instance == null) {
                    try {
                        if (log.isDebugEnabled()) {
                            log.debug("Allocating non-STM instance");
                        }
                        instance = loadServlet(); // 加载Servlet
                        newInstance = true; // 标示Servlet实例为已创建
                        if (!singleThreadModel) {
                            countAllocated.incrementAndGet();
                        }
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        ExceptionUtils.handleThrowable(e);
                        throw new ServletException(sm.getString("standardWrapper.allocate"), e);
                    }
                }
                if (!instanceInitialized) { // Servlet实例未初始化
                    initServlet(instance); // 对Servlet实例进行初始化
                }
            }
        }

        if (singleThreadModel) {
            if (newInstance) {
                synchronized (instancePool) {
                    instancePool.push(instance);
                    nInstances++;
                }
            }
        } else {
            if (log.isTraceEnabled()) {
                log.trace("  Returning non-STM instance");
            }
            if (!newInstance) {
                countAllocated.incrementAndGet();
            }
            return instance; // 返回已创建并初始化完成的Servlet实例
        }
    }
	... // 排除多余的干扰代码
}

loadServlet创建Servlet实例：

public synchronized Servlet loadServlet() throws ServletException {
    if (!singleThreadModel && (instance != null))
        return instance;
        
    PrintStream out = System.out;
    if (swallowOutput) {
        SystemLogHandler.startCapture();
    }

    Servlet servlet;
    try {
        long t1=System.currentTimeMillis();
        if (servletClass == null) {
            unavailable(null);
            throw new ServletException
                (sm.getString("standardWrapper.notClass", getName()));
        }

        InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager(); // 获取实例创建管理器
        try {
            servlet = (Servlet) instanceManager.newInstance(servletClass); // 根据Servlet全限定类名（在服务器启动读取配置信息的时候赋值）创建Servlet实例
        } catch (ClassCastException e) {
            unavailable(null);
            throw new ServletException(sm.getString("standardWrapper.notServlet", servletClass), e);
        } catch (Throwable e) {
            e = ExceptionUtils.unwrapInvocationTargetException(e);
            ExceptionUtils.handleThrowable(e);
            unavailable(null);
            if(log.isDebugEnabled()) {
                log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);
            }
            throw new ServletException(sm.getString("standardWrapper.instantiate", servletClass), e);
        }
		...
        initServlet(servlet); // 初始化Servlet实例对象

        fireContainerEvent("load", this);
        loadTime=System.currentTimeMillis() -t1;
    } finally {
        if (swallowOutput) {
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                if (getServletContext() != null) {
                    getServletContext().log(log);
                } else {
                    out.println(log);
                }
            }
        }
    }
    return servlet; // 返回加载完成的Servlet实例（其实就是DispatchServlet实例对象）
}

initServlet初始化Servlet实例：

private synchronized void initServlet(Servlet servlet) throws ServletException {
    if (instanceInitialized && !singleThreadModel) return;
    // 调用Servlet初始化方法
    try {
        if( Globals.IS_SECURITY_ENABLED) {
            boolean success = false;
            try {
                Object[] args = new Object[] { facade };
                SecurityUtil.doAsPrivilege("init", servlet, classType, args);
                success = true;
            } finally {
                if (!success) {
                    SecurityUtil.remove(servlet);
                }
            }
        } else {
            servlet.init(facade); // 实际上就是调用了Servlet实例的init方法进行初始化
        }
        instanceInitialized = true; // 标识Servlet实例已初始化
    } catch (UnavailableException f) {
        unavailable(f);
        throw f;
    } catch (ServletException f) {
        throw f;
    } catch (Throwable f) {
        ExceptionUtils.handleThrowable(f);
        getServletContext().log("StandardWrapper.Throwable", f );
        throw new ServletException(sm.getString("standardWrapper.initException", getName()), f);
    }
}

通过调试进入DispatchServlet实例的init方法后，发现调用的是HttpServletBean中的init方法：

public final void init() throws ServletException {
	// 首先为Servlet实例初始化相应的配置参数
	// 回想下web.xml中配置的参数（告诉Servlet实例配置文件的所在位置）：
	//   <init-param>
    //        <param-name>contextConfigLocation</param-name>
    //        <param-value>classpath:springmvc-servlet.xml</param-value>
    //   </init-param>
	PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
	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);
		}
		catch (BeansException ex) {
			if (logger.isErrorEnabled()) {
				logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
			}
			throw ex;
		}
	}
	initServletBean(); // 最后初始化Servlet实例
}

通过调试进入initServletBean方法，发现调用的是FrameworkServlet的initServletBean方法（主要是创建HandlerMapping映射处理器、HandlerAdapter处理适配器，以及初始化DispatchServlet）：

protected final void initServletBean() throws ServletException {
	getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
	if (logger.isInfoEnabled()) {
		logger.info("Initializing Servlet '" + getServletName() + "'");
	}
	long startTime = System.currentTimeMillis();
	try {
		this.webApplicationContext = initWebApplicationContext(); // 创建并初始化HandlerMapping映射处理器，以及HandlerAdapter处理适配器
		initFrameworkServlet(); // 初始化DispatchServlet实例
	} catch (ServletException | RuntimeException ex) {
		logger.error("Context initialization failed", ex);
		throw ex;
	}
	// 日志相关
	if (logger.isDebugEnabled()) {
		String value = this.enableLoggingRequestDetails ?
				"shown which may lead to unsafe logging of potentially sensitive data" :
				"masked to prevent unsafe logging of potentially sensitive data";
		logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
				"': request parameters and headers will be " + value);
	}

	if (logger.isInfoEnabled()) {
		logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
	}
}

可以看到initFrameworkServlet方法是空实现。原来DispatchServlet的初始化默认就到此结束了，这部分是留给继承它的的子类去实现扩展。

protected void initFrameworkServlet() throws ServletException {
}

1. 当DispatchServlet初始化完成后，下一步就是获取Handler请求处理器处理请求：

因为DispatchServlet处理的是http请求，因此在获取Handler请求处理器之前还需要经过HttpServlet的处理：

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
    HttpServletRequest  request;
    HttpServletResponse response;
    try {
    	// 转换为http类型的请求和响应
        request = (HttpServletRequest) req;
        response = (HttpServletResponse) res;
    } catch (ClassCastException e) {
        throw new ServletException("non-HTTP request or response");
    }
    service(request, response); // 处理请求
}

调用了FrameworkServlet的service方法：

protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	HttpMethod httpMethod = HttpMethod.resolve(request.getMethod()); // 获取请求访问类型（GET/POST等等）
	if (httpMethod == HttpMethod.PATCH || httpMethod == null) { // PATCH类型请求，或者为空
		processRequest(request, response);
	} else {
		super.service(request, response); // 正常来说，GET和POST类型的请求是最多的
	}
}

再调用HttpServlet的service请求，根据请求类型分别执行对应的方法：

protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String method = req.getMethod();
    if (method.equals(METHOD_GET)) {
        long lastModified = getLastModified(req);
        if (lastModified == -1) {
            doGet(req, resp); // 处理GET请求
        } else {
            long ifModifiedSince;
            try {
                ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
            } catch (IllegalArgumentException iae) {
                ifModifiedSince = -1;
            }
            if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                maybeSetLastModified(resp, lastModified);
                doGet(req, resp);
            } else {
                resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
            }
        }
    } else if (method.equals(METHOD_HEAD)) { // 处理HEAD请求
        long lastModified = getLastModified(req);
        maybeSetLastModified(resp, lastModified);
        doHead(req, resp);
    } else if (method.equals(METHOD_POST)) { // 处理HEAD请求
        doPost(req, resp);
    } else if (method.equals(METHOD_PUT)) { // 处理POST请求
        doPut(req, resp);
    } else if (method.equals(METHOD_DELETE)) { // 处理DELETE请求
        doDelete(req, resp);
    } else if (method.equals(METHOD_OPTIONS)) { // 处理OPTIONS请求
        doOptions(req,resp);
    } else if (method.equals(METHOD_TRACE)) { // 处理TRACE请求
        doTrace(req,resp);
    } else { // 不符合请求类型
        String errMsg = lStrings.getString("http.method_not_implemented");
        Object[] errArgs = new Object[1];
        errArgs[0] = method;
        errMsg = MessageFormat.format(errMsg, errArgs);
        resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
    }
}

对于HttpServlet的各种doXXX方法都是提供给子类去实现的。而在此处的子类是FrameworkServlet，再以GET请求为例子继续讲解：

protected final void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
	processRequest(request, response); 
}

protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	long startTime = System.currentTimeMillis();
	Throwable failureCause = null;

	LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
	LocaleContext localeContext = buildLocaleContext(request);

	RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
	ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

	WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
	asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

	initContextHolders(request, localeContext, requestAttributes);

	try {
		doService(request, response); // 重点关注这个方法
	} catch (ServletException | IOException ex) {
		failureCause = ex;
		throw ex;
	} catch (Throwable ex) {
		failureCause = ex;
		throw new NestedServletException("Request processing failed", ex);
	} finally {
		resetContextHolders(request, previousLocaleContext, previousAttributes);
		if (requestAttributes != null) {
			requestAttributes.requestCompleted();
		}
		logResult(request, response, failureCause, asyncManager);
		publishRequestHandledEvent(request, response, startTime, failureCause);
	}
}

最终还是调用回了DispatchServlet的doService方法：

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
	logRequest(request);
	// 备份request请求中的属性
	Map<String, Object> attributesSnapshot = null;
	if (WebUtils.isIncludeRequest(request)) {
		attributesSnapshot = new HashMap<>();
		Enumeration<?> attrNames = request.getAttributeNames();
		while (attrNames.hasMoreElements()) {
			String attrName = (String) attrNames.nextElement();
			if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
				attributesSnapshot.put(attrName, request.getAttribute(attrName));
			}
		}
	}
	// 为请求设置相应框架特有的属性
	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());
	if (this.flashMapManager != null) {
		FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
		if (inputFlashMap != null) {
			request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
		}
		request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new 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);
			}
		}
	}
}

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); // 根据request请求获取对应的映射处理器（它已经被封装成处理器链，并包含真正的处理器）
			if (mappedHandler == null) { // 没有可以处理该请求的映射处理器
				noHandlerFound(processedRequest, response); // 响应报错
				return;
			}
			
			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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
					return;
				}
			}
			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
				return;
			}
			
			mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); // 重点关注，真正调用处理方法，并返回结果

			if (asyncManager.isConcurrentHandlingStarted()) {
				return;
			}
			applyDefaultViewName(processedRequest, mv);
			mappedHandler.applyPostHandle(processedRequest, response, mv);
		} catch (Exception ex) {
			dispatchException = ex;
		} catch (Throwable err) {
			dispatchException = new NestedServletException("Handler dispatch failed", err);
		}
		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);
			}
		}
	}
}

遍历所有的HandlerMapping请求处理映射器，并根据请求获取Handler：

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	if (this.handlerMappings != null) {
		for (HandlerMapping mapping : this.handlerMappings) {
			HandlerExecutionChain handler = mapping.getHandler(request); // 获取Handler
			if (handler != null) {
				return handler;
			}
		}
	}
	return null;
}

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
	Object handler = getHandlerInternal(request); // 获取请求处理器
	if (handler == null) { // 获取的处理器为空，说明我们自定义的控制器无法处理该请求
		handler = getDefaultHandler(); // 获取默认处理器
	}
	if (handler == null) { // 默认处理器也为空，说明当前无法处理该请求，直接返回空
		return null;
	}
	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) || CorsUtils.isPreFlightRequest(request)) {
		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;
}

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
	try {
		return super.getHandlerInternal(request); // 调用父类的方法获取请求处理器
	} finally {
		ProducesRequestCondition.clearMediaTypesAttribute(request);
	}
}

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request); // 获取请求访问路径（在本例中是：/index）
	request.setAttribute(LOOKUP_PATH, lookupPath);
	this.mappingRegistry.acquireReadLock(); 
	try {
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request); // 根据请求和访问路径，获取处理请求的控制器方法
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null); // 控制器方法不为空，则说明可以处理该请求，则创建控制器实例
	}
	finally {
		this.mappingRegistry.releaseReadLock();
	}
}

创建对应的控制器实例（通过这个方法其实可以说明，所谓的Handler请求处理器，就是我们自己定义的Controller控制器）：

public HandlerMethod createWithResolvedBean() {
	Object handler = this.bean;
	if (this.bean instanceof String) {
		Assert.state(this.beanFactory != null, "Cannot resolve bean name without BeanFactory");
		String beanName = (String) this.bean; // 其实bean属性是字符串类型，为对应控制器的全限定类名
		handler = this.beanFactory.getBean(beanName); // 通过全限定类名创建控制器实例（在本例中是：创建TestController实例）
	}
	return new HandlerMethod(this, handler); // 返回请求处理方法对象，其中包含控制器实例
}

对于获取Handler处理器还有最后一步，将Handler处理器封装成 处理器执行链，往其中添加拦截器：

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
	HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
			(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

	String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH); // 获取请求访问路径（在本例中是：/index）
	for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
		if (interceptor instanceof MappedInterceptor) {
			MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
			if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
				chain.addInterceptor(mappedInterceptor.getInterceptor()); // 添加拦截器
			}
		} else {
			chain.addInterceptor(interceptor); // 添加拦截器
		}
	}
	return chain; // 返回处理器链
}

到此，能够处理当前请求的Handler请求处理器已创建完成。

2. Handler请求处理器已经创建完成，那么下一步就是获取HandlerAdapter处理适配器：

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
	if (this.handlerAdapters != null) {
		for (HandlerAdapter adapter : this.handlerAdapters) { // 遍历所有的请求处理器适配器
			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");
}

public final boolean supports(Object handler) {
	return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
}

protected boolean supportsInternal(HandlerMethod handlerMethod) {
	return true; // 始终返回true
}

3. 获取到了请求处理器，以及请求适配器，接下来就是利用适配器调用处理器中的真正处理方法：

通过这个方法可以知道调用处理方法的返回结果是ModeAndView类型：

public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
	return handleInternal(request, response, (HandlerMethod) handler);
}

protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
	ModelAndView mav;
	checkRequest(request); // 检查request请求是否合法
	if (this.synchronizeOnSession) { // 判断是否需要同步执行处理方法，默认是false
		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; // 返回执行结果
}

最后调用自定义的TestController控制器的对应方法index()：

@Controller
public class TestController {

    @RequestMapping("/index")
    public String index() {
        return "/WEB-INF/page/index.html";
    }

4. 最后判断返回的结果，是否需要渲染视图：

处理控制器方法返回的结果：

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable 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);
		}
	}

	if (mv != null && !mv.wasCleared()) { // 判断结果是否包含需要渲染的视图（在本例中返回的结果是index页面的路径，因此需要条件为true）
		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()) {
		return;
	}

	if (mappedHandler != null) {
		mappedHandler.triggerAfterCompletion(request, response, null);
	}
}

渲染并响应视图：

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
	Locale locale = (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
	response.setLocale(locale); // 将请求的语言环境应用于响应

	View view;
	String viewName = mv.getViewName(); // 获取视图名（本例中是：/WEB-INF/page/index.html）
	if (viewName != null) { // 视图名不为空
		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 { // 视图名为空，有可能返回的结果中已经包含了视图
		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.render(mv.getModelInternal(), request, response); // 响应视图
	} catch (Exception ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Error rendering view [" + view + "]", ex);
		}
		throw ex;
	}
}

解析视图名，并返回视图对象：

protected View resolveViewName(String viewName, @Nullable Map<String, Object> model, Locale locale, HttpServletRequest request) throws Exception {
	if (this.viewResolvers != null) {
		for (ViewResolver viewResolver : this.viewResolvers) { // 遍历所有的视图解析器
			View view = viewResolver.resolveViewName(viewName, locale); // 解析视图名
			if (view != null) { // 解析出来的视图对象不为空，说明解析成功，则返回视图对象
				return view;
			}
		}
	}
	return null;
}

解析视图名：

public View resolveViewName(String viewName, Locale locale) throws Exception {
	if (!isCache()) { // 判断是否启用了缓存
		return createView(viewName, locale); // 未启用则新建视图
	} else {
		Object cacheKey = getCacheKey(viewName, locale);
		View view = this.viewAccessCache.get(cacheKey); // 在缓存中获取视图
		if (view == null) { // 首次从缓存中获取为空
			synchronized (this.viewCreationCache) {
				view = this.viewCreationCache.get(cacheKey);
				if (view == null) {
					view = createView(viewName, locale); // 创建视图
					if (view == null && this.cacheUnresolved) { // 创建视图为空，说明创建失败
						view = UNRESOLVED_VIEW; // 将视图对象赋值为无法解析的视图
					}
					if (view != null && this.cacheFilter.filter(view, viewName, locale)) { // 视图不为空，再通过视图解析器链进行解析
						// 解析成功，设置缓存
						this.viewAccessCache.put(cacheKey, view);
						this.viewCreationCache.put(cacheKey, view);
					}
				}
			}
		} else {
			if (logger.isTraceEnabled()) {
				logger.trace(formatKey(cacheKey) + "served from cache");
			}
		}
		return (view != UNRESOLVED_VIEW ? view : null); // 返回视图对象
	}
}

最后响应视图：

public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
		HttpServletResponse response) throws Exception {

	if (logger.isDebugEnabled()) {
		logger.debug("View " + formatViewName() +
				", model " + (model != null ? model : Collections.emptyMap()) +
				(this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
	}

	Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
	prepareResponse(request, response);
	renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
}

到此，SpringMVC框架从请求到响应的核心流程源码解析到此结束。

MrFC
关注
  • 6
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从0到1搭建精品电商项目（用于毕设、简历等）—— 项目介绍与初步搭建（1）
2301_76238237的博客
04-19 686
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的MyBtis知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的MyBtis知识脑图原件（包括上方的面试解析xmind文档）
SpringMVC后端返回数据到前端代码示例
08-19
SpringMVC框架，后端开发人员能够方便地将数据发送到前端，以便在网页上展示或进行交互。这里我们将详细探讨两种主要的方式：通过`ModelAndView`对象返回数据到`.jsp`页面，以及通过返回JSON数据到HTML页面。 1. **...
牛逼！Java 从入门到精通，超全汇总版
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
JavaWeb三大组件之一——Servlet源码解析（剖析底层代码，需要耐心看完）
一只程序猿的博客
03-31 2601
什么是Servlet？ Servlet的全程是Server Applet。通俗来说，它是一个请求处理器，它可以接受来自前端或者其他服务器端的请求。作为Java工程师，我们通常是将其用在后端处理前端请求，执行相应业务操作。 而在目前市场的常用的主流框架，如Spring、SpringMvc、SpringBoot等等，这些Java应用开发框架中都不见Servlet的踪影，难道Servlet已经没落了吗？当然不是，这些所谓的主流框架，在底层用的其实还是Servlet，只是这些框架已经把Servlet封装隐藏起来了。
springMVC第一天——入门、整合与参数绑定
weixin_30267697的博客
05-24 240
　　大纲摘要： 　　1、Springmvc介绍 　　2、入门程序 　　3、Springmvc架构讲解 　　　　a)框架结构 　　　　b)组件说明 　　4、Springmvc整合mybatis 　　5、参数绑定 　　　　乱码问题解决 　　　　a)Springmvc默认支持的类型 　　　　b)简单数据类型 　　　　c)Pojo类型 　　　　d)Pojo包装类型 　...
SpringMVC《学习笔记(源码底层+基础用法整合)》
weixin_44981126的博客
06-06 4791
SpringMVC《学习笔记(源码底层+基础用法整合)》
SpringMVC
vende_tta的博客
07-01 708
SprintMVC 框架学习：官方文档 重点：SprintMVC的执行流程 1.MVC框架设计 MVC是三个单词的首字母缩写，它们是Model（模型）、View（视图）和Controller（控制）。 Model(dao,service) 是核心的"数据层"（Model），也就是程序需要操作的数据或信息。 View(jsp…) 直接面向最终用户的"视图层"（View）。它是提供给用户的操作界面，是程序的外壳。 Controller(servlet) 它负责根据用户输入的指令，选取"数据层"中的数
android安卓源码海量项目合集打包-1
热门推荐
chenhao0568的专栏
06-11 13万+
下载地址 最后更新共计113个分类5177套源码29.2 GB。 卷 新加卷 的文件夹 PATH 列表 卷序列号为 00000200 5E7A:7F30 F:. ├─前台界面 │ ├─3D标签云卡片热门 │ │ Android TagCloudView云标签的灵活运用.rar │ │ Android 实现 标签 拖动 改变位置.rar │ │ android 流式布局和热门标签.zip │ │ ...
Spring，SpringMVC总结
wxy198的博客
03-03 1011
Spring、SpringMVC总结
java-springmvc 01 补充 javaweb 三大组件Servlet，Filter、Listener（源码都是tomcat8.5项目中的）
qq_38757863的博客
04-27 140
01。
基于SSH的公司内部管理系统完整源码+说明（前端 Jsp，后端 Spring SpringMVC Hibernate）.zip
03-28
【资源说明】 1、该资源内项目代码都是经过测试运行成功，功能正常的情况下才上传的，请放心下载使用。 2、适用人群：主要针对计算机相关专业(如计科、信息安全、数据科学与大数据技术、人工智能、通信、物联网、...
基于SSH的公司内部管理系统源码+项目说明（前端 Jsp，后端 Spring SpringMVC）.zip
03-09
基于SSH的公司内部管理系统源码+项目说明（前端 Jsp，后端 Spring SpringMVC Hibernate，系统角色分为总经理、部门经理、普通员工，经理和员工通过该系统完成考勤数据录入，员工之间可以文档共享，消息沟通等）.zip
基于SSM框架的书评网完整源码（前端+后端）
03-08
这个书评网项目使用了SSM框架，提供了从前端到后端的完整源码，非常适合学习和实践Java Web开发。下面将详细阐述SSM框架的组成部分以及在书评网项目中的应用。 **1. Spring框架** Spring是Java企业级应用的核心框架...
从源码的角度来看SpringMVC_从源码的角度来看SpringMVC_
10-01
本文将从核心组件、请求处理流程、DispatcherServlet、HandlerMapping、ModelAndView、视图解析等多个方面，详细阐述SpringMVC的源码分析。 1. **核心组件** SpringMVC的核心组件包括DispatcherServlet、...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 508
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 297
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 288
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 908
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值