1. Introduction
When writing our Spring application we might need to specify a certain list of packages that contain our entity classes. Similarly, at some point, we would need only a specific list of our Spring beans to be initialized. This is where we can make use of @EntityScan or @ComponentScan annotations.
To clarify the terms we use here, components are classes with @Controller, @Service, @Repository, @Component, @Bean, etc. annotations. Entities are classes marked with @Entity annotation.
In this short tutorial, we’ll discuss the usage of @EntityScan and @ComponentScan in Spring, explain what are they used for, and then point out their differences.
2. The @EntityScan Annotation
When writing our Spring application we will usually have entity classes – those annotated with @Entity annotation. We can consider two approaches to placing our entity classes:
- Under the application main package or its sub-packages
- Use a completely different root package
In the first scenario, we could use @EnableAutoConfiguration to enable Spring to auto-configure the application context.
In the second scenario, we would provide our application with the information where these packages could be found. For this purpose, we would use @EntityScan.
@EntityScan annotation is used when entity classes are not placed in the main application package or its sub-packages. In this situation, we would declare the package or list of packages in the main configuration class within @EntityScan annotation. This will tell Spring where to find entities used in our application:
@Configuration
@EntityScan("com.baeldung.demopackage")
public class EntityScanDemo {
// ...
}
We should be aware that using @EntityScan will disable Spring Boot auto-configuration scanning for entities.
3. @ComponentScan Annotation
Similar to @EntityScan and entities, if we want Spring to use only a specific set of bean classes, we would use @ComponentScan annotation. It’ll point to the specific location of bean classes we would want Spring to initialize.
This annotation could be used with or without parameters. Without parameters, Spring will scan the current package and its sub-packages, while, when parameterized, it’ll tell Spring where exactly to search for packages.
Concerning parameters, we can provide a list of packages to be scanned (using basePackages parameter) or we can name specific classes where packages they belong to will also be scanned (using basePackageClasses parameter).
Let’s see an example of @ComponentScan annotation usage:
@Configuration
@ComponentScan(
basePackages = {"com.baeldung.demopackage"},
basePackageClasses = DemoBean.class)
public class ComponentScanExample {
// ...
}
4. @EntityScan vs. @ComponentScan
In the end, we can say that these two annotations are intended for completely different purposes.
Their similarity is that they both contribute to our Spring application configuration. @EntityScan should specify which packages do we want to scan for entity classes. On the other hand, @ComponentScan is a choice when specifying which packages should be scanned for Spring beans.
5. Conclusion
In this short tutorial, we discussed the usage of @EntityScan and @ComponentScan annotations and also pointed to their differences.
