Finding All Beans with a Custom Annotation in Spring boot

In Spring Boot, developers often define beans (components, services, etc.) to be managed automatically by the Spring IoC (Inversion of Control) container. Sometimes, it's helpful to identify beans marked with a specific custom annotation for special handling—whether for applying certain behavior or managing the execution flow.

In this article, we will explore how to create a Spring Boot application that scans and retrieves all beans annotated with a custom annotation. We will cover:

• Creating a custom annotation.
• Annotating beans (e.g., services) with the custom annotation.
• Scanning the application context to find the beans with that custom annotation.

Custom Annotations in Spring

Annotations in Spring are powerful tools for marking classes or methods with metadata. While Spring provides many built-in annotations like @Serviceor @Component, you can also define custom annotations. These annotations can be applied to specific beans, which can then be identified at runtime for special processing.

To achieve this, the steps are:

1. Define the custom annotation.
2. Annotate beans with this custom annotation.
3. Implement a utility to scan the Spring application context and find beans annotated with the custom annotation.

Implementation to find all beans with a Custom Annotation

Let’s walk through the steps to find all beans annotated with a custom annotation in a Spring Boot application.

Step 1: Create a New Spring Boot Project

Create a new Spring Boot project using IntelliJ IDEA or your preferred IDE. Choose the following options:

• Name: find-annotated-beans
• Language: Java
• Type: Maven
• Packaging: Jar

Click on the Next button.

Step 2: Add the Dependencies

Add the following dependencies into the Spring Boot Project.

• Spring Web
• Lombok
• Spring Boot DevTools

Click on the Create button.

Project Structure

After the project creation done successfully, the folder structure will look like the below image:P

Step 3: Configure Application Properties

In the application.properties file, set up the project name and port.

spring.application.name=find-annotated-beans
server.port=8080

Step 4: Create the CustomAnnotation Interface

This is our custom annotation, which will be used to mark certain beans.

CustomAnnotation.java

Step 5: Create the Annotated Beans

Now, let’s create two service classes that will be annotated with @CustomAnnotation.

AnnotatedService1.java:

AnnotatedService2.java:

These beans are annotated with @CustomAnnotation. They represent services that will be discovered by our scanner.

Step 6: Configure the Scanner to Run the Startup

We will configure the Spring Boot application to scan for the beans annotated with @CustomAnnotation during the startup.

BeanScannerConfig.java

By using CommandLineRunner, this configuration ensures that the bean scanner runs when the application starts up, searching for beans annotated with @CustomAnnotation.

Step 7: Create the CustomAnnotationBeanScanner Utility

We need a utility class to scan the application context for beans annotated with @CustomAnnotation.

CustomAnnotationBeanScanner.java

• BeanScannerConfig: This configuration ensures that the scanner is triggered at the application startup using the CommandLineRunner.
• The findBeansWithCustomAnnotation method scans the Spring context for the beans annotated with @CustomAnnotation and prints them to the console.

Step 8: Main class

No changes are required in the main class.

pom.xml

Step 9: Run the Application

Once you've set everything up, run the application. It will scan the application context and print out all the beans annotated with @CustomAnnotation to the console:

This example project demonstrates how to create the Spring Boot application that scans for the beans with the custom annotation. It can be extended to support the more complex scenarios by modifying the annotation scanner or adding the more annotated beans.

Conclusion

In this article, we explored how to create a custom annotation and use it to mark beans in a Spring Boot application. We then implemented a scanner utility that searches the application context for beans annotated with the custom annotation. This method provides flexibility for applying special behavior to specific beans at runtime.