Spring MVC 解读——<mvc:annotation-driven/>（剖析的比较的详细）

最新推荐文章于 2025-05-12 11:33:19 发布
转载 最新推荐文章于 2025-05-12 11:33:19 发布 · 1.3k 阅读 · 0
文章标签：

#Spring mvc #标签 #配置文件

本文深入解读了SpringMVC中@annotation-driven标签的作用，包括其内部实现机制以及如何自动注册关键Bean以处理请求。重点介绍了RequestMappingHandlerMapping和RequestMappingHandlerAdapter的作用，与<context:component-scan>标签的区别，并详细展示了代码实现过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring MVC 解读——<mvc:annotation-driven/>

摘要  <mvc:annotation-driven/>是做什么的？它做了什么？它与<context:component-scan/>有什么区别？

Spring MVC 解读——<mvc:annotation-driven/>

一、AnnotationDrivenBeanDefinitionParser

    通常如果我们希望通过注解的方式来进行Spring MVC开发，我们都会在***-servlet.xml中加入<mvc:annotation-driven/>标签来告诉Spring我们的目的。但是我们为什么这么做呢？这个标签是什么意思呢？它做了什么呢？

    同样为了弄清楚这些问题， 像<context:component-scan/>标签一样，我们先找到它的解析类。第一篇文章中说过了，所有的自定义命名空间（像mvc，context等）下的标签解析都是由BeanDefinitionParser接口的子类来完成的。参看第一篇文章中的图片

我们看到有多个AnnotationDrivenBeanDefinitionParser，他们是用来处理不同命名空间下的<annotation-driven/>标签的，我们今天研究的是<mvc:annotation-driven/>标签，所以我们找到对应的实现类是org.springframework.web.servlet.config.AnnotationDrivenBeanDefinitionParser。
    通过阅读类注释文档，我们发现这个类主要是用来向工厂中注册了

    上面几个Bean实例。这几个类都是用来做什么的呢？

    前两个是HandlerMapping接口的实现类，用来处理请求映射的。其中第一个是处理@RequestMapping注解的。第二个会将controller类的名字映射为请求url。

    中间三个是用来处理请求的。具体点说就是确定调用哪个controller的哪个方法来处理当前请求。第一个处理@Controller注解的处理器，支持自定义方法参数和返回值（很酷）。第二个是处理继承HttpRequestHandler的处理器。第三个处理继承自Controller接口的处理器。

    后面三个是用来处理异常的解析器。

二、实现

    光说无凭据，我们直接看代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
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);
         //第一个在这 RequestMappingHandlerMapping
         RootBeanDefinition handlerMappingDef =  new  RootBeanDefinition(RequestMappingHandlerMapping. class );
         handlerMappingDef.setSource(source);
         handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
         handlerMappingDef.getPropertyValues().add( "order" ,  0 );
         handlerMappingDef.getPropertyValues().add( "removeSemicolonContent" ,  false );
         handlerMappingDef.getPropertyValues().add( "contentNegotiationManager" , contentNegotiationManager);
         String methodMappingName = parserContext.getReaderContext().registerWithGeneratedName(handlerMappingDef);
         //第二个在这 RequestMappingHandlerAdapter
         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 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));
         //这里注册了BeanNameUrlHandlerMapping，SimpleControllerHandlerAdapter等
         // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"
         MvcNamespaceUtils.registerDefaultComponents(parserContext, source);
 
         parserContext.popAndRegisterContainingComponent();
 
         return  null ;
     }
//在这啊。
public  static  void  registerDefaultComponents(ParserContext parserContext, Object source) {
         registerBeanNameUrlHandlerMapping(parserContext, source);
         registerHttpRequestHandlerAdapter(parserContext, source);
         registerSimpleControllerHandlerAdapter(parserContext, source);
     }

    略长，但很容易看明白的代码。看注释我们发现，它的确注册了上面说的那几个类。

三、总结

    我们知道了它们自动为我们注册了这么多的Bean，那这些Bean是做什么的呢？

    我们主要说明里面的两个，RequestMappingHandlerMapping和RequestMappingHandlerAdapter。

    第一个是HandlerMapping的实现类，它会处理@RequestMapping 注解，并将其注册到请求映射表中。（下片文章我们会详细介绍的）

    第二个是HandlerAdapter的实现类，它是处理请求的适配器，说白了，就是确定调用哪个类的哪个方法，并且构造方法参数，返回值。（后面文章也会陆续详细介绍的）

    那么它跟<context:component-scan/>有什么区别呢？其实想上篇文章中介绍的，<context:component-scan/>标签是告诉Spring 来扫描指定包下的类，并注册被@Component，@Controller，@Service，@Repository等注解标记的组件。

    而<mvc:annotation-scan/>是告知Spring，我们启用注解驱动。然后Spring会自动为我们注册上面说到的几个Bean到工厂中，来处理我们的请求。

转自：http://my.oschina.net/HeliosFly/blog/205343

SpringMVC(8)——注解配置SpringMVC、SpringMVC汇总、＜mvc:annotation-driven＞作用
zjr_java的博客
03-28 669
同时它还提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，@Valid支持，读写XML的支持（JAXB，读写JSON的支持（Jackson）。我们处理响应ajax请求时，就使用到了对json的支持（配置之后，在加入了jackson的core和mapper包之后，不写配置文件也能自动转换成json，之前在别的章节就演示过了）通过源码分析DispatcherServlet调用各个组件处理请求的过程。说明：不演示文件上传是否实现。
Spring MVC 解读——<mvc:annotation-driven/>
weixin_34203426的博客
03-05 302
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring MVC 中关于 mvc:annotation-driven
杜鲁门的博客
11-12 928
<mvc:annotation-driven/>会自动注册RequestMappingHandlerMapping、 RequestMappingHandlerAdapter与ExceptionHandlerExceptionResolver三个benn。还提供一下支持： 支持使用ConversionService 实例对表单参数进行类型转换 支持使用@NumberFormat annotatio
掌握SpringMVC：深入理解＜mvc:annotation-driven/＞
weixin_29155599的博客
05-12 764
在传统的Spring MVC应用中，控制器通常由一系列的Bean来实现，每个Bean中包含多个方法，这些方法通过URL映射与前端请求关联。尽管这种方式在实现上具有一定的灵活性，但对于简单的CRUD操作来说，代码往往显得冗长且重复。例如，每个方法都要从请求中提取参数、设置响应类型，最后返回视图或数据，这在一定程度上增加了开发者的负担。注解驱动的控制器使用一系列的注解（如等）来直接声明方法映射，参数绑定，以及返回类型，大幅简化了控制器的代码。
Spring MVC之<mvc:annotation-driven/>
yanguo110的博客
10-08 831
整理文章:http://blog.youkuaiyun.com/sjjsh2/article/details/53100728  一、简短的介绍     是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean
SpringMVC的<mvc:annotation-driven />
qq_29860591的博客
04-09 1393
<mvc:annotation-driven />配置在什么时候必须配置？ ① 直接配置响应的页面：无需经过控制器来执行结果 ；但会导致其他请求路径失效，需要配置mvc:annotation-driven标签 <mvc:view-controller path="/success" view-name="success"/> ② RESTful-CRUD操作...
Spring mvc:annotation-driven
天下无双
02-12 791
如果在spring-mvc。xml文件中配置了mvc:annotation-driven 那么服务器启动的时候会创建一个 RequestMappingHandlerAdapter对象 RequestResponseBodyMethodProcessor @Configuration public class WebMvcConfiguration extends WebMvcCo
拦截器与冲突解决
08-05
1. **配置顺序**：Spring MVC按照注册拦截器的顺序执行它们，如果`<mvc:annotation-driven />`配置在拦截器之后，那么可能会导致拦截器无法正常工作，因为Spring可能已经处理了请求，而没有交给拦截器。 2. **命名...
解决拦截器与<mvc:annotation-driven />配置冲突的方法
在Spring MVC中，`<mvc:annotation-driven />`是MVC配置中的一个重要标签，它帮助开发者自动注册一些默认的组件，如处理器映射器（HandlerMapping）、处理器适配器（HandlerAdapter）、视图解析器（ViewResolver）等...
深入解析SpringMVC中的<mvc:annotation-driven/>配置
资源摘要信息:"本讲主要讨论了SpringMVC框架中的<mvc:annotation-driven/>元素，这是Spring MVC 3.1版本中引入的一个重要功能。它主要用于简化和自动配置Spring MVC框架中的一些默认行为。 首先，我们需要了解，...
<?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: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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"> <!-- 明确指定只扫描Controller --> <context:component-scan base-package="com.itheihei" use-default-filters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/"/> <property name="suffix" value=".jsp"/> </bean> <mvc:resources mapping="/js/**" location="/js/"/> <mvc:resources mapping="/images/**" location="/images/"/> <mvc:resources mapping="/css/**" location="/css/"/> <mvc:annotation-driven/> </beans><?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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!-- 排除Controller，只扫描Service/Repository等 --> <context:component-scan base-package="com.itheihei"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> </beans>@Controller public class AccountController { @Autowired AccountService accountService; @RequestMapping("findAllAccounts") public String findAllAccounts() { System.out.println("方法成功执行"); return "list"; } } <%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>首页</title> </head> <body> <a href="${pageContext.request.contextPath}/findAllAccounts">查看所有用户信息</a> </body> </html><?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <servlet> <servlet-name>dispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcherServlet</servlet-name> <url-pattern>/</url-pattern> <!-- 将所有请求映射到 dispatcherServlet --> </servlet-mapping> </web-app>为什么会404
最新发布
05-14
<think>好的，我现在需要解决用户在Spring MVC配置中遇到的404错误问题，用户提到了context:component-scan、viewResolver和mvc:annotation-driven这几个配置点。首先，我得回忆一下这些组件的作用以及它们如何影响...
SpringMVC源码总结（三）mvc:annotation-driven和mvc:message-converters简单介绍
08-07
NULL 博文链接：https://lgbolgger.iteye.com/blog/2105151
SpringMVC源码研究之注解mvc:annotation-driven
夫礼者的专栏
10-04 2628
Spring-MVC注解 1. 前言 通过查看 spring-webmvc-xxx.jar 下的spring.handlers文件可以发现 mvc前缀的标签都是由 MvcNamespaceHandler 来进行解析的。 通过查看其内部唯一的方法 init() 的实现可以确定 的解析工作是由 AnnotationDrivenBeanDefinitionParser 类全权负责的。
springmvc- mvc:annotation-driven的作用
shelbaydo的博客
03-03 276
SpringMVC 解读——<mvc:annotation-driven/>
Franco的博客
11-01 798
一、AnnotationDrivenBeanDefinitionParser     通常如果我们希望通过注解的方式来进行SpringMVC开发，我们都会在***-servlet.xml中加入标签来告诉Spring我们的目的。但是我们为什么这么做呢？这个标签是什么意思呢？它做了什么呢？     同样为了弄清楚这些问题， 像标签一样，我们先找到它的解析类。第一篇文章中说过了，所有的自
SpringMvc之 mvc:annotation-driven标签
qq_33028695的博客
10-07 847
在我们要完成比较复杂的数据类型转换时（比如：页面输入的String类型转换成Date类型，将页面的String类型转换成封装成一个对象时）需要在SpringMvc的配置文件中添加&lt;mvc:annotation-driven/&gt;标签。      那&lt;mvc:annotation-driven/&gt;标签的作用是什么呢？     作用1： 在SpringMvc配置文件中，使用&...
Spring MVC标签<mvc: annotation-driven />小结
weixin_33912638的博客
04-17 137
2019独角兽企业重金招聘Python工程师标准>>> ...
菜鸟之路——Spring MVC（十二） mvc:annotation-driven做了什么
热门推荐
sjjsh2的博客
11-09 2万+
<mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。<mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MV...
<mvc:annotation-driven />讲解
yinbucheng的博客
05-21 1029
是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的。 并提供了：数据绑定支持，@NumberFormatannotation支持，@Date
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值