流程图
ps:4和7应该是DispatcherServlet和handlerAdapter之间的
网上找的图就不重画了…
源码
初始化
调用 org.springframework.web.servlet.HttpServletBean#initServletBean（servlet 的init）
调用org.springframework.web.servlet.FrameworkServlet#initWebApplicationContext
调用org.springframework.web.servlet.FrameworkServlet#onRefresh
调用org.springframework.web.servlet.DispatcherServlet#initStrategies
/**
* Initialize the strategy objects that this servlet uses.
* <p>May be overridden in subclasses in order to initialize further strategy objects.
*/
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
首先SpringMVC得核心是DispatcherServlet,可以看到最终也是继承了HttpServlet
要到他的父类FrameworkServlet就可以找到doGet()
进入processRequest()方法
再进入doService()方法
再进入doDispatch()方法,里面就是SpringMVC的核心流程
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.
// 先找到对应的handlermapping,在找到对应的handler(即Controller层某个具体的方法)
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// Determine handler adapter for the current request.
// 根据handler再去找到对应的HandlerAdapter,适配器
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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
// 这里是第一个执行拦截器preHandle
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
// 通过适配器去执行handler的处理逻辑,返回modelandview
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
applyDefaultViewName(processedRequest, mv);
// 这里是第二个拦截器的地方postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
// As of 4.3, we're processing Errors thrown from handler methods as well,
// making them available for @ExceptionHandler methods and other scenarios.
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
// 第三个拦截器的地方afterCompletion
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
// 第三个拦截器的地方afterCompletion
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
5.2.2版本的springmvc,有2个默认的handlerMapping,是在项目启动的时候初始化的
先看DispatcherServlet里面的静态代码块
static {
// Load default strategy implementations from properties file.
// This is currently strictly internal and not meant to be customized
// by application developers.
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
}
}
加载了一个文件DispatcherServlet.properties
里面是springmvc要默认加载
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
源码可知,spring是先找到对应的handlerMapping,在通过这个mapping去找到对应的handler
handler就是对应的某个Controller层的方法
RequestMappingHandlerMapping
就是我们正常使用的方式
这种方式最后处理的时候是通过反射去调用
@Controller
public class UserController {
@RequestMapping("/test")
@ResponseBody
public String test() {
System.out.println("***************");
return "hello spring mvc";
}
}
BeanNameUrlHandlerMapping
两种实现方式
@Component("/test2")
public class UserController2 implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
System.out.println("hello controller");
return null;
}
}
@Component("/test3")
public class UserController3 implements HttpRequestHandler {
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("test HttpRequestHandler");
}
}
拦截器和过滤器
过滤器是基于函数回调的，需要依赖servlet容器，在请求进入容器后，还未进入Servlet之前进行预处理，并且请求结束返回给前端进行后期处理，只能在容器初始化时调用一次
拦截器不依赖于servlet容器，依赖于web框架，在springmvc中就是依赖于SpringMVC框架，通过继承HandlerInterceptorAdapter,是基于Java反射机制，可以选择拦截或者放行,一般使用的都是第一种,拦截器功在对请求权限鉴定方面确实很有用处：
⑴(preHandle)请求还没有到controller层时进行拦截
⑵(postHandle)请求走出controller层次，还没有到渲染时图层时进行拦截
⑶(afterCompletion)结束视图渲染，但是还没有到servlet的结束时进行拦截。对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理
上面源码注释分别标注了三处执行拦截器的地方,
注意: preHandle返回了false,依然会去执行afterCompletion
