Building Reactive Applications with Micronaut: A Step-by-Step Tutorial

Reactive programming is a powerful paradigm that allows developers to build responsive, resilient, and scalable applications. Micronaut, with its lightweight and modular architecture, provides excellent support for building reactive applications. In this tutorial, we will walk through the process of creating a reactive application using Micronaut.

Step 1: Setting Up the Project

To get started, we need to create a new Micronaut project. You can use Micronaut Launch or the Micronaut CLI to generate the project.

mn create-app example.micronaut.reactive --features=reactor,mongo-reactive,data-mongodb-reactive

This command creates a new Micronaut application with support for Reactor, MongoDB Reactive Streams, and reactive MongoDB repositories.

Step 2: Configuring MongoDB

Next, we need to configure the MongoDB connection in the application.yml file.

mongodb:
  uri: "mongodb://localhost:27017/reactiveDb"

Ensure that MongoDB is running locally or adjust the URI to point to your MongoDB instance.

Step 3: Creating the Domain Model

Let's create a simple domain model for our application. We'll define a Book entity that will be stored in the MongoDB database.

package example.micronaut.reactive;

import io.micronaut.serde.annotation.Serdeable;
import io.micronaut.data.annotation.Id;
import io.micronaut.data.annotation.GeneratedValue;
import io.micronaut.data.annotation.MappedEntity;
import org.bson.types.ObjectId;

@Serdeable
@MappedEntity
public class Book {
    @Id
    @GeneratedValue
    private ObjectId id;
    private String title;
    private String author;
    private int year;

    // Getters and setters
}

Step 4: Creating the Repository

We need a repository to perform CRUD operations on the Book entity. Micronaut Data provides a reactive repository interface for this purpose.

package example.micronaut.reactive;

import io.micronaut.data.annotation.Repository;
import io.micronaut.data.repository.reactive.ReactorCrudRepository;
import org.bson.types.ObjectId;

@Repository
public interface BookRepository extends ReactorCrudRepository {
}

Step 5: Creating the Service

Next, we'll create a service to handle business logic. This service will use the BookRepository to interact with the database.

package example.micronaut.reactive;

import jakarta.inject.Singleton;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Singleton
public class BookService {
    private final BookRepository bookRepository;

    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public Mono save(Book book) {
        return bookRepository.save(book);
    }

    public Flux findAll() {
        return bookRepository.findAll();
    }

    public Mono findById(ObjectId id) {
        return bookRepository.findById(id);
    }

    public Mono deleteById(ObjectId id) {
        return bookRepository.deleteById(id);
    }
}

Step 6: Creating the Controller

Finally, we'll create a controller to expose REST endpoints for our reactive application.

package example.micronaut.reactive;

import io.micronaut.http.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import org.bson.types.ObjectId;

@Controller("/books")
public class BookController {
    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @Post
    public Mono create(@Body Book book) {
        return bookService.save(book);
    }

    @Get
    public Flux list() {
        return bookService.findAll();
    }

    @Get("/{id}")
    public Mono get(ObjectId id) {
        return bookService.findById(id);
    }

    @Delete("/{id}")
    public Mono delete(ObjectId id) {
        return bookService.deleteById(id);
    }
}

Conclusion

In this tutorial, we have built a simple reactive application using Micronaut. We covered setting up the project, configuring MongoDB, creating a domain model, repository, service, and controller. Micronaut's support for reactive programming and its lightweight nature make it an excellent choice for building modern, scalable applications.

By following these steps, you can leverage the power of reactive programming to create responsive and resilient applications with Micronaut. Happy coding! 🚀