Iterable＜Result＜Item＞＞讲一下

好的，Iterable<Result<Item>> 是 MinIO Java SDK 中用于处理列表结果的典型模式，我来详细解释：

1. 三层结构分解

1Iterable<Result<Item>> results = minioClient.listObjects(...);
2

拆解理解：

Iterable<> - 可遍历的容器
Result<Item> - 包含实际结果的对象
Item - 真正的对象信息

2. 逐层理解

第一层：Iterable - 可迭代对象

1// 就像是一个装了很多东西的盒子，你可以逐个取出
2Iterable<Result<Item>> results = ...;
3
4// 可以用 for-each 循环遍历
5for (Result<Item> result : results) {
6    // 处理每个结果
7}
8

第二层：Result - 结果包装器

1// Result 是一个包装类，里面包含真正的 Item 或异常
2Result<Item> result = ...;
3
4// 需要调用 .get() 方法获取真正的 Item
5Item item = result.get(); // 这里可能抛出异常
6

第三层：Item - 实际的对象信息

1// Item 包含对象的详细信息
2Item item = result.get();
3String objectName = item.objectName();    // 对象名称
4long size = item.size();                  // 对象大小
5Date lastModified = item.lastModified();  // 最后修改时间
6

3. 完整使用示例

1import io.minio.*;
2import io.minio.messages.Item;
3
4public void listObjects() {
5    try {
6        // 1. 获取对象列表
7        Iterable<Result<Item>> results = minioClient.listObjects(
8            ListObjectsArgs.builder()
9                .bucket("my-bucket")
10                .prefix("documents/")
11                .recursive(true)
12                .build()
13        );
14        
15        // 2. 遍历结果
16        for (Result<Item> result : results) {
17            try {
18                // 3. 从Result中获取Item
19                Item item = result.get();
20                
21                // 4. 使用Item信息
22                System.out.println("对象名: " + item.objectName());
23                System.out.println("大小: " + item.size() + " bytes");
24                System.out.println("最后修改: " + item.lastModified());
25                System.out.println("---");
26                
27            } catch (Exception e) {
28                System.err.println("获取对象信息失败: " + e.getMessage());
29            }
30        }
31        
32    } catch (Exception e) {
33        e.printStackTrace();
34    }
35}
36

4. 为什么这样设计？

懒加载和流式处理

1// 不是一次性加载所有对象，而是按需加载
2// 适合处理大量对象，避免内存溢出
3Iterable<Result<Item>> results = minioClient.listObjects(...);
4
5// 遍历时才开始真正从服务器获取数据
6for (Result<Item> result : results) {
7    // 每次循环可能都会发起网络请求获取下一个对象
8    Item item = result.get();
9}
10

异常处理

1for (Result<Item> result : results) {
2    try {
3        Item item = result.get(); // 可能因为网络问题失败
4        // 处理对象...
5    } catch (Exception e) {
6        // 单个对象失败不影响其他对象处理
7        System.err.println("处理对象失败，继续下一个: " + e.getMessage());
8    }
9}
10

5. 实际项目中的写法

1public void processObjects(String bucketName, String prefix) {
2    try {
3        Iterable<Result<Item>> results = minioClient.listObjects(
4            ListObjectsArgs.builder()
5                .bucket(bucketName)
6                .prefix(prefix)
7                .recursive(true)
8                .build());
9        
10        List<String> objectNames = new ArrayList<>();
11        
12        for (Result<Item> result : results) {
13            try {
14                Item item = result.get();
15                if (!item.isDir()) {  // 排除文件夹
16                    objectNames.add(item.objectName());
17                    System.out.println("找到对象: " + item.objectName());
18                }
19            } catch (Exception e) {
20                log.error("读取对象信息失败", e);
21            }
22        }
23        
24        log.info("共找到 {} 个对象", objectNames.size());
25        
26    } catch (Exception e) {
27        log.error("列出对象失败", e);
28    }
29}
30

一句话总结：

Iterable<Result<Item>> 是一个"懒加载的、安全的对象列表"，需要遍历 → 解包 → 使用，适合处理大量MinIO对象。

《Iterable＜Result＜Item＞＞讲一下》是转载文章，点击查看原文。