分类默认分类下的文章

flatMap() operator in Webclient

作者: zorth
时间: 2025-01-01
分类: 默认分类
评论

In Spring WebClient, the `flatMap()` operator is commonly used to transform a `Mono` or `Flux` into another `Publisher` (either a `Mono` or `Flux`) and then flatten the result into a single reactive stream. This is particularly useful when you need to make a dependent asynchronous call or chain multiple WebClient calls.

Here’s how you can use `flatMap()` with WebClient:

### Example Use Case
Suppose you want to:
1. Make a WebClient call to fetch some data (e.g., user details).
2. Use the result of the first call to make another WebClient call (e.g., fetch user orders based on the user ID).

### Code Example
```java
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

public class WebClientFlatMapExample {

public static void main(String[] args) {
        WebClient webClient = WebClient.create("https://api.example.com");

// First API call to fetch user details
        Mono<String> userOrders = webClient.get()
                .uri("/users/{id}", 1) // Fetch user with ID 1
                .retrieve()
                .bodyToMono(User.class) // Deserialize response to User object
                .flatMap(user -> {
                    // Use the user ID to fetch orders
                    return webClient.get()
                            .uri("/users/{id}/orders", user.getId())
                            .retrieve()
                            .bodyToMono(String.class); // Deserialize orders as a String
                });

// Subscribe to the result
        userOrders.subscribe(
                result -> System.out.println("User Orders: " + result),
                error -> System.err.println("Error: " + error.getMessage())
        );
    }

// Example User class
    static class User {
        private int id;
        private String name;

// Getters and setters
        public int getId() {
            return id;
        }

public void setId(int id) {
            this.id = id;
        }

public String getName() {
            return name;
        }

public void setName(String name) {
            this.name = name;
        }
    }
}
```

### Explanation
1. **First WebClient Call**:
   - The first call fetches a `User` object by making a GET request to `/users/{id}`.
   - The response is deserialized into a `User` object using `bodyToMono(User.class)`.

2. **Using `flatMap()`**:
   - The `flatMap()` operator is used to take the `User` object from the first call and make another WebClient call to fetch the user's orders.
   - The second call uses the `user.getId()` to construct the URI for fetching orders.

3. **Flattening the Result**:
   - The `flatMap()` ensures that the result of the second WebClient call (a `Mono<String>`) is flattened into the reactive stream, so the final result is a single `Mono<String>`.

4. **Subscribing to the Result**:
   - The `subscribe()` method is used to consume the result or handle errors.

### Key Points
- Use `flatMap()` when the second operation depends on the result of the first operation.
- If you don’t need to make dependent calls and just want to transform the result, use `map()` instead.
- `flatMap()` is asynchronous and non-blocking, making it ideal for chaining dependent WebClient calls.

Why WebFlux Response Wrapped in a Mono

作者: zorth
时间: 2025-01-01
分类: 默认分类
评论

In reactive programming, particularly when using libraries like **Spring WebFlux**, a `WebClient` request often returns a **Mono** or **Flux** instead of a direct POJO (Plain Old Java Object). This is because WebClient is designed to work in a **non-blocking, asynchronous** manner, which is a core principle of reactive programming.

Here’s why the response is wrapped in a `Mono`:

---

### 1. **Reactive Streams and Asynchronous Nature**
   - A `Mono` represents a **single asynchronous value** or an empty result. It is part of the **Reactor library**, which implements the Reactive Streams specification.
   - When you make a request using `WebClient`, the response might not be immediately available because the operation is non-blocking. Instead of waiting (blocking) for the response, `WebClient` returns a `Mono` that will eventually emit the result (the POJO) when it becomes available.

---

### 2. **Non-Blocking I/O**
   - WebClient is built on top of **non-blocking I/O** (e.g., Netty). This means it doesn’t block the thread while waiting for the response. Instead, it returns a `Mono` that allows you to define what should happen when the response arrives.
   - This approach is more efficient than traditional blocking I/O because it allows the same thread to handle multiple requests simultaneously.

---

### 3. **Lazy Execution**
   - A `Mono` is **lazy**, meaning the actual HTTP request is not sent until you subscribe to the `Mono`. This allows you to compose and chain operations (e.g., transformations, error handling) before triggering the request.

---

### 4. **Functional Composition**
   - By returning a `Mono`, you can use functional operators like `map`, `flatMap`, `filter`, etc., to process the response in a declarative and composable way.
   - For example:
     ```java
     WebClient webClient = WebClient.create();

Mono<MyPojo> responseMono = webClient.get()
         .uri("https://api.example.com/data")
         .retrieve()
         .bodyToMono(MyPojo.class);

responseMono.map(pojo -> pojo.getSomeField())
         .subscribe(System.out::println);
     ```

---

### 5. **Error Handling**
   - A `Mono` also provides a clean way to handle errors. For example, you can use `onErrorResume` or `onErrorMap` to handle exceptions that might occur during the request or response processing.

---

### Why Not Return a POJO Directly?
If `WebClient` returned a POJO directly, it would have to block the thread until the response is received. This would defeat the purpose of using a non-blocking, reactive library like WebClient. By returning a `Mono`, the framework ensures that the application remains responsive and scalable.

---

### Summary
The `Mono` returned by `WebClient` encapsulates the asynchronous nature of the HTTP request and response. It allows you to handle the result (a POJO) in a non-blocking, reactive way, which is essential for building scalable and efficient applications in a reactive programming paradigm.

Master desires

作者: zorth
时间: 2024-12-14
分类: 默认分类
评论

Figma的模板组件被紫色边框环绕不能拖动也不能编辑

作者: zorth
时间: 2024-12-06
分类: 默认分类
评论

如果使用了Auto Layout，新tag会自动排列，但是我想要两个tag排列在同一行怎么办

作者: zorth
时间: 2024-12-05
分类: 默认分类
评论