spring-contextannotation-contextcomponentscan

Posted on: 2019-10-08 2019-10-08
Tags: Spring

Difference between <context:annotation-config> vs <context:component-scan>

Spring

1. Overview

In this tutorial, we’re going to learn about the differences between two
major XML configuration elements of
Spring: <context:annotation-config> and <context:component-scan>.

2. Bean Definitions

As we all know, Spring provides us with two ways to define our
beans and dependencies:
XML configuration and
Java annotations. We can also categorize Spring’s annotations under two
groups: dependency
injection annotations and
bean annotations.

Prior to annotations, we had to manually define all our beans and
dependencies in XML configuration files. Now thanks to Spring’s
annotations, it can automatically discover and wire all our beans and
dependencies for us. So, we can at least eliminate the XML needed for
beans and dependencies.

However, we should remember that annotations are useless unless we
activate them. In order to activate them, we can add either
<context:annotation-config> or <context:component-scan> on top of
our XML file.

In this section, we’ll see how <context:annotation-config>
and <context:component-scan> differ from each other in terms of their
ways of activating annotations.

3. Annotation Activation by <context:annotation-config>

The <context:annotation-config> annotation is mainly used to activate
the dependency injection
annotations. @Autowired,
@Qualifier, @PostConstruct,
@PreDestroy,
and
@Resource
are some of the ones that <context:annotation-config> can resolve.

Let’s make a simple example to see how <context:annotation-config> can
simplify the XML configuration for us.

First, let’s create a class with a dependency field:

public class UserService {
    @Autowired
    private AccountService accountService;
}

public class AccountService {}

Now, let’s define our beans.

<bean id="accountService" class="AccountService"></bean>

<bean id="userService" class="UserService"></bean>

Before going further let’s point out that we still need to declare beans
in the XML. That is because <context:annotation-config> activates
the annotations only for the beans already registered in the application
context.

As can be seen here, we annotated the accountService field
using @Autowired. @Autowired tells Spring that this field is a
dependency that needs to be automatically wired by a matching bean.

If we didn’t use @Autowired, then we would need to set the
accountService dependency manually:

<bean id="userService" class="UserService">
    <property name="accountService" ref="accountService"></property>
</bean>

Now, we can refer to our beans and dependencies in a unit test:

@Test
public void givenContextAnnotationConfig_whenDependenciesAnnotated_thenNoXMLNeeded() {
    ApplicationContext context
      = new ClassPathXmlApplicationContext("classpath:annotationconfigvscomponentscan-beans.xml");

    UserService userService = context.getBean(UserService.class);
    AccountService accountService = context.getBean(AccountService.class);

    Assert.assertNotNull(userService);
    Assert.assertNotNull(accountService);
    Assert.assertNotNull(userService.getAccountService());
}

Hmm, something is wrong here. It looks like Spring isn’t wiring the
accountService even though we annotated it by @Autowired. It looks
like @Autowired is not active. In order to solve this issue, we’ll
simply add the following line on top of our XML file:

<context:annotation-config/>

4. Annotation Activation by <context:component-scan>

As similar to <context:annotation-config>, <context:component-scan>
can recognize and process the dependency injection annotations too.
Moreover, <context:component-scan> recognizes bean annotations that
<context:annotation-config> doesn’t detect.

Basically, <context:component-scan> detects the annotations by
package scanning. To put it differently, it tells Spring which packages
need to be scanned to look for the annotated beans or components.

@Component, @Repository,
@Service,
@Controller,
@RestController,
and @Configuration are
several ones that <context:component-scan> can detect.

Now let’s see how we can simplify our previous example:

@Component
public class UserService {
    @Autowired
    private AccountService accountService;
}

@Component
public class AccountService {}

Here, the @Component annotation marks our classes as beans. Now, we
can clean out all the bean definitions from our XML file. And of course,
we need to keep the <context:component-scan> on top of it:

<context:component-scan
  base-package="com.baeldung.annotationconfigvscomponentscan.components" />

Finally, let’s note that Spring will look for the annotated beans and
dependencies under the package indicated by the base-package
attribute.

5. Conclusion

In this tutorial, we looked through the differences between
<context:annotation-config> and <context:component-scan>.

Code samples, as always, are
over on
GitHub.

getdocs

3043