12 Configurations

Micronaut features several built-in configurations that enable integration with common databases and other servers.

12.1 Configurations for Data Access

The table summarizes the configuration modules and the dependencies you should add to your build to enable them.

For example, to add support for MongoDB you define the following dependency:

build.gradle

compile "io.micronaut.configuration:micronaut-mongo-reactive"

For Groovy users, Micronaut provides special support for GORM.

The following sections go into more detail about configuration options and the exposed beans for each implementation.

12.1.1 Configuring a SQL Data Source

Java data sources can be configured for one of three currently provided implementations. Apache DBCP2, Hikari, and Tomcat are supported by default.

Configuring a JDBC DataSource

$ mn create-app my-app —features jdbc-tomcat

To get started, simply add a dependency to one of the JDBC configurations that corresponds to the implementation you would like to use. Choose one of the following:

runtime("io.micronaut.configuration:micronaut-jdbc-tomcat")

<dependency>
    <groupId>io.micronaut.configuration</groupId>
    <artifactId>micronaut-jdbc-tomcat</artifactId>
    <scope>runtime</scope>
</dependency>

runtime("io.micronaut.configuration:micronaut-jdbc-hikari")

<dependency>
    <groupId>io.micronaut.configuration</groupId>
    <artifactId>micronaut-jdbc-hikari</artifactId>
    <scope>runtime</scope>
</dependency>

runtime("io.micronaut.configuration:micronaut-jdbc-dbcp")

<dependency>
    <groupId>io.micronaut.configuration</groupId>
    <artifactId>micronaut-jdbc-dbcp</artifactId>
    <scope>runtime</scope>
</dependency>

You also need to add a JDBC driver dependency to your classpath. For example to add the H2 In-Memory Database:

runtime("com.h2database:h2")

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

For more information see the Configuring JDBC section of the Micronaut SQL libraries project.

12.1.2 Configuring Hibernate

Setting up a Hibernate/JPA EntityManager

$ mn create-app my-app —features hibernate-jpa

Micronaut features built in support for configuring a Hibernate / JPA EntityManager that builds on the SQL DataSource support.

Once you have configured one or many DataSources to use Hibernate, you will need to add the hibernate-jpa dependency to your build configuration:

implementation("io.micronaut.configuration:micronaut-hibernate-jpa")

<dependency>
    <groupId>io.micronaut.configuration</groupId>
    <artifactId>micronaut-hibernate-jpa</artifactId>
</dependency>

For more information see the Configuring Hibernate section of the Micronaut SQL libraries project.

Using GORM for Hibernate

For Groovy users and users familiar with the Grails framework, special support for GORM for Hibernate is available. To use GORM for Hibernate you should not include Micronaut’s built in SQL Support or the hibernate-jpa dependency since GORM itself takes responsibility for creating the DataSource, SessionFactory etc.

$ mn create-app my-app —features hibernate-gorm

See the GORM Modules section of the Micronaut for Groovy user guide.

12.1.3 Configuring MongoDB

Setting up the Native MongoDB Driver

$ mn create-app my-app —features mongo-reactive

Micronaut includes a configuration to automatically configure the native MongoDB Java driver. To use this configuration, add the following dependency to your application:

implementation("io.micronaut.configuration:micronaut-mongo-reactive")

<dependency>
    <groupId>io.micronaut.configuration</groupId>
    <artifactId>micronaut-mongo-reactive</artifactId>
</dependency>

Then configure the URI of the MongoDB server in application.yml:

Configuring a MongoDB server

mongodb:
    uri: mongodb://username:password@localhost:27017/databaseName

A non-blocking Reactive Streams MongoClient is then available for dependency injection.

To use the blocking driver, add a dependency to your application to the mongo-java-driver.

compile "org.mongodb:mongo-java-driver"

Then the blocking MongoClient will be available for injection.

See the Micronaut MongoDB documentation for further information on configuring and using MongoDB within Micronaut.

12.1.4 Configuring Neo4j

Micronaut features dedicated support for automatically configuring the Neo4j Bolt Driver for the popular Neo4j Graph Database.

$ mn create-app my-app —features neo4j-bolt

To configure the Neo4j Bolt driver you should first add the neo4j-bolt module to your classpath:

implementation("io.micronaut:micronaut-neo4j-bolt")

<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-neo4j-bolt</artifactId>
</dependency>

You should then configure the URI of the Neo4j server you wish to communicate with in application.yml:

Configuring neo4j.uri

neo4j:
    uri: bolt://localhost

Once you have the above configuration in place you can inject an instance of the org.neo4j.driver.v1.Driver bean, which features both a synchronous blocking API and a non-blocking API based on CompletableFuture.

See the Micronaut Neo4j documentation for further information on configuring and using Neo4j within Micronaut.

12.1.5 Configuring Postgres

Micronaut supports reactive and non-blocking client to connect to Postgres using reactive-pg-client, allowing to handle many database connections with a single thread.

Configuring the Reactive Postgres Client

$ mn create-app my-app —features postgres-reactive

To configure the Reactive Postgres client you should first add postgres-reactive module to your classpath:

build.gradle

compile "io.micronaut.configuration:micronaut-postgres-reactive"

For more information see the Configuring Reactive Postgres section of the Micronaut SQL libraries project.

12.1.6 Configuring Redis

Micronaut features automatic configuration of the Lettuce driver for Redis via the redis-lettuce module.

Configuring Lettuce

$ mn create-app my-app —features redis-lettuce

To configure the Lettuce driver you should first add the redis-lettuce module to your classpath:

build.gradle

compile "io.micronaut.configuration:micronaut-redis-lettuce"

You should then configure the URI of the Redis server you wish to communicate with in application.yml:

Configuring redis.uri

redis:
    uri: redis://localhost

You can also specify multiple Redis URIs using redis.uris in which case a RedisClusterClient is created instead.

For more information and further documentation see the Micronaut Redis documentation.

12.1.7 Configuring Cassandra

$ mn create-app my-app —features cassandra

For more information see the Micronaut Cassandra Module documentation.

12.1.8 Configuring Liquibase

To configure Micronaut integration with Liquibase, please follow these instructions.

12.1.9 Configuring Flyway

To configure Micronaut integration with Flyway, please follow these instructions