已知, DispatcherServlet
这个类是 spring 用于处理请求的。
我们先来看看 它的 继承关系:
可以发现,它是从 Servlet规范来的,还继承了 HttpServlet
这个类,我们犹记得 javaweb中 我们就是继承 HttpServlet
这个类,重写 doGet()
和 doPost()
方法来达到请求的处理的。
既然如此,它的继承关系中,肯定有一个类也是重写了 doGet() 和 doPost 方法,经查,是 FrameworkServlet
这个类
调用的是 processRequest(request, response);
这个方法来处理
在该方法中,在一堆属性设置之后,又调用了 doService(request, response);
这个方法来处理,再去找:
发现,该方法让子类去实现了,而 FrameworkServlet
又只有 DispatcherServlet
这一个子类,所以进入子类的 doService:
在该方法中,又是一堆 setAttribute() 方法,我们直接忽略,看到一个
doDispatch(request, response);
方法,具体的操作应该就在这个方法里面了!!!
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);
if (mappedHandler == 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 = HttpMethod.GET.matches(method);
if (isGet || HttpMethod.HEAD.matches(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
applyDefaultViewName(processedRequest, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
//catch 及 finally 块
}
该代码我将 catch 和 finally块去掉了。
第一步,定义了一个 HandlerExecutionChain
对象,我们看一下这个类:
注意一下 handler
和 interceptorList
这两个变量,直接看英文也可以猜出来 前者是 处理器 ,后者是 拦截器
接下来看到这一行:
这里是使用 getHandler 给 HandlerExecutionChain
对象赋值,进入该方法:
可以看到遍历 一个HandlerMapping
的集合,只要得到了 HandlerExecutionChain
对象就退出。
所以我么查看 getHandler()方法,发现是一个接口,我们不确定调用的是哪一个实现类重写的方法,所以debug一下:
发现走的是 AbstractHandlerMapping
这个实现类重写的方法,所以来看一下具体做的操作:
如上图,我们看到第一句就是 调用 getHandlerInternal()
方法来获取 handler 处理器。点进去看时发现是抽象方法,所以又需要 debug来看一下具体调用的是哪个重写的方法,发现是 RequestMappingInfoHandlerMapping
类重写的,
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
try {
return super.getHandlerInternal(request);
}
finally {
ProducesRequestCondition.clearMediaTypesAttribute(request);
}
}
可以看到,将操作交给了getHandlerInternal() 方法:
/**
* Look up a handler method for the given request.
*/
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
String lookupPath = initLookupPath(request);
this.mappingRegistry.acquireReadLock();
try {
HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}
finally {
this.mappingRegistry.releaseReadLock();
}
}
如上,看一下注释,说的是 为这个请求寻找一个处理器方法。这里就不往下分析了,往下分析过于复杂,我们只需要知道 该方法是从我们所写的 Controller
里面寻找一个 和当前 url 对应的那个方法来处理当前请求。
Object handler = getHandlerInternal(request);
执行过之后,我们就得到了具体的Controller的那一个方法来执行当前的请求
往下走,
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
看到该方法返回的是我们在外层需要的HandlerExecutionChain
对象,所以该方法需要重点关注一下:
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
if (interceptor instanceof MappedInterceptor) {
MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
if (mappedInterceptor.matches(request)) {
chain.addInterceptor(mappedInterceptor.getInterceptor());
}
}
else {
chain.addInterceptor(interceptor);
}
}
return chain;
}
第一步根据handler的类型决定如何创建HandlerExecutionChain
对象,handler的类型应该是 HandlerMethod
,所以使用构造方法创建对象,
将handler 处理器封装到了 HandlerExecutionChain
对象里。
后面的循环:
for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
if (interceptor instanceof MappedInterceptor) {
MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
if (mappedInterceptor.matches(request)) {
chain.addInterceptor(mappedInterceptor.getInterceptor());
}
}
else {
chain.addInterceptor(interceptor);
}
}
很容易理解,就是将能对当前url进行拦截的拦截器添加到 HandlerExecutionChain
对象里面去。
上面两步完成了,一个 完整的HandlerExecutionChain
对象就封装好了,
然后回到 DispatcherServlet
类的 getHandler()
方法。,判断完非空之后,就回到了 doDispatch()
方法:
下一步执行的就是 getHandlerAdapter()
的方法,参数是 某个Controller的那个方法,类型是 HandlerMethod
/**
* Return the HandlerAdapter for this handler object.
* @param handler the handler object to find an adapter for
* @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
*/
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
if (this.handlerAdapters != null) {
for (HandlerAdapter adapter : this.handlerAdapters) {
if (adapter.supports(handler)) {
return adapter;
}
}
}
}
很容易理解,就是找到一个能支持 handler的 Adpter来执行 handler。
这里其实用到了适配器模式,必须要知道,
HandlerExecutionChain
对象中的处理器handler 不止 Controller一种类型,可以用于Web请求处理的统称为Handler,Controller只是Handler的一种特殊类型。如果不使用适配器模式,那么就只能用 if-else例举出每一种可能的Handler类型,这是不具有扩展性的,为了能够以统一的方式调用各种类型的Handler,DispatcherServlet
将不同的Handler调用职责交给了HandlerAdapter
所以,如果我们是Controller作为handler,最后得到的 HandlerAdapter
应该是 SimpleControllerHandlerAdapter
如图,和我们的猜想一样,使用 supports()方法来判断是否是Controller类型,用handle() 去具体执行请求。
现在得到了 HandlerAdapter
对象
回到 doDispatch() 方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
我们再去看看HandlerExecutionChain
类里的这个方法:
可以发现,是执行每一个拦截器的 preHandle()
方法
回到 doDispatch() 方法,下一步是
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
根据注释,我们都知道是执行我们定义的 Controller里的逻辑,然后返回的是 ModelAndView
对象
下一步:
applyDefaultViewName(processedRequest, mv);
这一步是给 ModelAndView
对象设置视图名字
下一步:
mappedHandler.applyPostHandle(processedRequest, response, mv);
进入该方法查看一下:
可以发现,就是执行每一个拦截器的postHandle()
方法,然后该方法有参数ModelAndView
对象,可知在方法中可以对最后的模型视图对象修改,添加一些公共数据等等
回到 doDispatch() 方法,后面就是:
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
查看一下该方法:
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
// Did the handler return a view to render?
if (mv != null && !mv.wasCleared()) {
render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No view rendering, null ModelAndView returned.");
}
}
if (mappedHandler != null) {
// Exception (if any) is already handled..
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
第一步是判断是否要渲染一个视图, 第二个继续查看该方法:
可以发现,第二个是执行所有拦截器的afterCompletion()
方法
总结:
Java要处理 Web请求,要继承 HttpServlet
类并重写 doGet()
和 doPost()
方法
这一点在spring中仍然没有变化。 DispatcherServlet
重写doGet()
的逻辑在 doDispatch()
方法中,
在该方法中,定义了一个 HandlerExecutionChain
对象来封装对 执行该请求的具体的处理器(就是我们编写的Controller里的具体方法)和能拦截该请求的所有拦截器,处理器和拦截器从Spring容器里找。
HandlerExecutionChain
对象封装完毕之后,先执行 所有拦截器的 preHandle()
方法,然后执行 Controller的具体逻辑,获得 ModelAndView
对象,然后执行 所有拦截器的 postHandle()
方法 ,然后如果 ModelAndView
对象非NULL,那就渲染视图, 最后执行所有拦截器的 afterCompletion()
收尾