Spring support for @Controller given by vs

Question

I\'ve been researching what additional capabilities we have when using the mvc:annotation-driven tag and I\'m having a difficult time digesting the results, especially in re

Answer 1

The context:component-scan element lists a package that Spring should scan for @Controller annotations (in the base-package attribute).

the mvc:annotation-driven has no such attribute. This is a convenience element that installs a lot of default MVC elements into the application context. These elements are listed in section 16.14.1 of the Spring framework reference. This element does not appear to scan for @Controller annotations.

Contrary to popular belief, there is no dependancy between these elements. An @Controller without mvc:annotation-driven will function without an issue and handle HTTP requests just fine, as long as you have included context:component-scan with an appropriate base-package attribute.

Answer 2

• Case 1(annotation-driven)

  This is Enabling Spring annotations tag. All the annotations such as @Controller, @Service, @Autowired etc.. can be used. This doesn't creates a bean, but find the the annotations, and spring creates corresponding bean for that class if found annotation(such as @Controller, @Service, @Autowired etc..) .
  
  

• Case 2(component-scan)

  Spring will scan the package (and subpackages) of the classes specified in declaration and creates bean for it.

Answer 3

Both elements serve an entirely different purpose.

<context:component-scan /> is, as the name implies, for component scanning. It by default scans for all beans with the @Component annotation (or "sub"annotations like @Controller, @Service etc.). It will only register instances of those classes in the application context as beans. That is all.

<mvc:annotation-driven /> is for bootstrapping Spring MVC and it registers, amongst others, a RequestMappingHandlerMapping and RequestMappingHandlerAdapter. The first links requests to a certain method (the @RequestMapping annotation on methods in a @Controller annotated class). The last knows how to execute methods annotated with @RequestMaping.

Now <mvc:annotation-driven /> does nothing for scanning or detecting @Controllers if there are none in the application context then no request mappings are made. Now you have several ways of registering those beans in the application context and one of them is the aforementioned <context:component-scan />.

Basically a @Controller without <mvc:annotation-driven /> is, well, pretty useless as it does nothing but take up memory. It will not be bound to incoming requests, it just hangs around in the application context. It is just another bean like all other beans and nothing special is being done to it. (Recent, but deprecated, versions of Spring register the DefaultAnnotationHandlerMapping which processes the @Controller, this is however deprecated).