Java 正在从多个碎片获取数据

我试图构建一个简单的应用程序，从AWS Kinesis读取数据。我已经设法使用单个碎片读取数据，但我想从4个不同的碎片获取数据

问题是，我有一个while循环，只要碎片处于活动状态，它就会迭代，这会阻止我从不同的碎片读取数据。到目前为止，我找不到替代算法，也无法实现基于KCL的解决方案。 非常感谢

public static void DoSomething() {
        AmazonKinesisClient client = new AmazonKinesisClient();
        //noinspection deprecation
        client.setEndpoint(endpoint, serviceName, regionId);  
        /** get shards from the stream using describe stream method*/

        DescribeStreamRequest describeStreamRequest = new DescribeStreamRequest();
        describeStreamRequest.setStreamName(streamName);
        List<Shard> shards = new ArrayList<>();
        String exclusiveStartShardId = null;
        do {
            describeStreamRequest.setExclusiveStartShardId(exclusiveStartShardId);
            DescribeStreamResult describeStreamResult = client.describeStream(describeStreamRequest);
            shards.addAll(describeStreamResult.getStreamDescription().getShards());
            if (describeStreamResult.getStreamDescription().getHasMoreShards() && shards.size() > 0) {
                exclusiveStartShardId = shards.get(shards.size() - 1).getShardId();
            } else {
                exclusiveStartShardId = null;
            }
        }while (exclusiveStartShardId != null);

        /** shards obtained */
        String shardIterator;

        GetShardIteratorRequest getShardIteratorRequest = new GetShardIteratorRequest();
        getShardIteratorRequest.setStreamName(streamName);
        getShardIteratorRequest.setShardId(shards.get(0).getShardId());
        getShardIteratorRequest.setShardIteratorType("LATEST"); 

        GetShardIteratorResult getShardIteratorResult = client.getShardIterator(getShardIteratorRequest);
        shardIterator = getShardIteratorResult.getShardIterator();
        GetRecordsRequest getRecordsRequest = new GetRecordsRequest();

        while (!shardIterator.equals(null)) {
            getRecordsRequest.setShardIterator(shardIterator);
            getRecordsRequest.setLimit(250);
            GetRecordsResult getRecordsResult = client.getRecords(getRecordsRequest);
            List<Record> records = getRecordsResult.getRecords();

            shardIterator = getRecordsResult.getNextShardIterator();
            if(records.size()!=0) {
                for(Record r : records) {
                    System.out.println(r.getPartitionKey());
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
        }
    }

publicstaticvoiddosomething（）{
AmazonKinesisClient=新的AmazonKinesClient（）；
//无检查弃用
setEndpoint（端点、serviceName、regionId）；
/**使用描述流方法从流中获取碎片*/
DescribeStreamRequest DescribeStreamRequest=新的DescribeStreamRequest（）；
describeStreamRequest.setStreamName（流名称）；
列表碎片=新的ArrayList（）；
字符串exclusiveStartShardId=null；
做{
descripbeStreamRequest.setExclusiveStartShardId（exclusiveStartShardId）；
DescribeStreamResult DescribeStreamResult=client.describeStream（describeStreamRequest）；
addAll（descripbeStreamResult.getStreamDescription（）.getShards（））；
if（descripbeStreamResult.getStreamDescription（）.getHasMoreShards（）&&shards.size（）>0）{
exclusiveStartShardId=shards.get（shards.size（）-1.getShardId（）；
}否则{
exclusiveStartShardId=null；
}
}while（exclusiveStartShardId！=null）；
/**获得碎片*/
串切碎器；
GetShardIteratorRequest GetShardIteratorRequest=新建GetShardIteratorRequest（）；
getShardIteratorRequest.setStreamName（流名称）；
getShardIteratorRequest.setShardId（shards.get（0.getShardId（））；
getShardIteratorRequest.setHardIteratorType（“最新”）；
GetShardIteratorResult GetShardIteratorResult=client.getShardIterator（getShardIteratorRequest）；
shardIterator=getShardIteratorResult.getShardIterator（）；
GetRecordsRequest GetRecordsRequest=新建GetRecordsRequest（）；
而（！shardIterator.equals（null））{
getRecordsRequest.setShare迭代器（shardIterator）；
getRecordsRequest.setLimit（250）；
GetRecordsResult GetRecordsResult=client.getRecords（getRecordsRequest）；
列表记录=getRecordsResult.getRecords（）；
shardIterator=getRecordsResult.getNextSharedIterator（）；
如果（records.size（）！=0）{
用于（记录r：记录）{
System.out.println（r.getPartitionKey（））；
}
}
试一试{
睡眠（1000）；
}捕捉（中断异常e）{
}
}
}

建议不要从多个碎片中读取单个进程/工作进程。首先，正如您所看到的，它增加了代码的复杂性，但更重要的是，在扩展时会遇到问题

可扩展性的“秘密”是拥有小型独立的工作人员或其他类似单位。这种设计可以在Hadoop、DynamoDB或AWS中的Kinesis中看到。它允许您构建小型系统（微型服务），可以根据需要轻松地上下扩展。随着您的服务变得更加成功，或者使用率出现其他波动，您可以轻松添加更多的工作/数据单元

正如您在这些AWS服务中所看到的，有时您可以在DynamoDB中自动获得这种可伸缩性，有时您需要将碎片添加到您的kinesis流中。但对于您的应用程序，您需要以某种方式控制您的可伸缩性

对于Kinesis，可以使用AWS Lambda或Kinesis客户端库（KCL）进行上下缩放。它们都在监听流的状态（碎片和事件的数量），并使用它来添加或删除工人，并将事件交付给他们处理。在这两种解决方案中，您都应该构建一个针对单个碎片的工作者

---

如果需要对齐多个碎片中的事件，可以使用一些状态服务，如Redis或DynamoDB

对于一个更简单、更整洁的解决方案，您只需担心提供自己的消息处理代码，我建议您使用KCL库

引述

KCL充当记录处理逻辑之间的中介 和运动数据流。KCL执行以下任务：

• 连接到数据流
• 枚举数据流中的碎片
• 使用租约来协调碎片与其工作程序的关联
• 为它管理的每个碎片实例化一个记录处理器
• 从数据流中提取数据记录
• 将记录推送到相应的记录处理器
• 检查点处理记录
• 在工作实例计数更改或数据流重新硬存储（碎片被拆分或合并）时平衡碎片工作关联（租约）

---

问题是我无法读取任何数据，甚至在使用worker时无法检索碎片。想要使用“ConsumerShard”方法，但还不够。我尝试为kinesis应用程序定制aws示例，但是它太依赖DynamoDB了。我不想将我的对象或计数数保存到dynamo表中。