优化Java数据批量获取：利用Stream API避免共享可变性

// 假设 Cat 和 Dog 是实体类，catRepo 和 dogRepo 是数据访问层接口
// CatRepo 和 DogRepo 都有 fetchCats(List<Integer>) 和 fetchDogs(List<Integer>) 方法

AtomicInteger counter = new AtomicInteger();
List<Cat> catList = new ArrayList<>(); // 共享的可变列表
List<Dog> dogList = new ArrayList<>(); // 共享的可变列表

// 模拟生成5000个数字作为查询键
List<Integer> numbers = Stream.iterate(1, e -> e + 1)
    .limit(5000)
    .collect(Collectors.toList());

// 将数字列表分割成每批次500个的小列表
Collection<List<Integer>> partitionedListOfNumbers = numbers.stream()
    .collect(Collectors.groupingBy(num -> counter.getAndIncrement() / 500))
    .values(); // 得到 List<List<Integer>> 结构

// 遍历分批的列表，执行查询并累加结果
partitionedListOfNumbers.stream()
    .forEach(list -> {
        List<Cat> interimCatList = catRepo.fetchCats(list); // 从数据库获取猫列表
        catList.addAll(interimCatList); // 修改外部的 catList
        List<Dog> interimDogList = dogRepo.fetchDogs(list); // 从数据库获取狗列表
        dogList.addAll(interimDogList); // 修改外部的 dogList
    });

// 此时 catList 和 dogList 包含了所有查询结果

import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.function.Function; // 用于后续优化

// 假设 Cat, Dog, CatRepo, DogRepo 已经定义
// ... (Cat, Dog 实体类及 CatRepo, DogRepo 接口的定义)

public class BatchDataFetcher {

    // 假设 catRepo 和 dogRepo 已经通过依赖注入或其他方式初始化
    private CatRepo catRepo;
    private DogRepo dogRepo;

    public BatchDataFetcher(CatRepo catRepo, DogRepo dogRepo) {
        this.catRepo = catRepo;
        this.dogRepo = dogRepo;
    }

    public void fetchDataAndProcess() {
        // 用于分批的计数器，确保每个批次编号正确
        AtomicInteger counter = new AtomicInteger(); 

        // 模拟生成5000个数字，并将其分批
        // IntStream.rangeClosed(1, 5000) 生成从1到5000的整数流
        // .boxed() 将 IntStream 转换为 Stream<Integer>
        Collection<List<Integer>> partitionedListOfNumbers = IntStream.rangeClosed(1, 5000)
            .boxed() 
            .collect(Collectors.groupingBy(num -> counter.getAndIncrement() / 500))
            .values(); // 得到 List<List<Integer>> 结构

        // 获取所有猫列表
        List<Cat> catList = partitionedListOfNumbers.stream()
            .map(list -> catRepo.fetchCats(list)) // 对每个分批列表执行查询，得到 Stream<List<Cat>>
            .flatMap(List::stream) // 将 Stream<List<Cat>> 扁平化为 Stream<Cat>
            .collect(Collectors.toList()); // 收集所有 Cat 对象到一个新的 List 中

        // 获取所有狗列表
        List<Dog> dogList = partitionedListOfNumbers.stream()
            .map(list -> dogRepo.fetchDogs(list)) // 对每个分批列表执行查询，得到 Stream<List<Dog>>
            .flatMap(List::stream) // 将 Stream<List<Dog>> 扁平化为 Stream<Dog>
            .collect(Collectors.toList()); // 收集所有 Dog 对象到一个新的 List 中

        // 此时 catList 和 dogList 是通过 Stream 操作“生成”的，而不是“修改”的
        // 它们是不可变的（如果 collect 收集到的是不可变列表，否则是新的可变列表，但不再是共享的）
        System.out.println("Fetched " + catList.size() + " cats and " + dogList.size() + " dogs.");
    }
}

// 模拟 Cat, Dog, CatRepo, DogRepo
class Cat { private int id; private String name; public Cat(int id, String name) { this.id = id; this.name = name; } @Override public String toString() { return "Cat{" + "id=" + id + ", name='" + name + '\'' + '}'; } }
class Dog { private int id; private String name; public Dog(int id, String name) { this.id = id; this.name = name; } @Override public String toString() { return "Dog{" + "id=" + id + ", name='" + name + '\'' + '}'; } }
class CatRepo { public List<Cat> fetchCats(List<Integer> ids) { return ids.stream().map(id -> new Cat(id, "Cat-" + id)).collect(Collectors.toList()); } }
class DogRepo { public List<Dog> fetchDogs(List<Integer> ids) { return ids.stream().map(id -> new Dog(id, "Dog-" + id)).collect(Collectors.toList()); } }

// 示例运行
// public static void main(String[] args) {
//     BatchDataFetcher fetcher = new BatchDataFetcher(new CatRepo(), new DogRepo());
//     fetcher.fetchDataAndProcess();
// }

public class BatchDataFetcher {
    // ... (构造函数和成员变量不变)

    /**
     * 通用方法：根据分批的键列表和查询函数批量获取数据
     * @param partitionedKeys 分批的查询键列表
     * @param fetchFunction 接受一个 List<K> 并返回 List<T> 的查询函数
     * @param <T> 结果列表中的元素类型
     * @param <K> 查询键列表中的元素类型
     * @return 聚合后的所有 T 类型元素的列表
     */
    public <T, K> List<T> fetchEntitiesInBatches(Collection<List<K>> partitionedKeys, Function<List<K>, List<T>> fetchFunction) {
        return partitionedKeys.stream()
            .map(fetchFunction) // 对每个批次应用查询函数
            .flatMap(List::stream) // 扁平化结果
            .collect(Collectors.toList()); // 收集到新列表
    }

    public void fetchDataAndProcessOptimized() {
        AtomicInteger counter = new AtomicInteger();
        Collection<List<Integer>> partitionedListOfNumbers = IntStream.rangeClosed(1, 5000)
            .boxed()
            .collect(Collectors.groupingBy(num -> counter.getAndIncrement() / 500))
            .values();

        // 使用通用方法获取猫列表
        List<Cat> catList = fetchEntitiesInBatches(partitionedListOfNumbers, catRepo::fetchCats);

        // 使用通用方法获取狗列表
        List<Dog> dogList = fetchEntitiesInBatches(partitionedListOfNumbers, dogRepo::fetchDogs);

        System.out.println("Optimized: Fetched " + catList.size() + " cats and " + dogList.size() + " dogs.");
    }
}