SPI机制
传统的springmvc项目，需要我们指定web.xml等配置文件，但是，在spring的官网，官方推荐的并不是xml格式的，而是
public class MyWebApplicationInitializer implements WebApplicationInitializer {
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
// Load Spring web application configuration
//初始化springweb容器
AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext();
ac.register(SpringbootAppConfig.class);
ac.refresh();
// Create and register the DispatcherServlet
//注册DispatcherServlet
DispatcherServlet servlet = new DispatcherServlet(ac);
ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
registration.setLoadOnStartup(1);
registration.addMapping("*.do");
}
}
这七行代码，和我们传统的springmvc项目中加web.xml是一样的效果，这个方法是完成servlet容器的初始化，那为什么spring自己写的类，Tomcat在启动的时候，会调用呢？
在Servlet3.0新加的SPI机制是这样要求的：
- 如果一个项目(Tomcat)在启动的时候，需求调用外部系统(spring)的部分方法，完成初始化，那么，在外部系统中，在项目的resource文件下 META-INF/services/javax.servlet.ServletContainerInitializer 声明这么一个文件(路径是不允许变的)；文件中声明的类如果实现了ServletContainerInitializer接口；那么，Tomcat在启动的时候 必须要调用文件中声明的类的onStart方法；前提是：必须是一个web项目，否则Tomcat不会调用
- 但是spring官方文档指明开发springmvc，需要实现的是 WebApplicationInitializer 接口，那么WebApplicationInitializer和ServletContainerInitializer之间有什么关系？servlet3.0还有一个规范，如果在 实现了ServletContainerInitializer接口的类 上加上 @HandlesTypes(WebApplicationInitializer.class) 注解，那么onStart方法需要调用注解中接口的所有实现类对应的onStart方法
springmvc应用
这张原理图是在网上随便找了一张
运行原理
- 前台发送请求，请求会首先通过DispatcherServlet，前端控制器
- 前端控制器收到请求，会调用HandlerMapping(处理器映射器)来匹配有没有相对于的handlerMapping，如果有匹配的，会包装成handlerExecutionChain
- 接着dispatcherServlet会调用handlerAdapter，通过handlerAdapter来执行真正的业务逻辑代码，也就是所谓的controller中的方法
- 调用完成之后，返回modelAndView，前端控制器会调用师徒解析器ViewResolver对modelAndView进行解析
- 视图解析器会解析出对应的view，前端控制器根据view并进行视图的渲染(数据填充)，然后返回给前端调用者
springmvc核心组件
- 前端控制器 DispatcherServlet
- 处理器映射器 HandlerMapping
- 处理器适配器 HandlerAdapter
- 视图解析器 viewResolver
- ModelAndView
controller的三种配置方式
- @Controller注解
- 实现Controller接口，这种方式，需要在类名增加@Component("/映射地址")
- 实现HttpRequestHandler接口，在类上加@Component("/映射地址")
后面两种原理是一样的，下面会说到；spring默认的handlerMapping有两种：RequestMappingHandlerMapping和BeanNameUrlHandlerMapping；对于@Controller注解的controller，都是由前者来处理的，实现controller接口或者httpRequestHandler接口，是由后者来处理的
spring自带的handlerMapping
- RequestMappingHanderlMapping：@Controller是由该handlerMapping处理的
- BeanNameUrlHandlerMapping：后面两种实现方式都是=该handlerMapping处理的
spring自带的handlerAdapter
- RequestMappingHandlerAdapter：@Controller是由该handlerAdapter处理的
- HttpRequestHandlerAdapter：后面两种实现方式都是该handlerAdapter处理的
- SimpleControllerHadnlerAdapter
springmvc源码
springmvc的源码，我们暂时分为两部分，一是启动初始化，二是调用过程
简单而言，在请求接口的时候，需要根据与URL地址找到对应的处理方法，这个映射关系是在初始化的时候，存入到了一个map集合中
启动初始化
在spring初始化的时候，我们需要关注两个bean的初始化：
RequestMappingHandlerMapping和BeanNameUrlHandlerMapping
RequestMappingHandlerMapping是在org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration.EnableWebMvcConfiguration这里，在springboot自动注入的时候，给注入到beanDefinitionMap中了
BeanNameHandlerMapping 是在org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport中注入的
RequestMappingHandlerMapping
由于该mapping实现了InitializingBean，所以，在实例化该bean的时候，会调用父类的afterProperties()方法，在父类的方法中，又会调用到子类的org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#detectHandlerMethods这个方法，来初始化URL和method的对应关系；具体的调用逻辑在截图中，这几个方法中，只是有一些简单的校验，所以就跳过
/**
* @param handler
* 在这里其实是根据bean,获取到bean中所有添加了@RequestMapping注解的method，
* 然后把method和url进行映射，并把映射关系存到map中
*/
protected void detectHandlerMethods(Object handler) {
Class<?> handlerType = (handler instanceof String ?
obtainApplicationContext().getType((String) handler) : handler.getClass());
if (handlerType != null) {
//userType是当前的类名
Class<?> userType = ClassUtils.getUserClass(handlerType);
//根据类名获取到所有的方法
Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
(MethodIntrospector.MetadataLookup<T>) method -> {
try {
return getMappingForMethod(method, userType);
}
catch (Throwable ex) {
throw new IllegalStateException("Invalid mapping on handler class [" +
userType.getName() + "]: " + method, ex);
}
});
if (logger.isDebugEnabled()) {
logger.debug(methods.size() + " request handler methods found on " + userType + ": " + methods);
}
methods.forEach((method, mapping) -> {
Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
//这里是来注册映射关系的
registerHandlerMethod(handler, invocableMethod, mapping);
});
}
}
在注册映射关系的时候，其实就是将url和对应的方法，存入到了一个map集合中，这里的registerHandlerMethod内部调用到了org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.MappingRegistry#register，这这个方法中，将映射关系存入到了urlLookup这个map中
BeanNameUrlHandlerMapping
由于beanNameUrlHandlerMapping间接的实现了applicationContextAware，所以，在调用org.springframework.context.support.ApplicationContextAwareProcessor#postProcessBeforeInitialization的时候，会调用org.springframework.context.support.ApplicationObjectSupport#setApplicationContext；在底层，会调用到org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping#detectHandlers
在该方法中，
protected void detectHandlers() throws BeansException {
ApplicationContext applicationContext = obtainApplicationContext();
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
applicationContext.getBeanNamesForType(Object.class));
// Take any bean name that we can determine URLs for.遍历beanName
for (String beanName : beanNames) {
//判断beanName是否是以 / 开头的
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// URL paths found: Let's consider it a handler.
registerHandler(urls, beanName);
}
}
if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
}
}
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping#determineUrlsForHandler
@Override
protected String[] determineUrlsForHandler(String beanName) {
List<String> urls = new ArrayList<>();
if (beanName.startsWith("/")) {
urls.add(beanName);
}
String[] aliases = obtainApplicationContext().getAliases(beanName);
for (String alias : aliases) {
if (alias.startsWith("/")) {
urls.add(alias);
}
}
return StringUtils.toStringArray(urls);
}
推断出来beanName是以 / 开头的话，就会将当前url和对应的beanName添加到 一个map集合中：org.springframework.web.servlet.handler.AbstractUrlHandlerMapping#handlerMap
总结来说
RequestMappingHandlerMapping(@Controller注解)实现了InitializingBean接口
1.在初始化这个bean的时候，会调用afterPropertiesSet(initialization初始化方法)方法，
2.在这个方法中，会获取到当前单实例池中所有的Object类型的bean，过滤掉以scopedTarget.开头的bean
3.获取到bean中定义的方法(得到method名称和映射地址)，遍历methods,调用org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.MappingRegistry#register方法，在这里，会把当前
BeanNameUrlHandlerMapping(Controller接口)是实现了ApplicationContextAware接口的类(中间有多重继承实现)
1.在初始化这个bean的时候，会调用setApplicationContext()方法
2.最终会调用到org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping#detectHandlers方法，
3.在这个方法中，会获取到单实例池中所有的Object.class类型的beanName,获取到beanName之后，有一个判断，判断beanName是否是以 / 开头的；如果是，就调用registerHandler(urls, beanName);
4.然后会把当前映射路径和对应的Controller添加到handlerMap中
调用
在第一次调用controller的时候，会对dispatcherServlet进行初始化
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
在request请求过来的时候，会进入到org.springframework.web.servlet.DispatcherServlet#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.
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 = "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;
}
// Actually invoke the handler.
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) {
// 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) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
triggerAfterCompletion(processedRequest, response, mappedHandler,
new NestedServletException("Handler processing failed", err));
}
finally {
}
}
在getHandler()方法中，会根据当前请求的url地址来进行映射方法的查找，如果找到，返回对应的handlerMapping，然后包装成HandlerExecutionChain返回；
在getHandlerAdapter()方法中，根据当前handlerMapping对应的handlerAdapter，找到对应的handlerAdapter，
在mv = ha.handle(processedRequest, response, mappedHandler.getHandler());中会根据方法的入参和实际请求中的参数名对参数进行赋值，然后调用对应的controller方法
遗留问题
1.url中的参数如何解析？ XXX/{id}
2.controller入参，dispatcherServlet是如何判断处理的