SpringMVC源码解析

    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }

org.springframework.web.servlet.HandlerMapping=
　　　　org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,//例如@Component("/index")
    　 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,//例如：@RequestMapping("/index")
    　 org.springframework.web.servlet.function.support.RouterFunctionMappingprivate void initHandlerMappings(ApplicationContext context)this.handlerMappings = null;

if (this.detectAllHandlerMappings) {
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            // 从spring容器singletonObjects的list集合中拿出来所有的HandlerMapping
            Map matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        }
        else {//默认不走这个方法，因为this.detectAllhandlerMappings为true
            try {
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we‘ll add a default HandlerMapping later.
            }
        }

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
　　　　// 通过配置文件中的配置的信息得到handlerMapping
        if (this.handlerMappings == null) {
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerMappings declared for servlet ‘" + getServletName() +
                        "‘: using default strategies from DispatcherServlet.properties");
            }
        }
    }

protected  List getDefaultStrategies(ApplicationContext context, Class strategyInterface) {
        String key = strategyInterface.getName();
        String value = defaultStrategies.getProperty(key);
        if (value != null) {
            String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
            List strategies = new ArrayList(classNames.length);
            for (String className : classNames) {
                try {
                    Class> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
                    Object strategy = createDefaultStrategy(context, clazz);
                    strategies.add((T) strategy);
                }
                catch (ClassNotFoundException ex) {
                    throw new BeanInitializationException(
                            "Could not find DispatcherServlet‘s default strategy class [" + className +
                            "] for interface [" + key + "]", ex);
                }
                catch (LinkageError err) {
                    throw new BeanInitializationException(
                            "Unresolvable class definition for DispatcherServlet‘s default strategy class [" +
                            className + "] for interface [" + key + "]", err);
                }
            }
            return strategies;
        }
        else {
            return new LinkedList();
        }
    }

private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;

        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            Map matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        }
        else {
            try {
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                this.handlerAdapters = Collections.singletonList(ha);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we‘ll add a default HandlerAdapter later.
            }
        }

        // Ensure we have at least some HandlerAdapters, by registering
        // default HandlerAdapters if no other adapters are found.
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerAdapters declared for servlet ‘" + getServletName() +
                        "‘: using default strategies from DispatcherServlet.properties");
            }
        }
    }

protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws Exception;

doDispatch(request, response);

processedRequest = checkMultipart(request)

mappedHandler = getHandler(processedRequest);

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { 
    if (this.handlerMappings != null) { 
        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; 
}

　　我们能看见他是在遍历一个handlerMappings 

　　

　　可以看见图片上1188行代码， 他从这个mapping 里面获取了一个handler 如果获取到了 这个方法就走完了， 不 然就下一次循环. 

　　问题1解释: 

　　　这个HandlerMapping 哪里来的呢。 不多说，上图：

　　我们在源码包的DispatcherServlet.properties文件下会看见， 他定义了图片里的这些属性。 重点放在方框内，第 一个属性，就是我们刚看见的HandlerMappings， 也就是说 HandlerMappings也就是他自己事先定义好的呢。至 于第二个属性，咱们待会儿见~ 

　　也就是说SpringMVC自己自带了2个HandlerMapping 来供我们选择 至于 为什么要有2个呢？ 这时候得启动项目从断点的角度来看看了; 

　　我们用2种方式来注册Controller 分别是:

　　作为Bean的形式： 

@Component("/test") 
public class TesrController implements org.springframework.web.servlet.mvc.Controller{ 
    @Override 
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception { 
        System.out.println("1"); return null; 
    } 
}

　　以Annotation形式： 

@Controller 
public class AnnotationController { 
    @RequestMapping("/test2") 
    public Object test(){ 
        System.out.println("test"); 
        return null; 
    }
}

　　我们先用Bean的方式来跑: 

　　视角走到我们的mappedHandler = getHandler(processedRequest);里面 

　　问题2解释: 

　　来，跟着箭头走，我们发现 我们以Bean的形式注册的Controller 可以从这个BeanNameUrlHandlerMapping里面获取到对应的Handler ; 这里 我们是不是对于这个HandlerMapping有了懵懂的了解了？ 

　　猜想1： 

　　我们来猜一下 如果是以Annotation的形式注册的Controller的话 就会被第二个HandlerMapping获取到。 至于对不对 这个问题我们先留着。

　　我们先让代码继续走，会发现 Handler返回出来紧接着会执行下面这个方法，这个方法我们从流程图中可以了解到，就是在找一个适配器。

HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

问题3：何为适配器？

　　我们先来看看他这个方法里面干了啥：

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException { 
    if (this.handlerAdapters != null) { 
        for (HandlerAdapter ha : this.handlerAdapters) { 
            if (logger.isTraceEnabled()) { 
                logger.trace("Testing handler adapter [" + ha + "]"); 
                }
            if (ha.supports(handler)) { 
                return ha; 
                } 
        } 
    }
throw new ServletException("No adapter for handler [" + handler +"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler"); 
}

　　其实能看见他是从一个handlerAdapters属性里面遍历了我们的适配器 这个handlerAdapters哪来的呢？ 跟我们的HandlerMappings一样 在他的配置文件里面有写，就是我们刚刚所说的 待会儿见的那个东西~ 不多说 上图： 

　　问题3解释： 

　　至于什么是适配器，我们结合Handler来讲， 就如我们在最开始的总结时所说的， 一开始只是找到了Handler 现在要执行了，但是有个问题，Handler不止一个， 自然而然对应的执行方式就不同了， 这时候适配器的概念就出来了：对应不同的Handler的执行方案。 

　　当找到合适的适配器的时候， 基本上就已经收尾了，因为后面在做了一些判断之后（判断请求类型之类的），就开始执行了你的Handler了，上代码： 

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

　　这个mv就是我们的ModlAndView 其实执行完这一行 我们的Controller的逻辑已经执行完了， 剩下的就是寻找视图 渲染图的事情了.... 

　　我们这里只是使用了Bean的形式执行了一遍流程 假设使用Annotation呢？ 

　　

　　然后就是到了我们的适配器了： 

　　

　　这里我们会看到用的是这个适配器 而我们的Bean方式注册的Controller 的话 使用的是另外两个适配器来的，至于有什么区别呢？ 我们来看看他执行的时候

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

　　我们的Annotation的形式 是拿到这个handler作为一个HandlerMethod 也就是一个方法对象来执行 这时候我们看看Bean是什么样子的：

@Override 
@Nullable 
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
    return ((Controller) handler).handleRequest(request, response); 
}

　　由最开始可以看到 我们如果以Bean的形式注册Controller的话 我们的实现一个Controller的接口 在这里 他把我们的handler强制转换为一个Controller来执行了。

总结 

　　其实我们的SpringMVC关键的概念就在于Handler（处理器） 和Adapter(适配器)

　　通过一个关键的HandlerMappings 找到合适处理你的Controller的Handler 然后再通过HandlerAdapters找到一个合适的HandlerAdapter 来执行Handler即Controller里面的逻辑。 最后再返回ModlAndView...