Java / Gradle

Micronaut Data from a Spring Boot Application

This guide shows how to use Micronaut Data from a Spring Boot application.

Sergio del Amo
On this guide
In this section

What you will need

To complete this guide, you will need the following:

Introduction

In this guide, you will use Micronaut Data JDBC within a Spring Boot application.

Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Generate a Spring Boot Application

Generate a Spring Boot application using Spring Initializr with Spring Web.

Dependencies

Add the following dependencies as described in Using the Micronaut Spring Boot Starter to use Micronaut Features within a Spring Boot application.

build.gradle
annotationProcessor platform("io.micronaut.platform:micronaut-platform:5.1.3")
implementation platform("io.micronaut.platform:micronaut-platform:5.1.3")
annotationProcessor("io.micronaut:micronaut-inject-java")
annotationProcessor("jakarta.annotation:jakarta.annotation-api")
implementation("jakarta.annotation:jakarta.annotation-api")
annotationProcessor("jakarta.persistence:jakarta.persistence-api")
implementation("jakarta.persistence:jakarta.persistence-api")
implementation("io.micronaut.spring:micronaut-spring-boot-starter")

Moreover, add the following dependencies to use Micronaut Data:

build.gradle
annotationProcessor("io.micronaut.data:micronaut-data-processor")
implementation("io.micronaut.data:micronaut-data-jdbc")
implementation("io.micronaut.sql:micronaut-jdbc-hikari")
runtimeOnly("com.h2database:h2")

Configuration

Add configuration for an in-memory H2 Database.

src/main/resources/application.properties
#Mon Aug 31 19:16:21 UTC 2026
datasources.default.dialect=H2
datasources.default.driverClassName=org.h2.Driver
datasources.default.password=
datasources.default.schema-generate=CREATE_DROP
datasources.default.url=jdbc\:h2\:mem\:devDb;LOCK_TIMEOUT\=10000;DB_CLOSE_ON_EXIT\=FALSE
datasources.default.username=sa

Mapped Entities with Java Records

Create a Micronaut Data Mapped Entity

java/src/main/java/example/micronaut/Book.java
package example.micronaut;

import io.micronaut.core.annotation.Nullable;
import io.micronaut.data.annotation.GeneratedValue;
import io.micronaut.data.annotation.Id;
import io.micronaut.data.annotation.MappedEntity;

@MappedEntity // 
public record Book(
        @Id // 
        @GeneratedValue // 
        @Nullable // 
        Long id,
        String title,
        int pages
) {
}
1 Annotate the class with @MappedEntity to map the class to the table defined in the schema.
2 Specifies the ID of an entity
3 Specifies that the property value is generated by the database and not included in inserts
4 Annotate it with @Nullable because it is a generated value.
Note
 Learn how to leverage Java records for immutable configuration, Micronaut Data Mapped Entities and Projection DTOs in the Micronaut Data and Java Records guide.

JDBC Repository

Next, create a repository interface to define the operations to access the database. Micronaut Data will implement the interface at compilation time.

java/src/main/java/example/micronaut/BookRepository.java
package example.micronaut;

import io.micronaut.data.jdbc.annotation.JdbcRepository;
import io.micronaut.data.model.query.builder.sql.Dialect;
import io.micronaut.data.repository.CrudRepository;

@JdbcRepository(dialect = Dialect.H2) // 
public interface BookRepository extends CrudRepository<Book, Long> { // 

    Book save(String title, int pages);
}
1 @JdbcRepository with a specific dialect.
2 By extending CrudRepository you enable automatic generation of CRUD (Create, Read, Update, Delete) operations.

Controller

Create a controller which exposes a GET route at /books.

java/src/main/java/example/micronaut/BookController.java
package example.micronaut;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

@RestController // 
public class BookController {
    @Autowired // 
    private BookRepository bookRepository;

    @GetMapping("/books") // 
    Iterable<Book> list() {
        return bookRepository.findAll();
    }
}
1 In Spring’s approach to building RESTful web services, HTTP requests are handled by a controller. These components are identified by the @RestController annotation.
2 Inject a bean of type BookRepository by using @Autowired on the field definition.
3 The @GetMapping ensures that HTTP GET requests to /books are mapped to the list method.

Test

The following test shows that you can use Micronaut Data JDBC as your persistence solution in a Spring Boot Application.

java/src/test/java/example/micronaut/BookControllerTest.java
package example.micronaut;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.web.client.RestClient;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) // 
class BookControllerTest {
    @LocalServerPort // 
    private int port;

    private RestClient restClient;

    @Autowired // 
    BookRepository bookRepository;

    @BeforeEach
    void setup() {
        restClient = RestClient.builder()
                .baseUrl("http://localhost:" + port)
                .build();
    }

    @Test
    void booksGet() {
        assertEquals(0, booksJsonArray().length);
        Book moreJava17 = bookRepository.save("More Java 17", 951);
        Book[] books = booksJsonArray();
        assertEquals(1, books.length);
        assertNotNull(books[0].id());
        assertEquals(books[0].pages(), 951);
        assertEquals(books[0].title(), "More Java 17");
        bookRepository.delete(moreJava17);
        assertEquals(0, booksJsonArray().length);
    }

    private Book[] booksJsonArray() {
        return restClient.get()
                .uri("/books")
                .retrieve()
                .body(Book[].class);
    }

}
1 The @SpringBootTest annotation tells Spring Boot to look for a main configuration class (one with @SpringBootApplication, for instance) and use that to start a Spring application context.
2 Note the use of webEnvironment=RANDOM_PORT to start the server with a random port (useful to avoid conflicts in test environments) and the injection of the port with @LocalServerPort.
3 Inject a bean of type TestRestTemplate by using @Autowired on the field definition.

  1. Inject a bean of type BookRepository by using @Autowired on the field definition.

Testing the Application

To run the tests:

./gradlew test

Next Steps

Read more about Micronaut Spring and Micronaut Data.

Help with the Micronaut Framework

The Micronaut Foundation sponsored the creation of this Guide. A variety of consulting and support services are available.

License

Note
 All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).