Java

HOME
Java
Introduction to Reactive microservices with Spring WebFlux

March 30, 2023 / Last updated : April 2, 2023 Drona Java

Introduction to Reactive microservices with Spring WebFlux

Reactive microservices are a modern architectural pattern that has gained significant popularity in recent years. These microservices are designed to be scalable, resilient, and responsive to the constantly changing requirements of modern web applications. Spring WebFlux is a powerful framework that makes it easy to develop reactive microservices. In this tutorial, we will explore how to develop reactive microservices with Spring WebFlux and communicate reactively with a relational database.

Prerequisites

Before we get started, make sure you have the following prerequisites:

Java 11 or later
Maven 3.6.0 or later
Spring Boot 2.4.0 or later
An IDE (IntelliJ IDEA, Eclipse, or any other)

Step 1: Create a Spring Boot project

The first step is to create a new Spring Boot project. You can do this by using the Spring Initializr, which is a web-based tool that generates a basic Spring Boot project with the required dependencies. Follow the steps below to create a new Spring Boot project:

Go to start.spring.io and select the following options:

Project: Maven Project
Language: Java
Spring Boot: 2.5.0
Packaging: Jar
Java: 11

Add the following dependencies:

Spring WebFlux
Spring Data JPA
H2 Database

Click Generate to download the project as a zip file.
Extract the zip file to a location on your computer.
Open your IDE and import the project as a Maven project.

Step 2: Set up a Reactive controller

In this step, we will create a Reactive controller that handles HTTP requests and responses using Spring WebFlux. Follow the steps below to create a Reactive controller:

Create a new Java class called UserController in the com.example.demo.controller package.
Add the following code to the UserController class:



@RestController
@RequestMapping("/users")
public class UserController {
 
    @Autowired
    private UserRepository userRepository;
 
    @GetMapping
    public Flux<User> getUsers() {
        return userRepository.findAll();
    }
 
    @GetMapping("/{id}")
    public Mono<User> getUser(@PathVariable Long id) {
        return userRepository.findById(id);
    }
 
    @PostMapping
    public Mono<User> createUser(@RequestBody User user) {
        return userRepository.save(user);
    }
 
    @PutMapping("/{id}")
    public Mono<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userRepository.save(user);
    }
 
    @DeleteMapping("/{id}")
    public Mono<Void> deleteUser(@PathVariable Long id) {
        return userRepository.deleteById(id);
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

@RestController

@RequestMapping("/users")

public class UserController {

@Autowired

private UserRepository userRepository;

@GetMapping

public Flux<User> getUsers() {

return userRepository.findAll();

}

@GetMapping("/{id}")

public Mono<User> getUser(@PathVariable Long id) {

return userRepository.findById(id);

}

@PostMapping

public Mono<User> createUser(@RequestBody User user) {

return userRepository.save(user);

}

@PutMapping("/{id}")

public Mono<User> updateUser(@PathVariable Long id, @RequestBody User user) {

user.setId(id);

return userRepository.save(user);

}

@DeleteMapping("/{id}")

public Mono<Void> deleteUser(@PathVariable Long id) {

return userRepository.deleteById(id);

}

In the above code, we have created a UserController class that defines five methods to handle HTTP requests: getUsers(), getUser(), createUser(), updateUser(), and deleteUser(). Each of these methods returns a Mono or a Flux, which are classes provided by Spring WebFlux to handle asynchronous processing.

Step 3: Set up a Reactive repository

In this step, we will create a Reactive repository that communicates with a relational database using Spring Data JPA. Follow the steps below to create a Reactive repository:

Create a new Java interface called UserRepository in the com.example.demo.repository package.
Add the following code to the UserRepository interface:



@Repository
public interface UserRepository extends ReactiveCrudRepository<User, Long> {
}

1

2

3

4

5

6

@Repository

public interface UserRepository extends ReactiveCrudRepository<User, Long> {

}

In the above code, we have created a UserRepository interface that extends the ReactiveCrudRepository interface provided by Spring Data JPA. This interface provides methods to perform CRUD (Create, Read, Update, Delete) operations on a relational database.

Step 4: Configure the database connection

In this step, we will configure the database connection using H2 Database. Follow the steps below to configure the database connection:

Open the application.properties file located in the src/main/resources directory.
Add the following code to the file:



spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

1

2

3

4

5

6

7

8

spring.datasource.url=jdbc:h2:mem:testdb

spring.datasource.driverClassName=org.h2.Driver

spring.datasource.username=sa

spring.datasource.password=

spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

In the above code, we have configured the database connection to use H2 Database. We have set the database URL, driver class name, username, and password. We have also set the database platform to use the H2 Dialect.

Step 5: Run the application

In this step, we will run the Spring Boot application and test the Reactive microservice. Follow the steps below to run the application:

Open the DemoApplication class located in the com.example.demo package.
Right-click on the class and select Run As -> Spring Boot App.
Once the application is running, open a web browser and go to http://localhost:8080/users.
You should see a JSON array of users in the browser.
You can test the other HTTP methods by using a tool like Postman or cURL.

Congratulations! You have successfully developed a Reactive microservice with Spring WebFlux communicating reactively with a relational database. You can now build upon this foundation to create more complex microservices and applications.