I am trying to understand the difference here. I see that a class has been annotated with both of them with same package example :
@Configuration @EntityScan("some.known.persistence") @ComponentScan({ "some.known.persistence"}) public class ApiConfig { }
I understand the differences from API docs but want to understand in detail. Also does it mean that anything that is scanned by @ComponentScan
is having wider visibility wrt Spring context and @EntityScan
does not. If so using some attribute with @ComponentScan
should have sufficed the need to bind in a JPA context, isn't it?
The @ComponentScan annotation is used with the @Configuration annotation to tell Spring the packages to scan for annotated components. @ComponentScan also used to specify base packages and base package classes using thebasePackageClasses or basePackages attributes of @ComponentScan.
Spring Boot @SpringBootApplication annotation is used to mark a configuration class that declares one or more @Bean methods and also triggers auto-configuration and component scanning. It's same as declaring a class with @Configuration, @EnableAutoConfiguration and @ComponentScan annotations.
The @EnableJpaRepositories annotation is used to create repository classes from Spring Data interfaces. All three annotation are often used together, but they are responsible for different things.
The @EnableAutoConfiguration annotation enables Spring Boot to auto-configure the application context. Therefore, it automatically creates and registers beans based on both the included jar files in the classpath and the beans defined by us.
The @ComponentScan
annotation is used to automatically create beans for every class annotated with @Component
, @Service
, @Controller
, @RestController
, @Repository
, ... and adds them to the Spring container (allowing them to be @Autowired
).
The @EntityScan
on the other hand does not create beans as far as I know. It only identifies which classes should be used by a specific persistence context. Since Spring boot 1.4 that includes JPA, MongoDB, neo4j, Cassandra and CouchBase.
Why they're not merged? Well, I'm not on the Spring team, but since they have different meanings, why should they be merged? The @EntityScan
should mainly be used to scan your entity packages, while the @ComponentScan
should scan all packages that contain Spring beans, so the following is very likely:
@ComponentScan("org.example.base") @EntityScan("org.example.base.entities") public class MyConfig { }
We can also use @EntityScan
to define some Entities form external jar.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With