{"id":3942,"date":"2017-11-30T05:34:11","date_gmt":"2017-11-30T10:34:11","guid":{"rendered":"http:\/\/springframework.guru\/?p=3942"},"modified":"2019-06-05T02:06:50","modified_gmt":"2019-06-05T06:06:50","slug":"spring-component-scan","status":"publish","type":"post","link":"https:\/\/springframework.guru\/spring-component-scan\/","title":{"rendered":"Spring Component Scan"},"content":{"rendered":"

When developing Spring Boot applications, you need to tell the Spring Framework where to look for Spring components. Using component scan is one method of asking Spring to detect Spring managed components. Spring needs the information to locate and register all the Spring components with the application context when the application starts.<\/p>\n

Spring can auto scan, detect, and instantiate components from pre-defined project packages. It can auto scan all classes annotated with the stereotype annotations @Component<\/code>, @Controller<\/code>, @Service<\/code>, and @Repository<\/code><\/p>\n

In this post, I will discuss how Spring component scanning works.<\/p>\n

Sample Application<\/h2>\n

Let us create a simple Spring Boot application to understand how component scanning works in Spring.<\/p>\n

We will start by writing few components.<\/p>\n

DemoBeanA.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog.componentscan.example.demopackageA;\r\n\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component(\"demoBeanA\")\r\npublic class DemoBeanA {\r\n}\r\n<\/pre>\n
DemoBeanB1.java<\/h5>\n
\r\n   \/\/404: Not Found\r\n<\/pre>\n
DemoBeanB2.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog.componentscan.example.demopackageB;\r\n\r\nimport org.springframework.stereotype.Component;\r\n\r\n\r\n@Component(\"demoBeanB2\")\r\npublic class DemoBeanB2 extends DemoBeanB1{\r\n}\r\n<\/pre>\n
DemoBeanB3.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog.componentscan.example.demopackageB;\r\n\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component(\"demoBeanB3\")\r\npublic class DemoBeanB3 extends DemoBeanB2{\r\n}\r\n<\/pre>\n
DemoBeanC.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog.componentscan.example.demopackageC;\r\n\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component(\"demoBeanC\")\r\npublic class DemoBeanC {\r\n}\r\n<\/pre>\n
DemoBeanD.java<\/h5>\n
package guru.springframework.blog.componentscan.example.demopackageD;\r\n\r\nimport org.springframework.stereotype.Component;\r\n\r\n@Component(\"demoBeanD\")\r\npublic class DemoBeanD {\r\n}<\/pre>\n
\"Spring<\/a>
Click Here to Become a Spring Framework Guru!<\/figcaption><\/figure>\n
The @SpringBootApplication Annotation<\/h2>\n
Spring needs to know which packages to scan for annotated components in order to add them to the IoC container. In a Spring Boot project, we typically set the main application class with the @SpringBootApplication<\/code> annotation. Under the hood, @SpringBootApplication<\/code> is a composition of the @Configuration<\/code>,  @ComponentScan<\/code>, and @EnableAutoConfiguration<\/code> annotations. With this default setting, Spring Boot will auto scan for components in the current package (containing the @SpringBoot main class) and its sub packages.<\/p>\n
To know more about these annotations, go through my Spring Framework Annotations<\/a> post.<\/p>\n
Note: It is recommended that you locate your main application class in a root package above the component classes of the application.<\/p>\n
The code to create the main class and access components is this.<\/p>\n
BlogPostsApplication.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog;\r\n\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\n\r\n\r\n@SpringBootApplication\r\npublic class BlogPostsApplication {\r\n\r\n    public static void main(String[] args) {\r\n        ApplicationContext context = SpringApplication.run(BlogPostsApplication.class,args);\r\n            System.out.println(\"Contains A  \"+context.\r\n                    containsBeanDefinition(\"demoBeanA\"));\r\n            System.out.println(\"Contains B2  \" + context.\r\n                    containsBeanDefinition(\"demoBeanB2\"));\r\n            System.out.println(\"Contains C   \" + context.\r\n                    containsBeanDefinition(\"demoBeanC\"));\r\n\r\n\r\n    }\r\n}\r\n<\/pre>\n
The output of running the main class is this.
\n\"Output<\/a><\/p>\n
As you can notice, all the classes in the sub packages of the main class BlogPostsApplication <\/code> are auto scanned by Spring.<\/p>\n
@ComponentScan \u2013 Identifying Base Packages<\/h2>\n
The @ComponentScan<\/code> annotation is used with the @Configuration<\/code> annotation to tell Spring the packages to scan for annotated components. @ComponentScan<\/code> is also used to specify base packages and base package classes using thebasePackageClasses<\/code> or basePackages<\/code> attributes of @ComponentScan<\/code>.<\/p>\n
The basePackageClasses <\/code> attribute is a type-safe alternative to basePackages<\/code>. When you specify basePackageClasses, Spring will scan the package (and subpackages) of the classes you specify.<\/p>\n
A Java class annotated with @ComponentScan<\/code> with the basePackageClassesattribute<\/code> is this.<\/p>\n
BlogPostsApplicationWithComponentScan.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog;\r\nimport guru.springframework.blog.componentscan.example.demopackageB.DemoBeanB1;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.annotation.ComponentScan;\r\nimport org.springframework.context.annotation.Configuration;\r\n\r\n@Configuration\r\n@ComponentScan(basePackages = {\"guru.springframework.blog.componentscan.example.demopackageA\",\r\n        \"guru.springframework.blog.componentscan.example.demopackageD\",\r\n        \"guru.springframework.blog.componentscan.example.demopackageE\"},\r\n        basePackageClasses = DemoBeanB1.class)\r\npublic class BlogPostsApplicationWithComponentScan {\r\n    public static void main(String[] args) {\r\n        ApplicationContext context = SpringApplication.\r\n                run(BlogPostsApplicationWithComponentScan.class,args);\r\n        System.out.println(\"Contains A  \"+context.\r\n                containsBeanDefinition(\"demoBeanA\"));\r\n        System.out.println(\"Contains B2  \" + context.\r\n                containsBeanDefinition(\"demoBeanB2\"));\r\n        System.out.println(\"Contains C   \" + context.\r\n                containsBeanDefinition(\"demoBeanC\"));\r\n        System.out.println(\"Contains D   \" + context.\r\n                containsBeanDefinition(\"demoBeanD\"));\r\n\r\n    }\r\n}\r\n<\/pre>\n
The output on running the main class is this.
\n\"Output<\/a><\/p>\n
The @ComponentScan<\/code> annotation uses the basePackages<\/code> attribute to specify three packages (and subpackages) that will be scanned by Spring. The annotation also uses the basePackageClasses<\/code> attribute to declare the DemoBeanB1<\/code> class, whose package Spring Boot should scan.<\/p>\n
As demoBeanC<\/code> is in a different package, Spring did not find it during component scanning.<\/p>\n
Component Scanning Filters<\/h2>\n
You can configure component scanning by using different type filters that Spring provides.<\/p>\n
By using filters, you can further narrow the set of candidate components from everything in basePackages to everything in the base packages that matches the given filter or filters.<\/p>\n
Filters can be of two types: include and exclude filters. As their names suggest, include filters specify which types are eligible for component scanning, while exclude filters specify which types are not.<\/p>\n
You can use the include and\/or exclude filters with or without the default filter. To disable the default filter, set the useDefaultFilters <\/code> element of the @ComponentScan<\/code> annotation to a false<\/code>.<\/p>\n
The code to disable the default filter is this.<\/p>\n
BlogPostsApplicationDisablingDefaultFilters.java<\/h5>\n
\r\n   \/\/package guru.springframework.blog;\r\n\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.annotation.ComponentScan;\r\nimport org.springframework.context.annotation.Configuration;\r\n\r\n@Configuration\r\n@ComponentScan(value = \"guru.springframework.blog.componentscan.example.demopackageA\",\r\n        useDefaultFilters = false)\r\npublic class BlogPostsApplicationDisablingDefaultFilters {\r\n    public static void main(String[] args) {\r\n        ApplicationContext context = SpringApplication.\r\n                run(BlogPostsApplicationDisablingDefaultFilters.class,args);\r\n            System.out.println(\"Contains A  \" + context.containsBean(\"demoBeanA\"));\r\n    }\r\n}\r\n<\/pre>\n
In the preceding code, the value member defines the specific guru.springframework.blog.componentscan.example.demopackageA<\/code> package to scan, while the useDefaultFilters<\/code> member disables the default filter.<\/p>\n
The output on running the main class is this.
\n\"Output<\/a><\/p>\n
As you can notice, the class DemoBeanA <\/code> in the package demopackageA <\/code> is unavailable when the useDefaultFilters <\/code> element of the @ComponentScan<\/code> annotation is set to a false.<\/p>\n
Component Scanning Filter Types<\/h3>\n
Spring provides the FilterType <\/code> enumeration for the type filters that may be used in conjunction with @ComponentScan<\/code>.<\/p>\n
The available FilterType<\/code> values are:<\/p>\n