<mvc:annotation-driven />做了什么

<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的，即解决了@Controller注解使用的前提配置。

同时它还提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写
XML的支持（JAXB，读写JSON的支持（Jackson）。我们处理响应ajax请求时，就使用到了对json的支持（配置之后，在加入了
jackson的core和mapper包之后，不写配置文件也能自动转换成json）。

而且，当对action写JUnit单元测试时，要从spring
IOC容器中取DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter
两个bean，来完成测试，取的时候要知道正是<mvc:annotation-driven />这一句注册的这两个bean。

需要注意的是，在spring mvc 3.1以上，DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter对应变更为： 
  DefaultAnnotationHandlerMapping -> RequestMappingHandlerMapping 
  AnnotationMethodHandlerAdapter -> RequestMappingHandlerAdapter 
  AnnotationMethodHandlerExceptionResolver -> ExceptionHandlerExceptionResolver 
  以上都在使用了annotation-driven后自动注册。而且对应分别提供了AbstractHandlerMethodMapping ,
AbstractHandlerMethodAdapter和
AbstractHandlerMethodExceptionResolver以便于让用户更方便的实现自定义的实现类。

通常如果我们希望通过注解的方式来进行Spring
MVC开发，我们都会在***-servlet.xml中加入<mvc:annotation-driven/>标签来告诉Spring我们
的目的，那么这个标签到底做了什么呢，我们先看看它的解析类，我们知道所有的自定义命名空间（像mvc，context等）下的标签解析都是由BeanDefinitionParser接口的子类来完成的，先看图片：

我们看到有多个 AnnotationDrivenBeanDefinitionParser，他们是用来处理不同命名空间下的<annotation- driven/>标签的，我们今天研究的是<mvc:annotation-driven/>标签，所以我们找到对应的实现类 是：org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser。

一、AnnotationDrivenBeanDefinitionParser

通过阅读类注释文档，我们发现这个类主要是用来向工厂中注册了：

RequestMappingHandlerMapping 

BeanNameUrlHandlerMapping

RequestMappingHandlerAdapter

HttpRequestHandlerAdapter

SimpleControllerHandlerAdapter

ExceptionHandlerExceptionResolver 

ResponseStatusExceptionResolver 

DefaultHandlerExceptionResolver 

上面几个Bean实例。这几个类都是用来做什么的呢？
前两个是HandlerMapping接口的实现类，用来处理请求映射的。其中第一个是处理@RequestMapping注解的。第二个会将
controller类的名字映射为请求url。中间三个是用来处理请求的。具体点说就是确定调用哪个controller的哪个方法来处理当前请求。第
一个处理@Controller注解的处理器，支持自定义方法参数和返回值。第二个是处理继承HttpRequestHandler的处理器。第三个处理
继承自Controller接口的处理器。后面三个是用来处理异常的解析器。

二、实现

public BeanDefinition parse(Element element, ParserContext parserContext) {
    Object source = parserContext.extractSource(element);

    CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
    parserContext.pushContainingComponent(compDefinition);

    RuntimeBeanReference contentNegotiationManager = getContentNegotiationManager(element, source, parserContext);

    RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);
    handlerMappingDef.setSource(source);
    handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    handlerMappingDef.getPropertyValues().add("order", 0);
    handlerMappingDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
    String methodMappingName = parserContext.getReaderContext().registerWithGeneratedName(handlerMappingDef);
    if (element.hasAttribute("enableMatrixVariables")) {
        Boolean enableMatrixVariables = Boolean.valueOf(element.getAttribute("enableMatrixVariables"));
        handlerMappingDef.getPropertyValues().add("removeSemicolonContent", !enableMatrixVariables);
    }

    RuntimeBeanReference conversionService = getConversionService(element, source, parserContext);
    RuntimeBeanReference validator = getValidator(element, source, parserContext);
    RuntimeBeanReference messageCodesResolver = getMessageCodesResolver(element, source, parserContext);

    RootBeanDefinition bindingDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
    bindingDef.setSource(source);
    bindingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    bindingDef.getPropertyValues().add("conversionService", conversionService);
    bindingDef.getPropertyValues().add("validator", validator);
    bindingDef.getPropertyValues().add("messageCodesResolver", messageCodesResolver);

    ManagedList<?> messageConverters = getMessageConverters(element, source, parserContext);
    ManagedList<?> argumentResolvers = getArgumentResolvers(element, source, parserContext);
    ManagedList<?> returnValueHandlers = getReturnValueHandlers(element, source, parserContext);
    String asyncTimeout = getAsyncTimeout(element, source, parserContext);
    RuntimeBeanReference asyncExecutor = getAsyncExecutor(element, source, parserContext);
    ManagedList<?> callableInterceptors = getCallableInterceptors(element, source, parserContext);
    ManagedList<?> deferredResultInterceptors = getDeferredResultInterceptors(element, source, parserContext);

    RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
    handlerAdapterDef.setSource(source);
    handlerAdapterDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    handlerAdapterDef.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
    handlerAdapterDef.getPropertyValues().add("webBindingInitializer", bindingDef);
    handlerAdapterDef.getPropertyValues().add("messageConverters", messageConverters);
    if (element.hasAttribute("ignoreDefaultModelOnRedirect")) {
        Boolean ignoreDefaultModel = Boolean.valueOf(element.getAttribute("ignoreDefaultModelOnRedirect"));
        handlerAdapterDef.getPropertyValues().add("ignoreDefaultModelOnRedirect", ignoreDefaultModel);
    }
    if (argumentResolvers != null) {
        handlerAdapterDef.getPropertyValues().add("customArgumentResolvers", argumentResolvers);
    }
    if (returnValueHandlers != null) {
        handlerAdapterDef.getPropertyValues().add("customReturnValueHandlers", returnValueHandlers);
    }
    if (asyncTimeout != null) {
        handlerAdapterDef.getPropertyValues().add("asyncRequestTimeout", asyncTimeout);
    }
    if (asyncExecutor != null) {
        handlerAdapterDef.getPropertyValues().add("taskExecutor", asyncExecutor);
    }
    handlerAdapterDef.getPropertyValues().add("callableInterceptors", callableInterceptors);
    handlerAdapterDef.getPropertyValues().add("deferredResultInterceptors", deferredResultInterceptors);
    String handlerAdapterName = parserContext.getReaderContext().registerWithGeneratedName(handlerAdapterDef);

    RootBeanDefinition csInterceptorDef = new RootBeanDefinition(ConversionServiceExposingInterceptor.class);
    csInterceptorDef.setSource(source);
    csInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, conversionService);
    RootBeanDefinition mappedCsInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);
    mappedCsInterceptorDef.setSource(source);
    mappedCsInterceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    mappedCsInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, (Object) null);
    mappedCsInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, csInterceptorDef);
    String mappedInterceptorName = parserContext.getReaderContext().registerWithGeneratedName(mappedCsInterceptorDef);

    RootBeanDefinition exceptionHandlerExceptionResolver = new RootBeanDefinition(ExceptionHandlerExceptionResolver.class);
    exceptionHandlerExceptionResolver.setSource(source);
    exceptionHandlerExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    exceptionHandlerExceptionResolver.getPropertyValues().add("contentNegotiationManager", contentNegotiationManager);
    exceptionHandlerExceptionResolver.getPropertyValues().add("messageConverters", messageConverters);
    exceptionHandlerExceptionResolver.getPropertyValues().add("order", 0);
    String methodExceptionResolverName =
            parserContext.getReaderContext().registerWithGeneratedName(exceptionHandlerExceptionResolver);

    RootBeanDefinition responseStatusExceptionResolver = new RootBeanDefinition(ResponseStatusExceptionResolver.class);
    responseStatusExceptionResolver.setSource(source);
    responseStatusExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    responseStatusExceptionResolver.getPropertyValues().add("order", 1);
    String responseStatusExceptionResolverName =
            parserContext.getReaderContext().registerWithGeneratedName(responseStatusExceptionResolver);

    RootBeanDefinition defaultExceptionResolver = new RootBeanDefinition(DefaultHandlerExceptionResolver.class);
    defaultExceptionResolver.setSource(source);
    defaultExceptionResolver.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    defaultExceptionResolver.getPropertyValues().add("order", 2);
    String defaultExceptionResolverName =
            parserContext.getReaderContext().registerWithGeneratedName(defaultExceptionResolver);

    parserContext.registerComponent(new BeanComponentDefinition(handlerMappingDef, methodMappingName));
    parserContext.registerComponent(new BeanComponentDefinition(handlerAdapterDef, handlerAdapterName));
    parserContext.registerComponent(new BeanComponentDefinition(exceptionHandlerExceptionResolver, methodExceptionResolverName));
    parserContext.registerComponent(new BeanComponentDefinition(responseStatusExceptionResolver, responseStatusExceptionResolverName));
    parserContext.registerComponent(new BeanComponentDefinition(defaultExceptionResolver, defaultExceptionResolverName));
    parserContext.registerComponent(new BeanComponentDefinition(mappedCsInterceptorDef, mappedInterceptorName));

    // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"
    MvcNamespaceUtils.registerDefaultComponents(parserContext, source);

    parserContext.popAndRegisterContainingComponent();

    return null;
}

abstract class MvcNamespaceUtils {

    private static final String BEAN_NAME_URL_HANDLER_MAPPING_BEAN_NAME =
            BeanNameUrlHandlerMapping.class.getName();

    private static final String SIMPLE_CONTROLLER_HANDLER_ADAPTER_BEAN_NAME =
            SimpleControllerHandlerAdapter.class.getName();

    private static final String HTTP_REQUEST_HANDLER_ADAPTER_BEAN_NAME =
            HttpRequestHandlerAdapter.class.getName();

    public static void registerDefaultComponents(ParserContext parserContext, Object source) {
        registerBeanNameUrlHandlerMapping(parserContext, source);
        registerHttpRequestHandlerAdapter(parserContext, source);
        registerSimpleControllerHandlerAdapter(parserContext, source);
    }

    /**
     * Registers  an {@link HttpRequestHandlerAdapter} under a well-known
     * name unless already registered.
     */
    private static void registerBeanNameUrlHandlerMapping(ParserContext parserContext, Object source) {
        if (!parserContext.getRegistry().containsBeanDefinition(BEAN_NAME_URL_HANDLER_MAPPING_BEAN_NAME)){
            RootBeanDefinition beanNameMappingDef = new RootBeanDefinition(BeanNameUrlHandlerMapping.class);
            beanNameMappingDef.setSource(source);
            beanNameMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanNameMappingDef.getPropertyValues().add("order", 2);    // consistent with WebMvcConfigurationSupport
            parserContext.getRegistry().registerBeanDefinition(BEAN_NAME_URL_HANDLER_MAPPING_BEAN_NAME, beanNameMappingDef);
            parserContext.registerComponent(new BeanComponentDefinition(beanNameMappingDef, BEAN_NAME_URL_HANDLER_MAPPING_BEAN_NAME));
        }
    }

    /**
     * Registers  an {@link HttpRequestHandlerAdapter} under a well-known
     * name unless already registered.
     */
    private static void registerHttpRequestHandlerAdapter(ParserContext parserContext, Object source) {
        if (!parserContext.getRegistry().containsBeanDefinition(HTTP_REQUEST_HANDLER_ADAPTER_BEAN_NAME)) {
            RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(HttpRequestHandlerAdapter.class);
            handlerAdapterDef.setSource(source);
            handlerAdapterDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            parserContext.getRegistry().registerBeanDefinition(HTTP_REQUEST_HANDLER_ADAPTER_BEAN_NAME, handlerAdapterDef);
            parserContext.registerComponent(new BeanComponentDefinition(handlerAdapterDef, HTTP_REQUEST_HANDLER_ADAPTER_BEAN_NAME));
        }
    }

    /**
     * Registers a {@link SimpleControllerHandlerAdapter} under a well-known
     * name unless already registered.
     */
    private static void registerSimpleControllerHandlerAdapter(ParserContext parserContext, Object source) {
        if (!parserContext.getRegistry().containsBeanDefinition(SIMPLE_CONTROLLER_HANDLER_ADAPTER_BEAN_NAME)) {
            RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(SimpleControllerHandlerAdapter.class);
            handlerAdapterDef.setSource(source);
            handlerAdapterDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            parserContext.getRegistry().registerBeanDefinition(SIMPLE_CONTROLLER_HANDLER_ADAPTER_BEAN_NAME, handlerAdapterDef);
            parserContext.registerComponent(new BeanComponentDefinition(handlerAdapterDef, SIMPLE_CONTROLLER_HANDLER_ADAPTER_BEAN_NAME));
        }
    }

}

我们知道了它们自动为我们注册了这么多的Bean，那这些Bean是做什么的呢？
  最重要的就是RequestMappingHandlerMapping和RequestMappingHandlerAdapter。
  第一个是HandlerMapping的实现类，它会处理@RequestMapping 注解，并将其注册到请求映射表中。
  第二个是HandlerAdapter的实现类，它是处理请求的适配器，说白了，就是确定调用哪个类的哪个方法，并且构造方法参数，返回值。

三、小结

看了上面那些,我们再来归纳一下：
1、Spring是怎么解析<mvc:annotation-driven/>标签的？
首先,必须要有一个继承自"org.springframework.beans.factory.xml.NamespaceHandlerSupport"的类,在其init方法中,注册自己的解析器,注册mvc解析器的类为MvcNamespaceHandler。一般针对每个元素,都有一个解析器,比如：针对annotation-driven,就有一个解析器：就是前面提到的AnnotationDrivenBeanDefinitionParser。
解析器必须实现org.springframework.beans.factory.xml.BeanDefinitionParser接口,这个接口只有一个parse方法,它有两个参数,第一个参数org.w3c.dom.Element就是我们在xml文件中声明的<mvc:annotation-driven/>结点,拿到这个结点信息,就可以开始具体的业务了。
2、Spring怎么知道处理mvc开头的标签就调用MvcNamespaceHandler中注册的解析器的呢？
这需要有一个"mvc"<–>MvcNamespaceHandler这样一个映射关系,那么这个映射关系在哪里呢？就在META-INF目录下的spring.handlers:源文件中的内容：

http://www.springframework.org/schema/mvc= org.springframework.web.servlet.config.MvcNamespaceHandler  

这里定义了只要是http\://www.springframework.org/schema/mvc命名空间的标签，就使用org.springframework.web.servlet.config.MvcNamespaceHandler中的解析器。
头文件里说的http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd，并不是真的到网上去下载这个文件，在spring.schemas文件中，定义了它指向org/springframework/web/servlet/config/spring-mvc-3.1.xsd这个文件（在jar包里）。
所以，在Spring中，想使用自己的命名空间：
1、首先需要一个xsd文件，来描述自定义元素的命名规则，并在再Spring的配置文件的<benas>头中引用它。
2、然后需要实现一个BeanDefinitionParser接口，在接口的parse方法中，解析将来在Spring配置文件中出现的元素。（如果xsd声明可以有多个元素，需呀实现多个BeanDefinitionParser接口）
3、最后需要继承一个NamespaceHandlerSupport类，在它的init方法中，调用registerBeanDefinitionParser方法，将待解析的xml元素与解析器绑定。
4、在META-INF目录下，创建spring.schemas、spring.handlers文件，建立最高级的映射关系以便Spring进行处理。

四、与<context:component-scan/>的区别
<context:component-scan/>标签是告诉Spring 来扫描指定包下的类，并注册被@Component，@Controller，@Service，@Repository等注解标记的组件。
而<mvc:annotation-scan/>是告知Spring，我们启用注解驱动。然后Spring会自动为我们注册上面说到的几个Bean到工厂中，来处理我们的请求。
五、与<context:annotation-config/>的区别
当我们需要使用注解模式时，直接在Spring配置文件中定义这些Bean显得比较笨拙，例如：
使用@Autowired注解，必须事先在Spring容器中声明AutowiredAnnotationBeanPostProcessor的Bean：

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor "/>  

使用 @Required注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean：

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor"/>

简单的说，用什么注解，就需要声明对应的BeanPostProcessor。这样的声明未免太不优雅，而Spring为我们提供了一种极为方便注册这些BeanPostProcessor的方式，即使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。
另外，在我们使用注解时一般都会配置扫描包路径选项，即<context:component-scan/>。该配置项其实也包含了自动注入上述processor的功能，因此当使用<context:component-scan/>后，即可将<context:annotation-config/>省去，但必须要配置全！以防万一，还是同时声明的好。