Difference between vs

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.