通过订阅（Subscription）从 HStreamDB 消费数据

什么是一个订阅（Subscription）?

要从一个 stream 中消费数据，你必须为该 stream 创建一个订阅。创建成功后，每个订阅 都将从头开始检索数据。接收和处理消息的消费者（consumer）通过一个订阅与一个 stream 相关联。

一个 stream 可以有多个订阅，但一个给定的订阅只属于一个 stream。同样地，一个订阅 对应一个具有多个消费者的 consumer group，但每个消费者只属于一个订阅。

请参考这个页面，了解关于创建和管理订阅的详细信息。

如何用一个订阅来消费数据

为了消费写入 stream 中的数据，HStreamDB 客户端库提供了异步 Consumer API，它将发 起请求加入指定订阅的 consumer group。

两种 HStream 记录类型和相应的 Receiver

正如我们所介绍的，在 HStreamDB 中有两种 Record 类型，HRecord 和 Raw Record。当启 动一个消费者时，需要相应的 Receiver。在只设置了 HRecord Receiver 的情况下，当消 费者收到一条 raw record 时，消费者将忽略它并消费下一条 record。因此，原则上，我 们不建议在同一个 stream 中同时写入 HRecord 和 raw record。然而，这并没有在实现的 层面上严格禁止，用户仍然可以提供两种 receiver 来同时处理两种类型的 record。

简单的数据消费实例

异步的 Consumer API 不需要你的应用程序为新到来的 record 进行阻塞，可以让你的应用 程序获得更高的吞吐量。Records 可以在你的应用程序中使用一个长期运行的 records receiver 来接收，并逐条 ack，如下面的例子中所示。

  1. // ConsumeDataSimpleExample.java
  3. package docs.code.examples;
  5. import static java.util.concurrent.TimeUnit.SECONDS;
  7. import io.hstream.Consumer;
  8. import io.hstream.HRecordReceiver;
  9. import io.hstream.HStreamClient;
  10. import java.util.concurrent.TimeoutException;
  12. public class ConsumeDataSimpleExample {
  13.   public static void main(String[] args) throws Exception {
  14.     String serviceUrl = "127.0.0.1:6570";
  15.     if (System.getenv("serviceUrl") != null) {
  16.       serviceUrl = System.getenv("serviceUrl");
  17.     }
  19.     String subscriptionId = "your_subscription_id";
  20.     HStreamClient client = HStreamClient.builder().serviceUrl(serviceUrl).build();
  21.     consumeDataFromSubscriptionExample(client, subscriptionId);
  22.     client.close();
  23.   }
  25.   public static void consumeDataFromSubscriptionExample(
  26.       HStreamClient client, String subscriptionId) {
  27.     HRecordReceiver receiver =
  28.         ((hRecord, responder) -> {
  29.           System.out.println("Received a record :" + hRecord.getHRecord());
  30.           responder.ack();
  31.         });
  32.     // Consumer is a Service(ref:
  33.     // https://guava.dev/releases/19.0/api/docs/com/google/common/util/concurrent/Service.html)
  34.     Consumer consumer =
  35.         client
  36.             .newConsumer()
  37.             .subscription(subscriptionId)
  38.             // optional, if it is not set, client will generate a unique id.
  39.             .name("consumer_1")
  40.             .hRecordReceiver(receiver)
  41.             .build();
  42.     // start Consumer as a background service and return
  43.     consumer.startAsync().awaitRunning();
  44.     try {
  45.       // sleep 5s for consuming records
  46.       consumer.awaitTerminated(5, SECONDS);
  47.     } catch (TimeoutException e) {
  48.       // stop consumer
  49.       consumer.stopAsync().awaitTerminated();
  50.     }
  51.   }
  52. }
  1. // ExampleConsumer.go
  3. package examples
  5. import (
  6.     "github.com/hstreamdb/hstreamdb-go/hstream"
  7.     "log"
  8.     "time"
  9. )
  11. func ExampleConsumer() error {
  12.     client, err := hstream.NewHStreamClient(YourHStreamServiceUrl)
  13.     if err != nil {
  14.         log.Fatalf("Creating client error: %s", err)
  15.     }
  16.     defer client.Close()
  18.     subId := "SubscriptionId0"
  19.     consumer := client.NewConsumer("consumer-1", subId)
  20.     defer consumer.Stop()
  22.     dataChan := consumer.StartFetch()
  23.     timer := time.NewTimer(3 * time.Second)
  24.     defer timer.Stop()
  26.     for {
  27.         select {
  28.         case <-timer.C:
  29.             log.Println("[consumer]: Streaming fetch stopped")
  30.             return nil
  31.         case recordMsg := <-dataChan:
  32.             if recordMsg.Err != nil {
  33.                 log.Printf("[consumer]: Streaming fetch error: %s", err)
  34.                 continue
  35.             }
  37.             for _, record := range recordMsg.Result {
  38.                 log.Printf("[consumer]: Receive %s record: record id = %s, payload = %+v",
  39.                     record.GetRecordType(), record.GetRecordId().String(), record.GetPayload())
  40.                 record.Ack()
  41.             }
  42.         }
  43.     }
  45.     return nil
  46. }
  1. # https://github.com/hstreamdb/hstreamdb-py/blob/main/examples/snippets/guides.py
  2. import asyncio
  3. import hstreamdb
  4. import os
  6. # NOTE: Replace with your own host and port
  7. host = os.getenv("GUIDE_HOST", "127.0.0.1")
  8. port = os.getenv("GUIDE_PORT", 6570)
  9. stream_name = "your_stream"
  10. subscription = "your_subscription"
  13. # Run: asyncio.run(main(your_async_function))
  14. async def main(*funcs):
  15.     async with await hstreamdb.insecure_client(host=host, port=port) as client:
  16.         for f in funcs:
  17.             await f(client)
  20. class Processing:
  21.     count = 0
  22.     max_count: int
  24.     def __init__(self, max_count):
  25.         self.max_count = max_count
  27.     async def __call__(self, ack_fun, stop_fun, rs_iter):
  28.         print("max_count", self.max_count)
  29.         rs = list(rs_iter)
  30.         for r in rs:
  31.             self.count += 1
  32.             print(f"[{self.count}] Receive: {r}")
  33.             if self.max_count > 0 and self.count >= self.max_count:
  34.                 await stop_fun()
  35.                 break
  37.         await ack_fun(r.id for r in rs)
  40. async def subscribe_records(client):
  41.     consumer = client.new_consumer("new_consumer", subscription, Processing(10))
  42.     await consumer.start()

For better performance, Batched Ack is enabled by default with setting ackBufferSize = 100 and ackAgeLimit = 100, which you can change when initiating your consumers.

  1. Consumer consumer =
  2.     client
  3.         .newConsumer()
  4.         .subscription("you_subscription_id")
  5.         .name("your_consumer_name")
  6.         .hRecordReceiver(your_receiver)
  7.         // When ack() is called, the consumer will not send it to servers immediately,
  8.         // the ack request will be buffered until the ack count reaches ackBufferSize
  9.         // or the consumer is stopping or reached ackAgelimit
  10.         .ackBufferSize(100)
  11.         .ackAgeLimit(100)
  12.         .build();

为了获得更好的性能，默认情况下启用了 Batched Ack，和 ackBufferSize = 100 和 ackAgeLimit = 100 的设置，你可以在启动你的消费者时更新它。

  1. Consumer consumer =
  2.     client
  3.         .newConsumer()
  4.         .subscription("you_subscription_id")
  5.         .name("your_consumer_name")
  6.         .hRecordReceiver(your_receiver)
  7.         // When ack() is called, the consumer will not send it to servers immediately,
  8.         // the ack request will be buffered until the ack count reaches ackBufferSize
  9.         // or the consumer is stopping or reached ackAgelimit
  10.         .ackBufferSize(100)
  11.         .ackAgeLimit(100)
  12.         .build();

多个消费者和共享订阅

如先前提到的，在 HStream 中，一个订阅是对应了一个 consumer group 消费的。在这个 consumer group 中，可能会有多个消费者，并且他们共享订阅的进度。当想要提高从订阅 中消费数据的速度时，我们可以让一个新的消费者加入现有的订阅。这段代码是用来演示新 的消费者是如何加入 consumer group 的。更常见的情况是，用户使用来自不同客户端的消 费者去共同消费一个订阅。

  1. // ConsumeDataSharedExample.java
  3. package docs.code.examples;
  5. import static java.util.concurrent.TimeUnit.SECONDS;
  7. import io.hstream.Consumer;
  8. import io.hstream.HRecordReceiver;
  9. import io.hstream.HStreamClient;
  10. import java.util.concurrent.TimeoutException;
  12. public class ConsumeDataSharedExample {
  13.   public static void main(String[] args) throws Exception {
  14.     String serviceUrl = "127.0.0.1:6570";
  15.     if (System.getenv("serviceUrl") != null) {
  16.       serviceUrl = System.getenv("serviceUrl");
  17.     }
  19.     String subscription = "your_subscription_id";
  20.     String consumer1 = "your_consumer1_name";
  21.     String consumer2 = "your_consumer2-name";
  22.     HStreamClient client = HStreamClient.builder().serviceUrl(serviceUrl).build();
  24.     // create two consumers to consume records with several partition keys.
  25.     Thread t1 =
  26.         new Thread(() -> consumeDataFromSubscriptionSharedExample(client, subscription, consumer1));
  27.     Thread t2 =
  28.         new Thread(() -> consumeDataFromSubscriptionSharedExample(client, subscription, consumer2));
  29.     t1.start();
  30.     t2.start();
  31.     t1.join();
  32.     t2.join();
  33.     client.close();
  34.   }
  36.   public static void consumeDataFromSubscriptionSharedExample(
  37.       HStreamClient client, String subscription, String consumerName) {
  38.     HRecordReceiver receiver =
  39.         ((hRecord, responder) -> {
  40.           System.out.println("Received a record :" + hRecord.getHRecord());
  41.           responder.ack();
  42.         });
  43.     Consumer consumer =
  44.         client
  45.             .newConsumer()
  46.             .subscription(subscription)
  47.             .name(consumerName)
  48.             .hRecordReceiver(receiver)
  49.             .build();
  50.     try {
  51.       // sleep 5s for consuming records
  52.       consumer.startAsync().awaitRunning();
  53.       consumer.awaitTerminated(5, SECONDS);
  54.     } catch (TimeoutException e) {
  55.       // stop consumer
  56.       consumer.stopAsync().awaitTerminated();
  57.     }
  58.   }
  59. }
  1. // ExampleConsumerGroup.go
  3. package examples
  5. import (
  6.     "github.com/hstreamdb/hstreamdb-go/hstream"
  7.     "log"
  8.     "sync"
  9.     "time"
  10. )
  12. func ExampleConsumerGroup() error {
  13.     client, err := hstream.NewHStreamClient(YourHStreamServiceUrl)
  14.     if err != nil {
  15.         log.Fatalf("Creating client error: %s", err)
  16.     }
  17.     defer client.Close()
  19.     subId1 := "SubscriptionId1"
  21.     var wg sync.WaitGroup
  22.     wg.Add(2)
  24.     go func() {
  25.         consumer := client.NewConsumer("consumer-1", subId1)
  26.         defer consumer.Stop()
  27.         timer := time.NewTimer(5 * time.Second)
  28.         defer timer.Stop()
  29.         defer wg.Done()
  31.         dataChan := consumer.StartFetch()
  32.         for {
  33.             select {
  34.             case <-timer.C:
  35.                 log.Println("[consumer-1]: Stream fetching stopped")
  36.                 return
  37.             case recordMsg := <-dataChan:
  38.                 if recordMsg.Err != nil {
  39.                     log.Printf("[consumer-1]: Stream fetching error: %s", err)
  40.                     continue
  41.                 }
  43.                 for _, record := range recordMsg.Result {
  44.                     log.Printf("[consumer-1]: Receive %s record: record id = %s, payload = %+v",
  45.                         record.GetRecordType(), record.GetRecordId().String(), record.GetPayload())
  46.                     record.Ack()
  47.                 }
  48.             }
  49.         }
  50.     }()
  52.     go func() {
  53.         consumer := client.NewConsumer("consumer-2", subId1)
  54.         defer consumer.Stop()
  55.         timer := time.NewTimer(5 * time.Second)
  56.         defer timer.Stop()
  57.         defer wg.Done()
  59.         dataChan := consumer.StartFetch()
  60.         for {
  61.             select {
  62.             case <-timer.C:
  63.                 log.Println("[consumer-2]: Stream fetching stopped")
  64.                 return
  65.             case recordMsg := <-dataChan:
  66.                 if recordMsg.Err != nil {
  67.                     log.Printf("[consumer-2]: Stream fetching error: %s", err)
  68.                     continue
  69.                 }
  71.                 for _, record := range recordMsg.Result {
  72.                     log.Printf("[consumer-2]: Receive %s record: record id = %s, payload = %+v",
  73.                         record.GetRecordType(), record.GetRecordId().String(), record.GetPayload())
  74.                     record.Ack()
  75.                 }
  76.             }
  77.         }
  78.     }()
  80.     wg.Wait()
  82.     return nil
  83. }

使用 maxUnackedRecords 的来实现流控

一个常发生的状况是，消费者处理和确认数据的速度很可能跟不上服务器发送的速度，或者 一些意外的问题导致消费者无法确认收到的数据，这可能会导致以下问题：

服务器将不得不不断重发未确认的消息，并维护未确认的消息的信息，这将消耗服务器的资 源，并导致服务器面临资源耗尽的问题。

为了缓解上述问题，使用订阅的 maxUnackedRecords 设置来控制消费者接收消息时允许 的未确认 records 的最大数量。一旦数量超过 maxUnackedRecords，服务器将停止向当 前订阅的消费者们发送消息。

按顺序接收消息

注意：下面描述的接收顺序只针对单个消费者。如果一个订阅有多个消费者，在每个消费者 中仍然可以保证顺序，但如果我们把 consumer group 看成一个整体，那么顺序性就不再保 证了。

消费者将按照 HStream 服务器收到信息的顺序接收具有相同分区键的 record。由于 HStream 以至少一次的语义发送 hstream record，在某些情况下，当 HServer 可能没有收 到中间某些 record 的 ack 时，它将可能多次发送这条 record。而在这些情况下，我们也 不能保证顺序。

处理错误

当消费者正在运行时，如果 receiver 失败了，默认的行为是消费者会将将捕获异常，打印 错误日志，并继续消费下一条记录而不是导致消费者也失败。

在其他情况下可能会导致消费者的失败，例如网络、订阅被删除等。然而，作为一个服务， 你可能希望消费者继续运行，所以你可以设置一个监听器来处理一个消费者失败的情况。

  1. // add Listener for handling failed consumer
  2. var threadPool = new ScheduledThreadPoolExecutor(1);
  3. consumer.addListener(
  4.     new Service.Listener() {
  5.       public void failed(Service.State from, Throwable failure) {
  6.         System.out.println("consumer failed, with error: " + failure.getMessage());
  7.       }
  8.     },
  9.     threadPool);