Micronaut @ConfigurationBuilder Example

Micronaut @ConfigurationBuilder allows us to bind configuration files to Java objects using builder pattern.

Table of contents

• 1. Defining Configuration in application.yml
• 2. Builder Pattern
• 3. Using @ConfigurationBuilder
• 4. Injecting the Configured Database
• 5. Running the Application
• 6. Unit Tests
• 7. Download Source Code
• 8. References

Technologies used:

• Java 21
• Micronaut 4.7.6
• Maven 3.x

1. Defining Configuration in application.yml

We configure the properties in src/main/resources/application.yml

micronaut:
  application:
    name: configurationbuilder

myapp:
  database:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret
    max-size: 10
    min-size: 1

2. Builder Pattern

We have a Database class with a builder for configuration:

package com.mkyong.config;

public class Database {
    private String url;
    private String username;
    private String password;
    private int maxSize;
    private int minSize;

    private Database(Builder builder) {
        this.url = builder.url;
        this.username = builder.username;
        this.password = builder.password;
        this.maxSize = builder.maxSize;
        this.minSize = builder.minSize;
    }

    public String getUrl() {
        return url;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public int getMinSize() {
        return minSize;
    }

    public static class Builder {
        private String url;
        private String username;
        private String password;
        private int maxSize;
        private int minSize;

        public Builder url(String url) {
            this.url = url;
            return this;
        }

        public Builder username(String username) {
            this.username = username;
            return this;
        }

        public Builder password(String password) {
            this.password = password;
            return this;
        }

        public Builder maxSize(int maxSize) {
            this.maxSize = maxSize;
            return this;
        }

        public Builder minSize(int minSize) {
            this.minSize = minSize;
            return this;
        }

        public Database build() {
            return new Database(this);
        }
    }
}

3. Using @ConfigurationBuilder

We can now create a Micronaut configuration class that utilizes @ConfigurationBuilder to configure the Database.Builder:

package com.mkyong.config;

import io.micronaut.context.annotation.ConfigurationProperties;
import io.micronaut.context.annotation.ConfigurationBuilder;

@ConfigurationProperties("myapp.database")
public class DatabaseConfiguration {

    @ConfigurationBuilder(prefixes = "")
    private final Database.Builder builder = new Database.Builder();

    public Database.Builder getBuilder() {
        return builder;
    }

    public Database build() {
        return builder.build();
    }

}

4. Injecting the Configured Database

Create a service to print out all the database configuration.

package com.mkyong.service;

import com.mkyong.config.Database;
import com.mkyong.config.DatabaseConfiguration;
import jakarta.inject.Singleton;

@Singleton
public class DatabaseService {
    private final Database database;

    public DatabaseService(DatabaseConfiguration configuration) {
        this.database = configuration.build();
    }

    public void printAll() {
        System.out.println("Database URL: " + database.getUrl());
        System.out.println("Username: " + database.getUsername());
        System.out.println("Password: " + database.getPassword());
        System.out.println("Max Pool Size: " + database.getMaxSize());
        System.out.println("Min Pool Size: " + database.getMinSize());
    }
}

5. Running the Application

When we run the application, DatabaseService prints the values from application.yml.

package com.mkyong;

import com.mkyong.service.DatabaseService;
import io.micronaut.context.event.StartupEvent;
import io.micronaut.runtime.Micronaut;
import io.micronaut.runtime.event.annotation.EventListener;
import jakarta.inject.Inject;

public class Application {

    @Inject
    DatabaseService databaseService;

    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }

    @EventListener
    public void onStartup(StartupEvent event) {
        System.out.println("Application has started!");
        // Your startup code here, e.g., seeding a database or initializing resources.

        databaseService.printAll();
    }
}

Output

 __  __ _                                  _   
|  \/  (_) ___ _ __ ___  _ __   __ _ _   _| |_ 
| |\/| | |/ __| '__/ _ \| '_ \ / _` | | | | __|
| |  | | | (__| | | (_) | | | | (_| | |_| | |_ 
|_|  |_|_|\___|_|  \___/|_| |_|\__,_|\__,_|\__|
Application has started!
Database URL: jdbc:mysql://localhost:3306/mydb
Username: root
Password: secret
Max Pool Size: 10
Min Pool Size: 1
20:32:59.029 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 462ms. Server Running: http://localhost:8080

6. Unit Tests

package com.mkyong;

import com.mkyong.config.Database;
import com.mkyong.config.DatabaseConfiguration;
import io.micronaut.context.ApplicationContext;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class DatabaseConfigurationTest {
    @Test
    void testDatabaseConfiguration() {
        try (ApplicationContext context = ApplicationContext.run(
                "myapp.database.url", "jdbc:mysql://localhost:3306/mydb",
                "myapp.database.username", "root",
                "myapp.database.password", "secret",
                "myapp.database.pool.max-size", "10",
                "myapp.database.pool.min-size", "1")) {

            DatabaseConfiguration config = context.getBean(DatabaseConfiguration.class);
            Database database = config.build();

            assertEquals("jdbc:mysql://localhost:3306/mydb", database.getUrl());
            assertEquals("root", database.getUsername());
            assertEquals("secret", database.getPassword());
            assertEquals(10, database.getMaxSize());
            assertEquals(1, database.getMinSize());
        }
    }
}

7. Download Source Code

8. References

• Micronaut ConfigurationProperties Documentation
• Micronaut @ConfigurationProperties Documentation
• Micronaut Configuration Guide
• Micronaut @ConfigurationProperties Example – Mkyong.com
• Micronaut Loading external yaml or configuration file – Mkyong.com