Project Reactor：在Mono中将Flux聚合为List属性

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

// Item 类定义
class Item {
    private String name;

    public Item(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Item{" + "name='" + name + '\'' + '}';
    }
}

// Person 类定义，包含一个 List<Item> 属性
class Person {
    private List<Item> items;

    public Person() {
        // 可以在构造函数中初始化列表，或者在设置时处理
    }

    public Person(List<Item> items) {
        this.items = items;
    }

    public List<Item> getItems() {
        return items;
    }

    public void setItems(List<Item> items) {
        this.items = items;
    }

    @Override
    public String toString() {
        return "Person{" + "items=" + items + '}';
    }
}

// 模拟服务层接口，返回 Flux<Item>
interface ItemService {
    Flux<Item> getItems();
}

// ItemService 的具体实现
class MyItemService implements ItemService {
    @Override
    public Flux<Item> getItems() {
        // 模拟异步获取 Item 列表，每个 Item 之间有延迟
        return Flux.just(new Item("Laptop"), new Item("Mouse"), new Item("Keyboard"))
                   .delayElements(Duration.ofMillis(100)); // 模拟异步延迟
    }
}

public class FluxToListInMonoExample {

    private final ItemService itemService = new MyItemService(); // 注入服务

    /**
     * 创建一个 Mono<Person>，其中 Person 对象的 items 属性通过聚合 Flux<Item> 得到。
     *
     * @return 包含聚合后 Item 列表的 Mono<Person>
     */
    public Mono<Person> createPersonWithCollectedItems() {
        // 1. 从服务层获取一个 Flux<Item> 数据流
        Flux<Item> itemFlux = itemService.getItems();

        // 2. 使用 collectList() 操作符将 Flux<Item> 聚合成 Mono<List<Item>>
        //    这个 Mono 会在 itemFlux 发出所有 Item 后，发布一个包含所有 Item 的 List。
        Mono<List<Item>> collectedItemsMono = itemFlux.collectList();

        // 3. 使用 map() 操作符将 Mono<List<Item>> 转换为 Mono<Person>
        //    当 List<Item> 可用时，创建一个 Person 对象并设置其 items 属性。
        Mono<Person> personMono = collectedItemsMono.map(itemList -> {
            Person person = new Person(); // 创建一个新的 Person 实例
            person.setItems(itemList);    // 将收集到的 List<Item> 设置给 Person 对象
            return person;                // 返回包含 List<Item> 的 Person 对象
        });

        return personMono;
    }

    public static void main(String[] args) {
        FluxToListInMonoExample example = new FluxToListInMonoExample();

        System.out.println("开始聚合 Item 并创建 Person 对象...");
        example.createPersonWithCollectedItems()
                .doOnNext(person -> {
                    System.out.println("成功创建 Person 对象: " + person);
                    if (person.getItems() != null && !person.getItems().isEmpty()) {
                        System.out.println("包含的 Item 数量: " + person.getItems().size());
                        person.getItems().forEach(item -> System.out.println(" - " + item.getName()));
                    } else {
                        System.out.println("Person 对象不包含任何 Item 或列表为空。");
                    }
                })
                .doOnError(error -> System.err.println("处理过程中发生错误: " + error.getMessage()))
                .block(); // 阻塞等待结果，仅用于示例演示，生产代码中应避免使用 block()
        System.out.println("操作完成。");
    }
}