Creating a Custom Auto-Configuration with Spring Boot

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

Auto-configuration in Spring Boot simplifies the configuration process by automatically configuring beans based on the dependencies and properties available in the application context. Creating custom auto-configuration enables you to bundle your configurations and make them reusable across different projects. This guide will walk you through creating a custom auto-configuration with Spring Boot 3.2.

Prerequisites

JDK 17 or later
Maven or Gradle
IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a New Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following configuration:

Project: Maven Project
Language: Java
Spring Boot: 3.2.x
Dependencies: None (we'll add necessary dependencies manually)

Download and unzip the project, then open it in your IDE.

1.2 Update `pom.xml`

Update the pom.xml file to include the necessary dependencies and configurations for your custom auto-configuration.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>custom-auto-configuration</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>custom-auto-configuration</name>
    <description>Custom Spring Boot Auto-Configuration</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
        <relativePath/>
    </parent>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Autoconfigure -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <!-- Optional dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Explanation:

spring-boot-autoconfigure: Provides auto-configuration support.
spring-boot-starter-logging: Adds logging support, which is common for most starters.

Step 2: Create Custom Components and Configuration

2.1 Create a Custom Service

Create a class named CustomService in the com.example.customautoconfig.service package.

package com.example.customautoconfig.service;

public class CustomService {

    public String getMessage() {
        return "Hello from CustomService!";
    }
}

Explanation:

CustomService: A simple service class that returns a message.

2.2 Create an Auto-Configuration Class

Create a class named CustomAutoConfiguration in the com.example.customautoconfig.config package.

package com.example.customautoconfig.config;

import com.example.customautoconfig.service.CustomService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CustomAutoConfiguration {

    @Bean
    public CustomService customService() {
        return new CustomService();
    }
}

Explanation:

@Configuration: Indicates that the class can be used by the Spring IoC container as a source of bean definitions.
@Bean: Marks a method as a bean producer for the application context.

2.3 Configure Auto-Configuration Metadata

Create a resources/META-INF/spring.factories file to register your auto-configuration class.

# META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.example.customautoconfig.config.CustomAutoConfiguration

Explanation:

spring.factories: Registers the CustomAutoConfiguration class to be automatically configured.

Step 3: Test the Custom Auto-Configuration

3.1 Create a Spring Boot Application to Use the Custom Auto-Configuration

Create a new Spring Boot project to test your custom auto-configuration. Use Spring Initializr to create a new project with the following configuration:

Project: Maven Project
Language: Java
Spring Boot: 3.2.x
Dependencies: Spring Web

Download and unzip the project, then open it in your IDE.

3.2 Add the Custom Auto-Configuration Dependency

Add the custom auto-configuration dependency to the pom.xml file of your new Spring Boot application.

<dependency>
    <groupId>com.example</groupId>
    <artifactId>custom-auto-configuration</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

3.3 Use the Custom Service in Your Application

Create a controller class named HelloController in the com.example.demo.controller package.

package com.example.demo.controller;

import com.example.customautoconfig.service.CustomService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private CustomService customService;

    @GetMapping("/hello")
    public String hello() {
        return customService.getMessage();
    }
}

Explanation:

CustomService: The custom service provided by your custom auto-configuration.
@Autowired: Injects the CustomService dependency.
@GetMapping("/hello"): Maps GET requests to the /hello endpoint and returns a message from the CustomService.

Step 4: Running and Testing the Application

4.1 Run the Application

Run the Spring Boot application using your IDE or the command line:

./mvnw spring-boot:run

4.2 Test the Custom Auto-Configuration

Use a web browser or a tool like Postman to send a GET request to http://localhost:8080/hello. You should see the message "Hello from CustomService!".

Conclusion

In this comprehensive guide, you have learned how to create a custom auto-configuration with Spring Boot. We covered:

Setting up a new project for the custom auto-configuration.
Creating custom components and an auto-configuration class.
Registering the auto-configuration class using spring.factories.
Creating a new Spring Boot application to test the custom auto-configuration.
Using the custom auto-configuration in the application and verifying its functionality.

By following these steps, you can create custom auto-configurations to encapsulate reusable configurations and simplify the setup of your Spring Boot applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog