Spring MVC源码深入剖析执行流程

最新推荐文章于 2022-05-31 08:19:04 发布

置顶 JAVA_DIRECTION

最新推荐文章于 2022-05-31 08:19:04 发布

阅读量406

点赞数 1

分类专栏： SpringMVC 文章标签： mvc spring

SpringMVC 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Spring MVC是现在最流行的MVC框架, 很多人说它是一个优秀的框架。实质上是由于Spring MVC加入注解,注解让Spring MVC质变, 这使得开发效率得到了飞速提升。而且它本身就是Spring的一小部分,所以让就不再像Struts2那样，需要插件的支持。也就是说，它们是无缝连接的。但无论多少多么优秀的框架，它们永远都是建立在listener, servlet, filter这些服务器容器组件之上的。可见基础尤其重要。

首先, 如果我们想在Web项目中添加spring MVC的支持，要在web.xml中配置如下代码:

[html] view plain copy

<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

其中，org.springframework.web.servlet.DispatcherServlet就是整个Spring MVC框架的切入点。与添加Struts类似。Struts是通过Filter作为切入点，而Spring MVC使用的是Servlet。原理其实是一样的，都起到拦截用户请求的作用。Filter是在服务器启动时，即生成一个实例。而Servlet若不设置load-on-startup，则为第一次访问时生成实例。DispatcherServlet需要在服务器启动时生成实例。

下面我们通过源码的来解析Spring MVC的大体流程:

[java] view plain copy

//这是DispatcherServlet的定义,继承自FrameworkServlet
public class DispatcherServlet extends FrameworkServlet {
…
protected void initStrategies(ApplicationContext context) {
…
}
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
…
}
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
…
}
…
｝

当我们发送请求时,DispatcherServlet会进行拦截,而对于Servlet来说。service方法是处理请求的核心,但DispatcherServlet中并没有定义此方法。我们通过父类FrameworkServlet中查看：

[java] view plain copy

protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String method = request.getMethod();
if (method.equalsIgnoreCase(RequestMethod.PATCH.name())) {
processRequest(request, response);
}
else {
super.service(request, response);
}
}

processRequest(request,response)方法调用,在这个方法中，调用的了doService(request,response)。而此时doService正是上述的DispatcherServlet中的doService方法。而doService中又调用了doDispatcher方法。那么可以看出,doDispatcher就是DispatcherServlet处理核心方法。

下面为doDispatcher方法的源码:

[java] view plain copy

/**
* Process the actual dispatching to the handler.
* The handler will be obtained by applying the servlet’s HandlerMappings in order.
* The HandlerAdapter will be obtained by querying the servlet’s installed HandlerAdapters
* to find the first that supports the handler class.
* All HTTP methods are handled by this method. It’s up to HandlerAdapters or handlers
* themselves to decide which methods are acceptable.
* @param request current HTTP request
* @param response current HTTP response
* @throws Exception in case of any kind of processing failure
*/
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()) {
logger.debug(”Last-Modified value for [“ + getRequestUri(request) + “] 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);
}
}
}

首先有几个类需要声明,ModelAndView、HandlerExecutionChain、HandlerMapping、HandlerMethod、HandlerAdapter。

1、HandlerMethod(org.springframework.web.method.HandlerMethod)，这个类为中存放了某个bean对象和该bean对象的某个要处理的Method对象。

2、HandlerMapping,作用为通过request对象，获取对应的HandlerMethod对象。

3、HandlerExecutionChain作用为通过加入Interceptor拦截器包装HandlerMapping返回的HandlerMethod对象。让待处理的方法对象与拦截器称为一个整体,即执行链。

4、ModelAndView,顾名思义。Model即MVC的M，View即MVC的V。其对象存放的正是数据与视图信息。

5、HandlerAdapter:作用为具体处理HandlerMethod,即通过它调用某个方法。

下面分析正题:

doDispatcher方法中,首先通过getHandler方法获得handler,如下:

[java] view plain copy

/**
* Return the HandlerExecutionChain for this request.
* Tries all handler mappings in order.
* @param request current HTTP request
* @return the HandlerExecutionChain, or {@code null} if no handler could be found
*/
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并调用每个HandlerMapping对象的getHandler方法,而HandlerMapping为接口,其中AbstractHandlerMapping这个抽象类中实现了HandlerMapping接口,并实现了getHandler方法,如下:

[java] view plain copy

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
Object handler = getHandlerInternal(request);
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
// Bean name or resolved handler?
if (handler instanceof String) {
String handlerName = (String) handler;
handler = getApplicationContext().getBean(handlerName);
}
return getHandlerExecutionChain(handler, request);
}

其中Object handler = getHandlerInternal(request);为获取HandlerMethod对象,此方法源码如下:

[java] view plain copy

/**
* Look up a handler method for the given request.
*/
@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
if (logger.isDebugEnabled()) {
logger.debug(”Looking up handler method for path ” + lookupPath);
}
HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
if (logger.isDebugEnabled()) {
if (handlerMethod != null) {
logger.debug(”Returning handler method [“ + handlerMethod + “]”);
}
else {
logger.debug(”Did not find handler method for [“ + lookupPath + “]”);
}
}
return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}

在获得HandlerMethod对象之后，通过getHandlerExecutionChain(handler, request)将HandlerMethod对象与Interceptor拦截器封装,成为HandlerExecutionChain的对象。这就是doDispatch方法中mappedHandler引用指向的对象的来源流程。
获得HandlerExecutionChain对象之后，可以通过这个对象获得之前封装进去的HandlerMethod对象。通过getHandler()即可。

[java] view plain copy

// Determine handler adapter for the current request.
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

而HandlerAdapter接口的具体实现类的对象为真正调用方法,即通过反射调用HandlerMethod对象中封装的某个类的实例所对应的某个方法。

[java] view plain copy

// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

返回值为ModelAndView类型的对象,作用就不必多说.而在hanle方法之前和之后有这么两个方法调用:

[java] view plain copy

mappedHandler.applyPreHandle(processedRequest, response)

[java] view plain copy

mappedHandler.applyPostHandle(processedRequest, response, mv);

作用就是通过执行链中的Interceptor拦截器做拦截处理。功能与Filter相似。

总结如图:

另外应该注意的是，我们若想使用Spring MVC, 就必须有一个类似于Spring的applicationContext.xml那样的配置文件，(默认名为servletName-servlet.xml, 这里的servletName指在web.xml中配置的servlet的name属性)配置文件,。作用不用多说，与Spring的applicationContext.xml类似，作为IOC容器的核心文件, 所有bean组件都通过它来创建。也是IOC的核心。