跳到主要内容

Reactive Programming in Spring WebFlux Series - V

· 阅读需 3 分钟

Reactive Database Access


Why Choose Reactive Database Access?​

Traditional database access methods are usually blocking, meaning that when a query is executing, the thread is blocked until the query is completed. This can lead to performance bottlenecks in highly concurrent environments. Reactive database access uses non-blocking I/O operations, allowing applications to handle more concurrent requests, improving system throughput and response times.


Spring Data R2DBC​

Spring Data R2DBC (Reactive Relational Database Connectivity) is a project in the Spring ecosystem that provides reactive programming support for relational databases. R2DBC is a new database connection specification designed to support reactive programming models.

1. Project Setup​

First, create a Spring Boot project and include the necessary dependencies:

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>
<dependency>
<groupId>io.r2dbc</groupId>
<artifactId>r2dbc-h2</artifactId>
</dependency>
</dependencies>

2. Database Connection Configuration​

Configure the H2 database in application.properties:

spring.r2dbc.url=r2dbc:h2:mem:///testdb
spring.r2dbc.username=sa
spring.r2dbc.password=
spring.r2dbc.generate-unique-name=true

spring.h2.console.enabled=true
spring.h2.console.settings.web-allow-others=true

3. Data Model​

Define a simple User entity:

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;

@Table("users")
public class User {
@Id
private Long id;
private String name;

// Getters and Setters
}

4. Creating a Repository​

Create a reactive UserRepository interface:

import org.springframework.data.repository.reactive.ReactiveCrudRepository;

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

5. Data Initialization​

Use an initializer class to preload some data:

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import reactor.core.publisher.Flux;

@Configuration
public class DataInitializer {

@Bean
CommandLineRunner init(UserRepository repository) {
return args -> {
Flux<User> userFlux = Flux.just(
new User(null, "John Doe"),
new User(null, "Jane Doe"),
new User(null, "Sam Smith"))
.flatMap(repository::save);

userFlux
.thenMany(repository.findAll())
.subscribe(user -> System.out.println("Saving " + user.toString()));
};
}
}

6. Handler Functions and Route Configuration​

Create handler functions and route configurations to handle HTTP requests and return responses:

import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import reactor.core.publisher.Mono;

@Component
public class UserHandler {
private final UserRepository userRepository;

public UserHandler(UserRepository userRepository) {
this.userRepository = userRepository;
}

public Mono<ServerResponse> getUser(ServerRequest request) {
Long userId = Long.valueOf(request.pathVariable("id"));
return userRepository.findById(userId)
.flatMap(user -> ServerResponse.ok().body(Mono.just(user), User.class))
.switchIfEmpty(ServerResponse.notFound().build());
}

public Mono<ServerResponse> getAllUsers(ServerRequest request) {
return ServerResponse.ok().body(userRepository.findAll(), User.class);
}

public Mono<ServerResponse> createUser(ServerRequest request) {
Mono<User> userMono = request.bodyToMono(User.class);
return userMono.flatMap(userRepository::save)
.flatMap(user -> ServerResponse.ok().body(Mono.just(user), User.class));
}
}

@Configuration
public class RouterConfig {
@Bean
public RouterFunction<ServerResponse> route(UserHandler handler) {
return RouterFunctions.route()
.GET("/user/{id}", handler::getUser)
.GET("/users", handler::getAllUsers)
.POST("/user", handler::createUser)
.build();
}
}

Conclusion​

In this article, we explored how to perform reactive database access in Spring WebFlux. With Spring Data R2DBC, we can easily achieve non-blocking access to relational databases, greatly improving the performance and concurrency handling of applications.