《SpringMVC从入门到放肆》四、SpringMVC配置式开发（处理器映射器）

上一篇我们讲解了DispatcherServlet的url-pattern配置详解，今天我们来真正对SpringMVC进行配置式开发。
所谓配置式开发是指“处理器类是程序员自己定义的、实现了特定接口的类，然后在SpringMVC配置文件中对该类进行显式的，明确的注册”的开发方式。今天我们的开发还是将中央调度器的url-pattern配置成*.do。然后将springmvc.xml的静态资源访问先取消。

一、处理器映射器（BeanNameUrlHandlerMapping）
handlerMapping接口负责根据request请求找到对应的Handler处理器及Interceptor拦截器，并将它们封装在HandlerExecutionChain对象中，返回给中央调度器。其常用的实现类有两种：
1、BeanNameUrlHandlerMapping
2、SimpleUrlHandlerMapping

这里着重说明SimpleUrlHandlerMapping。BeanNameUrlHandlerMapping我们简单来看一下源码：

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {

    /**
     * Checks name and aliases of the given bean for URLs, starting with "/".
     */
    @Override
    protected String[] determineUrlsForHandler(String beanName) {
        List<String> urls = new ArrayList<String>();
        if (beanName.startsWith("/")) {
            urls.add(beanName);
        }
        String[] aliases = getApplicationContext().getAliases(beanName);
        for (String alias : aliases) {
            if (alias.startsWith("/")) {
                urls.add(alias);
            }
        }
        return StringUtils.toStringArray(urls);
    }

}

上方BeanNameUrlHandlerMapping类中只有一个方法determineUrlsForHandler()。该方法中把所有以斜杠开头的请求的BeanName都放到了一个名叫urls的List中。然后返回给了中央调度器。但是有一个弊端，比如我有两个请求都由一个Controller来处理，这时我们的springmvc.xml文件的配置方式如下：

<!-- 注册SpringMVC处理器 -->
<bean id="/my.do" class="cn.wechatbao.controller.MyController"></bean>
<bean id="/you.do" class="cn.wechatbao.controller.MyController"></bean>

这样Spring容器在创建MyController实例的时候，一次性创建了两个，而对于我们来说，其实一个实例就可以对两个或多个请求进行处理。所以我们继续来讲解SimpleUrlHandlerMapping方法。

二、处理器映射器（SimpleUrlHandlerMapping）
要使用SimpleUrlHandlerMapping我们需要将其注册到SpringMVC中，如图，我们在默认的处理器映射器中并没有发现该实现类。所以需要注册。

注册方式：（springmvc.xml如下）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!-- 注册视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
    
    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="/my.do">myController</prop>
                <prop key="/you.do">myController</prop>
                <prop key="/he.do">myController</prop>
            </props>
        </property>
        <!-- 
        这种方式也可以实现多个请求交由一个Controller处理的需求
        <property name="urlMap">
            <map>
                <entry key="/my.do" value="myController"></entry>
                <entry key="/you.do" value="myController"></entry>
                <entry key="/he.do" value="myController"></entry>
            </map>
        </property>
         -->
    </bean>
    
    <!-- 注册SpringMVC处理器 -->
    <bean id="myController" class="cn.wechatbao.controller.MyController"></bean>
</beans>

注意：该种配置方式只针对多个请求用一个Controller处理才使用。

三、处理器映射器源码分析
1、当客户端发送请求到达中央调度器（DispatcherServlet）时，DispatcherServlet首先进入到doService方法在doService()方法里，对request设计一些属性，然后又进入到了doDispatch()方法，在doDispatch()方法里，我们着重来看以下代码：

// Determine handler for the current request.
mappedHandler = getHandler(processedRequest);

2、从doDispatch()方法又进入了一个getHandler()的方法，如下

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;
}

在该方法中，使用了一个forEach循环，来循环所有的处理器映射器，根据每个处理器映射器（HandlerMapping）来获取与之对应的处理器执行链（HandlerExecutionChain）。

进入hm.getHandler(request);方法来看。
3、继续hm.getHandler(request);方法

@Override
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);
    }

    HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
    if (CorsUtils.isCorsRequest(request)) {
        CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
        CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
        CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
    }
    return executionChain;
}

4、接下来又走到了HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);这个方法。我们就不继续深究了。有兴趣的朋友可以自己再研究下去。我们得出的结论是经过了一系列的方法，最终返回给中央调度器一个HandlerExecutionChain对象。明白这个我们的目的就已经达到了。