Reactive Spring Boot: Building the Future of Scalable Apps

“Image taken by ChatGPT”

🚀 Welcome to FutureLens! In this blog, we are explore how to Reactive Spring Boot is very transforming in the way scalable and high level- performance applications are built. You’ll be learn how to implement reactive with APIs using Spring WebFlux with practical code with examples. Let’s dive into the future of your modern backend development!

Modern applications is the must handle to high concurrency, massive traffic, and real-time data streams. Traditional blocking with architectures struggle under these new conditions.

Reactive programming solving this by enabling non-blocking, asynchronous, event-driven systems.

In the Java ecosystem, reactive with systems are the truly commonly built using:

• Spring Boot
• Spring WebFlux
• Project Reactor
• Reactive Databases (MongoDB, R2DBC)

This blog demonstrates how to do build a Reactive REST API using Spring Boot + WebFlux with a strong focus on the code imp

1. Project Setup

Create a Spring Boot projects with the following dependencies.

Maven pom.xml

<dependencies>

    <!-- Reactive Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>

    <!-- Reactive MongoDB -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Validation -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

    <!-- Testing -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

</dependencies>

2. Application Configuration

“Image taken by Chrome”

application.yml

spring:
  data:
    mongodb:
      uri: mongodb://localhost:27017/reactive_db

server:
  port: 8080

3. Spring Boot Main Class

@SpringBootApplication
public class ReactiveDemoApplication {

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

}

4. Domain Model

User.java

import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Document(collection = "users")
public class User {

    @Id
    private String id;

    private String name;

    private String email;

    private int age;

}

5. Reactive Repository

“Image taken by Chrome”

Reactive repositories are returns into Mono or Flux instead of the traditional objects.

UserRepository.java

import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
import reactor.core.publisher.Flux;

public interface UserRepository extends ReactiveMongoRepository<User, String> {

    Flux<User> findByAgeGreaterThan(int age);

}

6. Service Layer

UserService.java

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface UserService {

    Mono<User> createUser(User user);

    Flux<User> getAllUsers();

    Mono<User> getUserById(String id);

    Mono<User> updateUser(String id, User user);

    Mono<Void> deleteUser(String id);

}

UserServiceImpl.java

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {

    private final UserRepository repository;

    @Override
    public Mono<User> createUser(User user) {
        return repository.save(user);
    }

    @Override
    public Flux<User> getAllUsers() {
        return repository.findAll();
    }

    @Override
    public Mono<User> getUserById(String id) {
        return repository.findById(id);
    }

    @Override
    public Mono<User> updateUser(String id, User user) {

        return repository.findById(id)
                .flatMap(existing -> {

                    existing.setName(user.getName());
                    existing.setEmail(user.getEmail());
                    existing.setAge(user.getAge());

                    return repository.save(existing);
                });
    }

    @Override
    public Mono<Void> deleteUser(String id) {
        return repository.deleteById(id);
    }
}

7. Reactive REST Controller

Photo by am g on Unsplash

UserController.java

import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService service;

    @PostMapping
    public Mono<User> create(@RequestBody User user) {
        return service.createUser(user);
    }

    @GetMapping
    public Flux<User> getAll() {
        return service.getAllUsers();
    }

    @GetMapping("/{id}")
    public Mono<User> getById(@PathVariable String id) {
        return service.getUserById(id);
    }

    @PutMapping("/{id}")
    public Mono<User> update(@PathVariable String id,
                             @RequestBody User user) {

        return service.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public Mono<Void> delete(@PathVariable String id) {
        return service.deleteUser(id);
    }

}

8. Streaming Endpoint (Server-Sent Events)

Photo by Scott Rodgerson on Unsplash

Reactive systems with the can streams data continuously.

@GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<User> streamUsers() {

    return service.getAllUsers()
            .delayElements(Duration.ofSeconds(1));
}

9. Functional Routing (Alternative to Controllers)

Photo by Mehdi Mirzaie on Unsplash

Spring boot WebFlux also a generative supports functional routing.

RouterConfig.java

@Configuration
public class RouterConfig {

    @Bean
    public RouterFunction<ServerResponse> routes(UserHandler handler) {

        return RouterFunctions
                .route(RequestPredicates.GET("/router/users"),
                        handler::getAllUsers)
                .andRoute(RequestPredicates.POST("/router/users"),
                        handler::createUser);
    }

}

10. Handler Implementation

@Component
@RequiredArgsConstructor
public class UserHandler {

    private final UserService service;

    public Mono<ServerResponse> getAllUsers(ServerRequest request) {

        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(service.getAllUsers(), User.class);
    }

    public Mono<ServerResponse> createUser(ServerRequest request) {

        Mono<User> userMono = request.bodyToMono(User.class);

        return userMono
                .flatMap(service::createUser)
                .flatMap(user -> ServerResponse.ok().bodyValue(user));
    }

}

11. Global Exception Handling

Photo by Arturo Añez on Unsplash

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public Mono<ResponseEntity<String>> handleException(RuntimeException ex) {

        return Mono.just(
                ResponseEntity
                        .status(HttpStatus.INTERNAL_SERVER_ERROR)
                        .body(ex.getMessage())
        );
    }

}

12. Reactive Testing

Spring WebFlux uses with WebTestClient for testing.

UserControllerTest.java

@SpringBootTest
@AutoConfigureWebTestClient
public class UserControllerTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void testCreateUser() {

        User user = User.builder()
                .name("John")
                .email("john@mail.com")
                .age(25)
                .build();

        webTestClient.post()
                .uri("/users")
                .bodyValue(user)
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.name").isEqualTo("John");
    }
}

13. Core Reactive Types

Photo by Zemos on Unsplash

Mono (0..1 item)

Mono<String> mono = Mono.just("Hello Reactive");

Flux (0..N items)

Flux<Integer> numbers = Flux.just(1,2,3,4,5);

14. Reactive Operators

Map

Flux<Integer> squared =
        Flux.just(1,2,3,4)
            .map(n -> n * n);

FlatMap

Flux<Integer> result =
        Flux.just(1,2,3)
            .flatMap(n -> Flux.just(n, n * 10));

15. Backpressure Example

Flux.range(1, 10000)
    .log()
    .limitRate(100)
    .subscribe();

16. Parallel Processing

Flux.range(1, 10)
    .parallel()
    .runOn(Schedulers.parallel())
    .map(i -> i * 2)
    .sequential()
    .subscribe(System.out::println);

17. Project Structure

src
 └── main
     ├── controller
     ├── service
     ├── repository
     ├── handler
     ├── router
     ├── model
     └── exception

Conclusion

Reactive Spring Boot is enables building a high-performance, scalable microservices with this:

• Non-blocking I/O
• Efficient resource usage
• Streaming APIs
• Event-driven architecture

Core level reactive stack:

Spring WebFlux
Project Reactor
Netty Server
Reactive Database Drivers

Reactive types:

Mono<T>
Flux<T>

🔮Thanks for reading on FutureLens! Reactive programming is a very shaping for the next generation of a scalable systems and real-time applications. Keep the exploring, keep building, and stay ahead with the modern technologies. See you in the next level deep-dive with the FutureLens!