Spring @ComponentScan Annotation with Example

Spring is one of the most popular frameworks for building enterprise-level Java applications. It is an open-source, lightweight framework that simplifies the development of robust, scalable, and maintainable applications. Spring provides various features such as Dependency Injection (DI), Aspect-Oriented Programming (AOP), and support for Plain Old Java Objects (POJOs), making it a preferred choice for Java developers.

In this article, we will focus on the @ComponentScan annotation in Spring.

@ComponentScan Annotation in Spring

The @ComponentScan annotation is used to specify the package that the framework should scan for Spring-managed components. These components are classes annotated with @Component, @Service, @Repository, or @Controller. When Spring finds such classes, it automatically registers them as beans in the Spring application context.

The @ComponentScan annotation is used along with the @Configuration annotation. It eliminates the need for manual bean registration in XML files, making the configuration more concise and easier to manage.

Key Points about @ComponentScan:

• The @ComponentScan annotation tells Spring to scan specific packages for components annotated with @Component, @Service, @Repository, or @Controller.
• Without arguments, the @ComponentScan annotation scans the package of the annotated class and its sub-packages by default.
• The @ComponentScan annotation is used alongside @Configuration to define package scanning in a configuration class.
• The @ComponentScan annotation helps spring automatically detect and register beans without needing manual bean declaration.

Steps to Use the @ComponentScan Annotation

We will create a simple Spring application with a College class and configure it using @ComponentScan.

Step 1: Create the College Class

Let's create a simple Collge Class with a method test() that prints a message.

// Creating a class
package ComponentAnnotation;

public class College {
    public void test() {
        System.out.println("Test College Method");
    }
}

Now let’s create a Bean for this class inside the beans.xml file.

Bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

	<bean id="collegeBean" class="ComponentAnnotation.College"></bean>
</beans>

Step 2: Add @Component

Instead of defining the College bean in an XML file, we can use the @Component annotation to mark the class as a Spring-managed component.

// Java Program to Illustrate Component Annotation
// Indulgence in College Class

package ComponentAnnotation;
import org.springframework.stereotype.Component;

// Registering the class as a Spring bean
@Component("collegeBean")  
public class College {
    public void test() {
        System.out.println("Test College Method");
    }
}

Transitioning from XML to Annotation-Based Configuration

Instead of using an XML file (beans.xml) to define beans, Spring allows us to use Java-based configuration. By creating a configuration class annotated with @Configuration and using @ComponentScan, we can replace the XML configuration with a more modern and concise approach. This eliminates the need for beans.xml and makes the application easier to manage.

Step 3: Create a Configuration Class

We create a configuration class (CollegeConfig) and use the @ComponentScan annotation to specify the package to scan for components.

// Java Program to Illustrate Configuration of
// College Class

package ComponentAnnotation;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
// Marks this class as a configuration class
@Configuration  
// Specifies the package to scan
@ComponentScan(basePackages = "ComponentAnnotation") 
public class CollegeConfig {
}

Step 4: Create the Main Application

Now to check our application, we can create a Main class to load the Spring application context and retrieve the College bean.

//Creating a Main class
package ComponentAnnotation;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        // Load the Spring application context using the configuration class
        ApplicationContext context = new AnnotationConfigApplicationContext(CollegeConfig.class);

        // Retrieve the College bean
        College college = context.getBean(College.class);

        // Call the test method
        college.test();
    }
}

Step 5: Run the Application

When we run the Main class, the output will be:

Test College Method