<mvc:annotation-driven />做了什么
2017-08-14 15:44
309 查看
<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
通过阅读类注释文档,我们发现这个类主要是用来向工厂中注册了:
上面几个Bean实例。这几个类都是用来做什么的呢?
前两个是HandlerMapping接口的实现类,用来处理请求映射的。其中第一个是处理@RequestMapping注解的。第二个会将
controller类的名字映射为请求url。中间三个是用来处理请求的。具体点说就是确定调用哪个controller的哪个方法来处理当前请求。第
一个处理@Controller注解的处理器,支持自定义方法参数和返回值。第二个是处理继承HttpRequestHandler的处理器。第三个处理
继承自Controller接口的处理器。后面三个是用来处理异常的解析器。
二、实现
我们知道了它们自动为我们注册了这么多的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/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:
使用 @Required注解,就必须声明RequiredAnnotationBeanPostProcessor的Bean:
简单的说,用什么注解,就需要声明对应的BeanPostProcessor。这样的声明未免太不优雅,而Spring为我们提供了一种极为方便注册这些BeanPostProcessor的方式,即使用<context:annotation- config/>隐式地向 Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。
另外,在我们使用注解时一般都会配置扫描包路径选项,即<context:component-scan/>。该配置项其实也包含了自动注入上述processor的功能,因此当使用<context:component-scan/>后,即可将<context:annotation-config/>省去,但必须要配置全!以防万一,还是同时声明的好。
同时它还提供了:数据绑定支持,@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/>省去,但必须要配置全!以防万一,还是同时声明的好。
相关文章推荐
- Spring MVC 教程,快速入门,深入分析――<mvc:annotation-driven /> 到底做了什么工作
- <mvc:annotation-driven/>做了些什么,默认配置
- <mvc:annotation-driven >和<context:component-scan>
- <mvc:annotation-driven />注解意义
- spring mvc拦截器和<mvc:annotation-driven />的详解
- <mvc:annotation-driven />与<context:annotation-config />
- <mvc:annotation-driven />注解意义
- SpringMVC 【<mvc:annotation-driven />】 到底做了什么工作
- <mvc:annotation-driven>和<context:annotation-config>
- <mvc:annotation-driven/> <context:annotation-config/> <context:component-scan>
- Spring <context:component-scan/>与<mvc:annotation-driven/>
- Spring <context:annotation-config/> <context:component-scan/>与<mvc:annotation-driven />
- <context:annotation-config/>,<mvc:annotation-driven/>和<context:component-scan>之间的关系
- <mvc:annotation-driven>新增标签
- <mvc:annotation-driven/>的作用
- <context:component-scan/> <mvc:annotation-driven /> 区别
- <mvc:annotation-driven />真的强
- Spring MVC学习-----------<mvc:annotation-driven /> 到底做了什么工作
- SpringMVC系列(十)<mvc:default-servlet-handler/>(处理静态资源)和<mvc:annotation-driven />
- <mvc:annotation-driven/>注解意义