Spring Boot 4 Complete Guide · 课时

响应式数据访问与集成

将 WebFlux 应用连接到响应式数据存储，并与其他响应式组件集成。

响应式数据访问与集成 是 CoddyKit 上的免费 Spring Boot 4 Complete Guide 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Spring Boot 4 Complete Guide 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Reactive Data Access Needs

When building reactive applications with Spring WebFlux, traditional data access methods like Spring Data JPA or plain JDBC won't work. Why?

These methods are blocking. They pause the application thread while waiting for database operations to complete. This goes against the non-blocking, asynchronous nature of reactive programming.

Introducing Reactive Data Stores

To maintain the reactive flow, we need reactive data stores and drivers that support non-blocking I/O. These drivers return Mono or Flux, allowing your application to do other work while the database processes requests.

Common reactive databases include:

MongoDB: A NoSQL document database.
Cassandra: A NoSQL wide-column store.
Redis: A NoSQL key-value store, often used for caching.
R2DBC: (Reactive Relational Database Connectivity) for relational databases like PostgreSQL, MySQL, H2.

Setting Up Reactive MongoDB

For our examples, we'll focus on MongoDB, a popular choice for reactive applications. First, you need the right dependency in your pom.xml (Maven) or build.gradle (Gradle):

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

This starter brings in Spring Data MongoDB Reactive, allowing you to easily interact with MongoDB in a non-blocking way.

Defining Reactive Entities

Just like with traditional Spring Data, you define entities that map to your database collections. For MongoDB, you use the @Document annotation.

The @Id annotation marks the primary key field. This tells Spring Data how to identify unique documents.

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

@Document(collection = "products")
public class Product {
  @Id
  private String id;
  private String name;
  private double price;

  public Product(String id, String name, double price) {
    this.id = id;
    this.name = name;
    this.price = price;
  }

  // Getters and Setters (omitted for brevity)
  public String getId() { return id; }
  public String getName() { return name; }
  public double getPrice() { return price; }

  @Override
  public String toString() {
    return "Product{id='" + id + "', name='" + name + "'}";
  }
}

Creating Reactive Repositories

To perform CRUD operations (Create, Read, Update, Delete) on your entities, you create repository interfaces. For reactive MongoDB, you extend ReactiveMongoRepository.

This interface automatically provides reactive versions of common operations, returning Mono for single results and Flux for multiple results.

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

public interface ProductRepository extends ReactiveMongoRepository<Product, String> {
  // Custom reactive query methods can be added here
  Mono<Product> findByName(String name);
  Flux<Product> findByPriceGreaterThan(double price);
}

Simulating Reactive Save

When you save an entity using a reactive repository, it returns a Mono<Product>. This Mono represents the product once it's saved. You subscribe to it to trigger the operation and handle the result.

Try running this example to see how a reactive save operation might be handled:

import reactor.core.publisher.Mono;

class Item {
  String id;
  String name;
  public Item(String id, String name) {
    this.id = id;
    this.name = name;
  }
  @Override
  public String toString() { return "Item{name='" + name + "'} "; }
}

public class Main {
  public static void main(String[] args) {
    Item newItem = new Item("101", "Reactive Widget");

    // Simulate a reactive repository save method
    Mono<Item> savedItemMono = Mono.just(newItem)
                                   .doOnSuccess(item -> System.out.println("Simulating DB save for: " + item.name));

    System.out.println("Initiating save operation...");
    savedItemMono.subscribe(
      item -> System.out.println("Saved item received: " + item),
      error -> System.err.println("Error: " + error.getMessage()),
      () -> System.out.println("Save process completed.")
    );
  }
}

Simulating Reactive Retrieval

Retrieving data reactively works similarly. For a single item (e.g., by ID), you get a Mono. For multiple items, you get a Flux. You subscribe to these publishers to consume the data.

Run this code to see how Mono and Flux are used to handle retrieved data:

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;

class User {
  String id;
  String name;
  public User(String id, String name) {
    this.id = id;
    this.name = name;
  }
  @Override
  public String toString() { return "User{name='" + name + "'} "; }
}

public class Main {
  public static void main(String[] args) {
    List<User> users = Arrays.asList(
      new User("U1", "Alice"),
      new User("U2", "Bob"),
      new User("U3", "Charlie")
    );

    // Simulate finding a single user by ID
    Mono<User> userMono = Mono.just(users.get(0));
    System.out.println("\n--- Finding single user ---");
    userMono.subscribe(user -> System.out.println("Found: " + user));

    // Simulate finding all users
    Flux<User> userFlux = Flux.fromIterable(users);
    System.out.println("\n--- Finding all users ---");
    userFlux.subscribe(user -> System.out.println("Found: " + user));
  }
}

Integrating with Reactive Services

In a Spring WebFlux application, your service layer will inject the reactive repositories and use their Mono and Flux return types. This allows for seamless chaining of reactive operations.

For example, a service method might save a product and then return the saved product's ID, all within a reactive stream.

import reactor.core.publisher.Mono;
// Assume Product and ProductRepository are defined elsewhere
// import your.package.Product;
// import your.package.ProductRepository;

// This is a simplified example, not a full runnable app
// as it would require a full Spring Boot context.
class ProductService {
  private final ProductRepository productRepository;

  public ProductService(ProductRepository productRepository) {
    this.productRepository = productRepository;
  }

  public Mono<String> createProduct(Product product) {
    return productRepository.save(product)
                            .map(Product::getId);
  }

  public Mono<Product> getProductById(String id) {
    return productRepository.findById(id);
  }
}

Chaining Reactive Data Operations

The true power of reactive data access comes when you chain operations. You can transform, filter, and combine Mono and Flux streams from your database with other reactive sources (like external API calls or other service logic).

This allows you to build complex, non-blocking data flows efficiently.

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;

public class Main {
  public static void main(String[] args) {
    // Simulate fetching user IDs from a database (Flux)
    Flux<String> userIds = Flux.just("userA", "userB", "userC");

    // Simulate fetching user details for each ID (Mono)
    Flux<String> userNames = userIds.delayElements(Duration.ofMillis(50))
                                    .flatMap(id -> Mono.just("Name_" + id.toUpperCase()));

    System.out.println("Fetching and transforming user data...");
    userNames.subscribe(
      name -> System.out.println("Processed User: " + name),
      error -> System.err.println("Error: " + error.getMessage()),
      () -> System.out.println("All users processed.")
    );

    // Keep main thread alive for async operations
    try { Thread.sleep(500); } catch (InterruptedException e) {} 
  }
}

Quick Check: Reactive Repositories

You are building a Spring WebFlux application and need to connect to a MongoDB database in a non-blocking way. Which Spring Data interface should you extend for your repository to get reactive CRUD operations?

Recap: Reactive Data Access

Great job! In this lesson, you've learned about the importance of reactive data access in Spring WebFlux applications and how to achieve it.

Traditional blocking data access is replaced by non-blocking reactive drivers.
Spring Data provides interfaces like ReactiveMongoRepository for reactive CRUD.
These repositories return Mono (for single items) and Flux (for multiple items).
You can seamlessly chain reactive operations from data access with other reactive components.

This knowledge is key to building truly end-to-end reactive applications!

常见问题解答

「响应式数据访问与集成」课时是免费的吗？

是的 — 「响应式数据访问与集成」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Spring Boot 4 Complete Guide 课程的其余内容，请升级到 CoddyKit PRO。 Spring Boot 4 Complete Guide 课程共包含 4 节课。

「响应式数据访问与集成」这节课中我会学到什么？

将 WebFlux 应用连接到响应式数据存储，并与其他响应式组件集成。你通过在浏览器中直接运行的动手代码来练习 Spring Boot 4 Complete Guide，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Spring Boot 4 Complete Guide 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Spring Boot 4 Complete Guide 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「响应式数据访问与集成」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Spring Boot 4 Complete Guide 课中编写并运行代码吗？

能。每节 Spring Boot 4 Complete Guide 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Spring Boot 4 Complete Guide