1. Introduction to Component Scanning

Component scanning is a mechanism used by Spring to automatically detect and register beans within the application context. By using the @ComponentSca n annotation, you instruct Spring to look for classes annotated with specific stereotypes such as @Component , @Service , @Repository , and @Controller. This automatic detection saves you from manually defining beans in XML configuration or Java configuration classes.

1.1 What is @ComponentScan?

@ComponentScan is an annotation used in Spring to specify the base packages to scan for Spring components. By default, it scans the package of the class that declares it and its sub-packages. This annotation can be used in combination with @Configuration to configure Spring's application context.

Example Code:

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.example.service")
public class AppConfig {
}

In the example above, Spring will scan the com.example.service package and its sub-packages for classes annotated with @Component , @Service , @Repository , or @Controller.

1.2 Benefits of Component Scanning

• Reduces Boilerplate Code : Eliminates the need for manual bean registration.
• Simplifies Configuration : Allows for a cleaner and more maintainable configuration.
• Promotes Convention Over Configuration : Follows the convention of annotating classes to define beans.

1.3 How to Customize Component Scanning

You can customize component scanning by specifying multiple packages or using filters to include or exclude specific classes.

Example Code:

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;

@Configuration
@ComponentScan(
    basePackages = {"com.example.service", "com.example.repository"},
    includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Service.class}),
    excludeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {DeprecatedService.class})
)
public class CustomAppConfig {
}

In this configuration, Spring will scan the com.example.service and com.example.repository packages, include only classes annotated with @Service , and exclude classes that are of type DeprecatedService.

2. How Component Scanning Works Internally

Spring uses the ClassPathScanningCandidateComponentProvider to scan the classpath for components. It leverages the classpath resource loader to find classes, then filters and registers them as beans based on the provided annotations.

2.1 The Scanning Process

• Class Path Resource Loading : Spring scans the classpath for resources (classes).
• Component Filtering : Filters the classes based on annotations or other criteria.
• Bean Definition Creation : Creates bean definitions for the detected components and registers them in the application context.

Example Code:

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.AnnotationTypeFilter;

public class CustomScanner {

    public static void main(String[] args) {
        ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
        provider.addIncludeFilter(new AnnotationTypeFilter(Service.class));

        for (BeanDefinition bd : provider.findCandidateComponents("com.example")) {
            System.out.println("Found component: " + bd.getBeanClassName());
        }
    }
}

In this example, CustomScanner demonstrates how to programmatically scan for beans annotated with @Service in the com.example package.

2.2 Common Issues and Solutions

• Class Not Found Exception : Ensure that the package names in @ComponentScan are correct and that the classes are present in the classpath.
• Duplicate Bean Definitions: If multiple components are scanned that implement the same interface or class, use @primary or @Qualifier to resolve conflicts.

3. Conclusion

Component scanning is a powerful feature of the Spring Framework that simplifies bean management and configuration. By understanding and leveraging @ComponentScan, you can create cleaner and more maintainable Spring applications. If you have any questions or need further clarification on component scanning, feel free to leave a comment below!

Read posts more at : How Component Scanning Works in Spring Framework?