Lists的分批次操作-EW帮帮网

Lists的分批次操作

1 方法解释

Lists.partition 方法，用于将一个列表分割成多个指定大小的子列表

Lists.partition(List list, int size) 方法接受两个参数：
list：要分割的原始列表。
size：每个子列表的大小。
该方法会将原始列表按照指定的大小分割成多个子列表，并返回一个包含这些子列表的新列表。
示例
假设我们有一个包含 10 个元素的列表，我们想将其分割成每个子列表包含 3 个元素

import com.google.common.collect.Lists;

import java.util.List;

public class PartitionExample {
    public static void main(String[] args) {
        // 创建一个包含 10 个元素的列表
        List<Integer> originalList = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用 Lists.partition 方法将列表分割成每个子列表包含 3 个元素
        List<List<Integer>> partitions = Lists.partition(originalList, 3);

        // 遍历分割后的子列表
        for (List<Integer> partition : partitions) {
            System.out.println(partition);
        }
    }
}

输出结果：

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]

2 实际业务场景

1 分批调用 CPI 系统的实现原理

借助Lists.partition方法把待处理的数据列表分割成多个规模较小的子列表，接着依次调用 CPI 系统处理这些子列表，最终汇总所有子列表的处理结果。

代码

import com.google.common.collect.Lists;
import java.util.ArrayList;
import java.util.List;

public class CPIService {

    // 模拟调用CPI系统的方法，每次最多处理3条数据
    public List<Result> callCPI(List<Request> batchRequests) {
        System.out.println("调用CPI系统，处理 " + batchRequests.size() + " 条数据");
        List<Result> results = new ArrayList<>();
        
        // 模拟处理每条数据
        for (Request request : batchRequests) {
            Result result = new Result();
            result.setRequestId(request.getId());
            result.setSuccess(true);
            results.add(result);
        }
        
        // 模拟网络延迟
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        return results;
    }

    // 分批调用CPI系统的方法
    public List<Result> batchCallCPI(List<Request> allRequests, int batchSize) {
        List<Result> allResults = new ArrayList<>();
        
        // 使用Lists.partition方法将大数据列表分割成多个小批次
        List<List<Request>> partitions = Lists.partition(allRequests, batchSize);
        
        // 依次处理每个批次
        for (List<Request> batch : partitions) {
            List<Result> batchResults = callCPI(batch);
            allResults.addAll(batchResults);
        }
        
        return allResults;
    }

    // 示例请求类
    static class Request {
        private String id;
        private String data;

        public String getId() {
            return id;
        }

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

        public String getData() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }
    }

    // 示例结果类
    static class Result {
        private String requestId;
        private boolean success;
        private String message;

        public String getRequestId() {
            return requestId;
        }

        public void setRequestId(String requestId) {
            this.requestId = requestId;
        }

        public boolean isSuccess() {
            return success;
        }

        public void setSuccess(boolean success) {
            this.success = success;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }

    public static void main(String[] args) {
        CPIService service = new CPIService();
        
        // 创建包含10个请求的列表
        List<Request> allRequests = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            Request request = new Request();
            request.setId("REQ-" + i);
            request.setData("数据" + i);
            allRequests.add(request);
        }
        
        // 分批调用CPI系统，每批处理3条数据
        List<Result> results = service.batchCallCPI(allRequests, 3);
        
        // 输出结果
        System.out.println("处理完成，共获得 " + results.size() + " 条结果");
        for (Result result : results) {
            System.out.println("请求ID: " + result.getRequestId() + ", 处理结果: " + (result.isSuccess() ? "成功" : "失败"));
        }
    }
}

2 代码解析

数据分割：
Lists.partition(allRequests, 3)把包含 10 个请求的列表分割成 4 个子列表，每个子列表分别包含 3、3、3、1 个请求。
分批处理：
借助循环依次处理各个子列表，每次处理 3 条数据。
callCPI方法模拟调用 CPI 系统，实际项目中这里会是真实的网络调用。
结果汇总：
把每个批次的处理结果添加到allResults列表中，最终得到完整的处理结果

3 实际使用优化

批次大小设定：
要依据 CPI 系统的性能和限制来确定合适的批次大小。
可以通过配置参数或者动态计算来调整批次大小。
错误处理：
要添加重试机制，对网络异常等问题进行处理。
可以采用熔断策略，防止系统崩溃。
性能优化：
可以使用多线程并发处理不同批次，提升处理速度。
考虑添加异步处理和结果回调机制。
日志监控：
记录每个批次的处理情况，方便后续排查问题。
对关键指标进行监控，如处理时间、成功率等。

通过这种分批调用的方式，能够有效避免因数据量过大导致的调用失败，同时还能提升系统的稳定性和处理效率。

Lists的分批次操作