Spring Boot が Kafka を統合: spring-kafka の詳細な調査

序文

Kafka は、トピック パーティションに基づいて設計され、非常に高いメッセージ送信および処理パフォーマンスを実現できるメッセージ キュー製品です。 Spring は、Apache の Kafka クライアントをカプセル化し、Spring プロジェクトに Kafka を迅速に統合するために使用される Spring-kafka プロジェクトを作成しました。単純なメッセージの送受信に加えて、Spring-kafka は多くの高度な機能も提供します。これらの用途を一つずつ見ていきましょう。

プロジェクトアドレス: https://github.com/spring-projects/spring-kafka

シンプルな統合

依存関係の導入

<依存関係> <グループ ID > org.springframework.kafka </グループ ID > <アーティファクト ID > spring-kafka </アーティファクト ID > <バージョン> 2.2.6.RELEASE </バージョン> </依存関係>  

設定を追加

spring.kafka.producer.bootstrap-servers = 127.0.0.1 :9092

送受信をテストする

/**  
 * @著者: kl @kailing.pub  
 * @日付: 2019/5/30  
 */  
 @SpringBootアプリケーション 
 @レストコントローラ 
パブリッククラスアプリケーション{  
  プライベート最終 Logger logger = LoggerFactory .getLogger(Application.class);  
  パブリック静的voidメイン(String[] args) {  
    SpringApplication.run(Application.class、引数);  
  }
  オートワイヤード 
  プライベート KafkaTemplate < Object , Object >テンプレート;  
  @GetMapping("/send/{input}")  
  public void sendFoo(@PathVariable String input) {  
    this.template.send("topic_input", 入力);  
  }  
  @KafkaListener( id = "webGroup" 、トピック= "topic_input" )  
  パブリック void listen(文字列入力) {  
    logger.info("入力値: {}" , input);  
  }  
 }

アプリケーションを起動したら、ブラウザに http://localhost:8080/send/kl と入力します。コンソールにログ出力が表示されます: 入力値: "kl"。基本的な使い方はとても簡単です。メッセージを送信するときに KafkaTemplate を挿入し、メッセージを受信するときに @KafkaListener アノテーションを追加します。

Spring-kafka-test組み込み Kafka サーバー

ただし、Kafka Server サービス環境がすでにある場合は、上記のコードを正常に起動できます。 Kafka は Scala + Zookeeper で構築されており、公式サイトからデプロイメント パッケージをダウンロードしてローカルにデプロイできることがわかっています。ただし、開発プロセスを簡素化し、Kafka 関連の機能を検証するために、Spring-Kafka-Test は Kafka-test をカプセル化し、アノテーション スタイルのワンクリックで Kafka Server 機能を起動できるようにしており、これも非常に使いやすいことをお伝えしたいと思います。この記事のすべての Kafka テスト ケースは、この組み込みサービスを使用して提供されます。

依存関係の導入

<依存関係> <グループ ID > org.springframework.kafka </グループ ID > <アーティファクト ID > spring-kafka-test </アーティファクト ID > <バージョン> 2.2.6.RELEASE </バージョン> <スコープ>テスト</スコープ> </依存関係>  

サービスを開始する

次の Junit テスト ケースは、4 つのブローカー ノードを含む Kafka サーバー サービスを直接起動するために使用されます。

 @RunWith(SpringRunner.class)@SpringBootTest( classes = ApplicationTests .class)@EmbeddedKafka( count = 4 、 ports = {9092,9093,9094,9095})public クラス ApplicationTests {@Testpublic void contextLoads()throws IOException { System.in.read(); }}

上記のように、@EmbeddedKafka というアノテーションを 1 つ付けるだけで、完全に機能する Kafka サービスを開始できます。かっこいいでしょう？デフォルトでは、パラメータなしでアノテーションのみが書き込まれると、ランダムなポートを持つブローカーが作成されます。特定のポートといくつかのデフォルトの構成項目が起動ログに出力されます。ただし、Kafka インストール パッケージ構成ファイル内のこれらの構成項目は、アノテーション パラメータで構成できます。以下は、@EmbeddedKafka アノテーションで設定可能なパラメータの詳細な説明です。

• 値: ブローカーノードの数
• カウント: 値と同じ、ブローカーに設定されているノードの数
• 制御されたシャットダウン スイッチ。主に、ブローカーが予期せずシャットダウンした場合に、このブローカーのパーティションが利用できなくなる時間を短縮するために使用されます。

Kafka は、マルチブローカー アーキテクチャを備えた高可用性サービスです。 1 つのトピックは複数のパーティションに対応し、1 つのパーティションには複数のレプリカを含めることができます。これらのレプリケーション コピーは、高可用性を実現するために複数のブローカーに保存されます。ただし、パーティション レプリカ セットは複数ありますが、現在動作しているレプリカ セットは 1 つだけです。デフォルトでは、最初に割り当てられたレプリカ セット [優先レプリカ] がリーダーとなり、データの書き込みと読み取りを担当します。ブローカーをアップグレードしたり、ブローカーの構成を更新したりする場合は、サービスを再起動する必要があります。この時点で、パーティションを利用可能なブローカーに転送する必要があります。以下に3つの状況が関係している。

1. ブローカーを直接シャットダウンする: ブローカーがシャットダウンされると、ブローカー クラスターは新しいブローカーをパーティション リーダーとして再選出します。選挙中、このブローカーのパーティションはしばらくの間利用できなくなります。
2. 制御されたシャットダウンを有効にする: ブローカーがシャットダウンされると、ブローカー自体は最初にリーダーの役割を他の利用可能なブローカーに転送しようとします。
3. コマンドラインツールを使用する: bin/kafka-preferred-replica-election.sh を使用して、PartitionLeader ロールの転送を手動でトリガーします。

• ports: ポート リスト (配列)。カウントパラメータに対応して、複数のポート番号に対応する複数のブローカーが存在する。
• brokerProperties: ブローカー パラメータ設定。配列構造であり、ブローカー パラメータ設定に対して次のメソッドをサポートします。

 @EmbeddedKafka(ブローカープロパティ= {" log.index.interval.bytes = 4096"," num .io.threads = 8 "})

• kerPropertiesLocation: ブローカーパラメータファイル設定

機能は上記の brokerProperties と同じですが、Kafka Broker には 182 個の構成可能なパラメーターがあります。上記のようにすべてを構成することは決して最善の解決策ではないため、次のようなローカル構成ファイルを読み込む機能が提供されています。

 @EmbeddedKafka(ブローカープロパティの場所= "classpath:application.properties" )

デフォルトでは、KafkaTemplate を使用してメッセージを送信するときにトピックが存在しない場合は、新しいトピックが作成されます。パーティションとレプリカのデフォルトの数は、次のブローカー パラメータによって設定されます。

新しいトピックを作成する

num.partitions = 1 #トピックパーティションのデフォルト数 
 num.replica.fetchers = 1 #レプリカのデフォルト数

プログラムの開始時にトピックを作成する

/**  
 * @著者: kl @kailing.pub  
 * @日付: 2019/5/31  
 */  
 @構成 
パブリッククラスKafkaConfig{  
  @ビーン 
  パブリックKafkaAdmin管理者(KafkaPropertiesプロパティ){  
    KafkaAdmin管理者=新しいKafkaAdmin(properties.buildAdminProperties());  
    admin.setFatalIfBrokerNotAvailable(true);  
    管理者に戻ります。  
  }  
  @ビーン 
  パブリック NewTopic topic2() {  
    新しい NewTopic("topic-kl", 1, (short) 1) を返します。  
  }  
 }

Kafka Broker がサポートしている場合 (バージョン 1.0.0 以上)、既存のトピックのパーティション数が設定されたパーティション数より少ないことが判明した場合、新しいパーティションが追加されます。 KafkaAdmin の一般的な用途は、次のとおりです。

setFatalIfBrokerNotAvailable(true): デフォルト値は False です。これは、Broker が利用できない場合の Spring コンテキストの初期化には影響しません。ブローカーが利用できないことが通常のビジネス ニーズに影響すると思われる場合は、この値を True に設定します。

setAutoCreate(false) : デフォルト値は True です。これは、インスタンス化後に Kafka がインスタンス化された NewTopic オブジェクトを自動的に作成することを意味します。

初期化(): setAutoCreateがfalseの場合、プログラムは管理者の初期化()メソッドを明示的に呼び出してNewTopicオブジェクトを初期化する必要があります。

コードロジックで作成

プログラムを起動するときにトピックに必要なパーティションの数がわからないことがありますが、ブローカーのデフォルト設定をそのまま使用することはできません。この場合、Kafka-Client に付属する AdminClient を使用して処理する必要があります。上記の Spring によってカプセル化された KafkaAdmin も AdminClient を使用して処理されます。のように：

オートワイヤード 
  プライベート KafkaProperties プロパティ。  
  @テスト 
  パブリック void testCreateToipc(){  
    AdminClientクライアント= AdminClient .create(properties.buildAdminProperties());  
    if(クライアント != null){  
      試す {  
        コレクション< NewTopic >  新しいnewTopics = 新しい ArrayList < > (1);  
        新しいトピックを追加します(新しい NewTopic("topic-kl",1,(short) 1));  
        クライアント。トピックを作成します(新しいトピック)。  
      }キャッチ (Throwable e){  
        e.printStackTrace();  
      }ついに {  
        クライアントを閉じます。  
      }  
    }  
  }

追伸: トピックを作成する他の方法

上記のトピック作成方法では、spring-kafka2.x は spring boot2.x のみをサポートしているため、Spring Boot のバージョンが 2.x 以上である必要があります。これらの API はバージョン 1.x では使用できません。プログラム内でKafka_2.10を介してトピックを作成する方法は次のとおりです。

依存関係の導入

<依存関係>    
 <グループID> org.apache.kafka</グループID>    
 <アーティファクトID> kafka_2.10</アーティファクトID >    
 <バージョン> 0.8.2.2</バージョン>    
 </依存関係>  

APIで作成

@テスト 
  パブリック void testCreateTopic() は例外をスローします{  
    ZkClient zkClient =新しいZkClient("127.0.0.1:2181", 3000, 3000, ZKStringSerializer$.MODULE$)  
    文字列topicName = "topic-kl" ;  
    intパーティション= 1 ;  
    整数レプリケーション= 1 ;  
    AdminUtils.createTopic(zkClient、トピック名、パーティション、レプリケーション、新しいプロパティ());  
  }

ZkClient の最後の構築パラメータは、シリアル化と逆シリアル化のインターフェース実装であることに注意してください。ブロガーがテスト中に記入しないと、ZK で作成されたトピックのデータに問題が生じます。デフォルトの Kafka 実装も非常にシンプルで、文字列の UTF-8 エンコード処理を実行します。 ZKStringSerializer$ は、Kafka に実装されたインターフェース インスタンスです。 Scala のコンパニオン オブジェクトです。 Java で MODULE$ を直接呼び出すことでインスタンスを取得できます。

コマンドモードの作成

@テスト 
  パブリック void testCreateTopic(){  
    文字列[]オプション=新しい文字列[]{  
        " - 作成する"、  
        "--zookeeper","127.0.0.1:2181",  
        "--レプリケーション係数", "3",  
        "--パーティション", "3",  
        "--トピック"、"トピック-kl"  
    };  
    TopicCommand.main(オプション);  
  }

メッセージ送信のための KafkaTemplate の調査

送信結果を取得する

非同期取得

template.send("","").addCallback(新しいListenableFutureCallback < SendResult < Object , Object >> ( ) {  
      @オーバーライド 
      パブリックvoid onFailure(Throwable throwable) {  
        ......  
      }  
      @オーバーライド 
      パブリックvoid onSuccess(SendResult < Object 、 Object > objectObjectSendResult) {  
        ....  
      }  
    });

同期取得

ListenableFuture < SendResult <オブジェクト、オブジェクト>>   future =テンプレート.send("topic-kl","kl");  
    試す {  
      SendResult <オブジェクト、オブジェクト>  結果= future .get();  
    }キャッチ (Throwable e){  
      e.printStackTrace();  
    }

Kafka トランザクション メッセージ

デフォルトでは、Spring-kafka によって自動的に生成される KafkaTemplate インスタンスには、トランザクション メッセージを送信する機能がありません。トランザクション機能を有効にするには、次の設定が必要です。トランザクションがアクティブ化された後、すべてのメッセージ送信はトランザクションが発生したメソッド内でのみ実行できます。それ以外の場合は、トランザクションがないことを示す例外がスローされます。

 spring.kafka.producer.transaction-id-prefix = kafka_tx 。

たとえば、メッセージの送信にトランザクションが必要な場合、次の例のように、すべてのメッセージが正常に送信されます。最初のメッセージが送信された後、2 番目のメッセージが送信される前に例外が発生すると、送信された最初のメッセージもロールバックされます。さらに、通常の状況では、最初のメッセージが送信され、その後一定期間スリープしてから 2 番目のメッセージを送信すると仮定すると、コンシューマーはトランザクション メソッドが実行された後にのみメッセージを受信します。

 @GetMapping("/send/{input}")  
  public void sendFoo(@PathVariable String input) {  
    テンプレート.executeInTransaction(t - > {  
      t.send("topic_input","kl");  
      if ("エラー".equals(入力)) {  
        新しい RuntimeException("失敗") をスローします。  
      }  
      t.send("topic_input","ckl");  
      true を返します。  
    });  
  }

トランザクション機能が有効化されると、メソッドに@Transactionalアノテーションを追加することでも有効になります。

 @GetMapping("/send/{input}")  
  @Transactional(ロールバックFor = RuntimeException .class)  
  public void sendFoo(@PathVariable String input) { 
     テンプレートを送信します("topic_input", "kl");  
    if ("エラー".equals(入力)) {  
      新しい RuntimeException("失敗") をスローします。  
    }  
    テンプレートを送信します("topic_input", "ckl");  
  }

Spring-Kafka のトランザクション メッセージングは​​、Kafka が提供するトランザクション メッセージング機能に基づいています。 Kafka ブローカーのデフォルト構成は、3 つ以上のブローカーの高可用性サービス用に設定されています。テスト中のシンプルさと利便性のために、組み込みサービスを使用して単一ブローカーの Kafka サービスを作成しましたが、いくつかの問題が発生しました。

1. トランザクション ログ レプリカ セットがブローカーの数より大きい場合、次の例外がスローされます。

有効なブローカーの数 '1' は、必要なレプリケーション係数 '3' を満たしていません 
トランザクション状態トピック用 ('transaction.state.log.replication.factor' で構成)。  
クラスターが起動中で、すべてのブローカーがまだ起動していない場合は、このエラーは無視できます。

デフォルトのブローカー構成transaction.state.log.replication.factor=3、単一ノードは1にしか調整できません

2. レプリカの数がレプリカ同期キューの数より少ない場合、次の例外がスローされます。

パーティション__transaction_state-13の同期レプリカの数は[1]で、必要な最小数[2]を下回っています。

デフォルトのブローカー構成はtransaction.state.log.min.isr=2で、単一ノードは1にしか調整できません。

ReplyKafkaTemplate はメッセージの返信を取得します

ReplyKafkaTemplate は KafkaTemplate のサブクラスです。親クラスのメソッドを継承するだけでなく、メッセージの送信\返信セマンティクスを実装するための新しいメソッドsendAndReceiveを追加します。

 RequestReplyFuture < K , V, R > sendAndReceive(ProducerRecord < K , V >レコード);

つまり、メッセージを送信すると、コンシューマーから結果が返されます。従来の RPC 対話と同じです。メッセージの送信者がメッセージ コンシューマーの特定の消費状況を知る必要がある場合、この API は非常に適しています。たとえば、メッセージでデータのバッチを送信する場合、コンシューマーが正常に処理したデータを知る必要があります。次のコードは、ReplyingKafkaTemplateを統合して使用する方法を示しています。

 /**  
 * @著者: kl @kailing.pub  
 * @日付: 2019/5/30  
 */  
 @SpringBootアプリケーション 
 @レストコントローラ
 パブリッククラスアプリケーション{  
  プライベート最終 Logger logger = LoggerFactory .getLogger(Application.class);  
  パブリック静的voidメイン(String[] args) {  
    SpringApplication.run(Application.class、引数);  
  }  
  @ビーン 
  パブリック ConcurrentMessageListenerContainer <文字列, 文字列>返信コンテナ (ConcurrentKafkaListenerContainerFactory <文字列, 文字列>コンテナファクトリー) {  
    ConcurrentMessageListenerContainer <文字列, 文字列>  返信コンテナ= containerFactory .createContainer("返信");  
    返信コンテナ.getContainerProperties().setGroupId("返信グループ");  
    コンテナの自動起動を false に設定します。  
    repliesContainer を返します。  
  }  
  @ビーン 
  パブリック ReplyKafkaTemplate <文字列、文字列、文字列> replyingTemplate(ProducerFactory <文字列、文字列> pf、ConcurrentMessageListenerContainer <文字列、文字列> repliesContainer) { 
     新しい ReplyKafkaTemplate(pf, repliesContainer) を返します。  
  }  
  @ビーン 
  パブリック KafkaTemplate kafkaTemplate(ProducerFactory < String , String > pf) {  
    新しい KafkaTemplate(pf) を返します。  
  }  
  オートワイヤード 
  プライベート ReplyKafkaTemplate テンプレート;  
  @GetMapping("/send/{input}")  
  @Transactional(ロールバックFor = RuntimeException .class)  
  パブリック void sendFoo(@PathVariable String input) は例外をスローします {  
    プロデューサーレコード<文字列, 文字列>  レコード=新しいProducerRecord < > ("topic-kl", 入力);  
    RequestReplyFuture <文字列、文字列、文字列>   replyFuture =テンプレート.sendAndReceive(レコード);  
    ConsumerRecord <文字列, 文字列>  消費者レコード= replyFuture .get();  
    System.err.println("戻り値: " + consumerRecord.value());  
  }  
  @KafkaListener( id = "webGroup" 、トピック= "topic-kl" )  
  @送信先 
  パブリック文字列 listen(文字列入力) {  
    logger.info("入力値: {}", input);  
    「成功」を返します。  
  }  
 }

Spring-kafka メッセージ消費の使用法の調査

@KafkaListener の使用

@KafkaListener のメッセージ受信機能は、これまでの簡単な統合で実証されましたが、@KafkaListener にはそれ以上の機能があります。より多くの使用シナリオを持つその他の一般的な機能は次のとおりです。

• 消費される指定されたトピックとパーティションのメッセージを表示します。
• 各トピックとパーティションの初期化のオフセットを設定します。
• コンシューマスレッドの同時実行を設定する
• メッセージ例外ハンドラを設定する

@KafkaListener( id = "webGroup" 、トピックパーティション= {  
      @TopicPartition(トピック= "topic1" 、パーティション= {"0", "1"})、  
          @TopicPartition(トピック= "topic2" 、パーティション= "0" 、  
パーティションオフセット= @PartitionOffset(パーティション= "1" 、初期オフセット= "100" ))  
      },同時実行性= "6" 、 errorHandler = "myErrorHandler" )  
  パブリック文字列 listen(文字列入力) {  
    logger.info("入力値: {}", input);  
    「成功」を返します。  
  }

その他の注釈パラメータは簡単に理解できます。 ErrorHandler について説明する必要があります。このパラメータを設定するには、KafkaListenerErrorHandler インターフェースを実装する必要があります。アノテーション内の構成は、Spring コンテキスト内のカスタム実装インスタンスの名前です。たとえば、上記の構成は errorHandler = "myErrorHandler" です。すると、春のローンチでは次のようなインスタンスが作成されるはずです。

 /**  
 * @著者: kl @kailing.pub  
 * @日付: 2019/5/31  
 */  
 @Service("myErrorHandler")  
パブリッククラス MyKafkaListenerErrorHandler は KafkaListenerErrorHandler を実装します {  
  ロガーlogger = LoggerFactory .getLogger(getClass()); 
   @オーバーライド 
  パブリックオブジェクトhandleError(Message <? >メッセージ、ListenerExecutionFailedException 例外) {  
    logger.info(message.getPayload().toString());  
    null を返します。  
  }  
  @オーバーライド 
  パブリック オブジェクト handleError(Message <? >メッセージ、ListenerExecutionFailedException 例外、Consumer <? 、 ?>コンシューマー) {  
    logger.info(message.getPayload().toString());  
    null を返します。  
  }  
 }

手動確認モード

手動 ACK モードでは、コミット オフセットはビジネス ロジックによって制御されます。たとえば、プログラムが消費しているとき、このセマンティクスがあり、特に異常な状況では、ACK を確認せず、つまりオフセットを送信しません。その場合は、手動の ACK モードを使用してのみ実行できます。手動送信を有効にするには、まず自動送信をオフにしてから、コンシューマーの消費モードを設定する必要があります。

 spring.kafka.consumer.enable-auto-commit = false    
 spring.kafka.listener.ack-mode =手動 

上記の設定が完了したら、使用時に @KafkaListener リスニング メソッドで Acknowledgment を入力するだけです。 ack.acknowledge() を実行すると、オフセットが送信されたことを意味します。

 @KafkaListener( id = "webGroup" 、トピック= "topic-kl" )  
  パブリック文字列 listen(文字列入力、確認応答 ack) {  
    logger.info("入力値: {}", input);  
    if ("kl".equals(入力)) {  
      ack.acknowledge();  
    }  
    「成功」を返します。  
  }

@KafkaListener アノテーション リスナー ライフサイクル

@KafkaListener アノテーションが付けられたリスナーのライフサイクルを制御できます。デフォルトでは、@KafkaListener のパラメーター autoStartup = "true" です。つまり、消費は自動的に開始されますが、そのライフサイクルは KafkaListenerEndpointRegistry を通じて介入することもできます。 KafkaListenerEndpointRegistry には、start()、pause()、resume()/start、stop、continue の 3 つのアクション メソッドがあります。次のコードはこの機能を詳細に示しています。

 /**  
 * @著者: kl @kailing.pub  
 * @日付: 2019/5/30  
 */  
 @SpringBootアプリケーション 
 @レストコントローラ 
パブリッククラスアプリケーション{  
  プライベート最終 Logger logger = LoggerFactory .getLogger(Application.class);  
  パブリック静的voidメイン(String[] args) {  
    SpringApplication.run(Application.class、引数);  
  }  
  オートワイヤード 
  プライベート KafkaTemplate テンプレート。  
  @GetMapping("/send/{input}")  
  @Transactional(ロールバックFor = RuntimeException .class)  
  パブリック void sendFoo(@PathVariable String input) は例外をスローします {  
    プロデューサーレコード<文字列, 文字列>  レコード=新しいProducerRecord < > ("topic-kl", 入力);  
    テンプレート.send(レコード);  
  }  
  オートワイヤード 
  プライベート KafkaListenerEndpointRegistry レジストリ。  
  @GetMapping("/stop/{リスナーID}")  
  public void stop(@PathVariable String リスナーID){  
    レジストリの getListenerContainer(リスナーID).pause();  
  }  
  @GetMapping("/resume/{リスナーID}")  
  public voidresume(@PathVariable String リスナーID){  
    レジストリの getListenerContainer(リスナーID).resume();  
  }  
  @GetMapping("/start/{リスナーID}")  
  public void start(@PathVariable String リスナーID){  
    レジストリの getListenerContainer(リスナーID).start();  
  }  
  @KafkaListener( id = "webGroup" 、トピックス= "topic-kl" 、 autoStartup = "false" )  
  パブリック文字列 listen(文字列入力) {  
    logger.info("入力値: {}", input);  
    「成功」を返します。  
  }  
 }

上記のコードでは、listenerID は @KafkaListener の ID 値「webGroup」です。プロジェクトを開始したら、次の URL をそれぞれ実行して効果を確認します。

まず、メッセージを送信します: http://localhost:8081/send/ckl。 autoStartup = "false" なので、リスナーに入るメッセージは表示されません。

次に、リスナーを起動します: http://localhost:8081/start/webGroup。メッセージが届いたことがわかります。

同様の方法を使用して、消費を一時停止したり継続したりした場合の効果をテストできます。

SendToメッセージ転送

前回のメッセージ送信応答アプリケーションで @SendTo を見ました。 @SendTo アノテーションは、応答セマンティクスの送信に加えて、転送トピック キューを指定するためのパラメータも受け取ることができます。一般的なシナリオとしては、メッセージを複数回処理する必要があり、異なる処理によって cups などの一貫性のないリソースが消費されるというものがあります。これは、異なるトピックにまたがり、異なるホストにデプロイされたコンシューマーを使用することで解決できます。のように：

 @KafkaListener( id = "webGroup" 、トピック= "topic-kl" )  
  @SendTo("トピック-ckl")  
  パブリック文字列 listen(文字列入力) {  
    logger.info("入力値: {}", input);  
    入力 + "hello!" を返します。  
  }  
  @KafkaListener( id = "webGroup1" 、トピック= "topic-ckl" )  
  パブリック void listen2(文字列入力) {  
    logger.info("入力値: {}", input);  
  }

メッセージ再試行とデッドレターキューの適用

上記の手動 Ack モードを通じてメッセージのオフセットを制御することに加えて、Spring-kafka は再試行可能な消費メッセージのセマンティクスもカプセル化します。つまり、消費データで例外が発生した場合にメッセージを再試行するように設定できます。事前に決められたトピックにメッセージを送信するまでの再試行回数も設定できます。それがデッドレターキューです。次のコードはこの効果を示しています。

オートワイヤード 
  プライベート KafkaTemplate テンプレート。  
  @ビーン 
  public ConcurrentKafkaListenerContainerFactory <? 、 ?> kafkaListenerContainerFactory(  
      ConcurrentKafkaListenerContainerFactoryConfigurer コンフィギュラー、  
      ConsumerFactory <オブジェクト, オブジェクト> kafkaConsumerFactory、  
      KafkaTemplate <オブジェクト、オブジェクト>テンプレート) {  
    ConcurrentKafkaListenerContainerFactory <オブジェクト, オブジェクト>  ファクトリー=新しいConcurrentKafkaListenerContainerFactory < > ();  
    configurer.configure(ファクトリ、kafkaConsumerFactory);  
    //最大再試行回数: 3 回 
    factory.setErrorHandler(新しい SeekToCurrentErrorHandler(新しい DeadLetterPublishingRecoverer(テンプレート)、3));  
    工場を返却する。  
  }  
  @GetMapping("/send/{input}")  
  public void sendFoo(@PathVariable String input) {  
    template.send("topic-kl", 入力);  
  }  
  @KafkaListener( id = "webGroup" 、トピック= "topic-kl" )  
  パブリック文字列 listen(文字列入力) {  
    logger.info("入力値: {}", input);  
    新しい RuntimeException("dlt") をスローします。  
  }  
  @KafkaListener( id = "dltGroup" 、トピック= "topic-kl.DLT" )  
  パブリック void dltListen(文字列入力) {  
    logger.info("DLTから受信: " + 入力);  
  }

上記のアプリケーションでは、メッセージが topic-kl でリッスンされると、ランタイム例外がトリガーされ、再試行の最大回数に達した後、リスナーは 3 回呼び出しを試みます。メッセージは破棄され、デッドレター キューに再試行されます。デッドレターキューのトピックルールは、ビジネストピック名 + 「.DLT」です。上記のビジネス トピックの名前が「topic-kl」の場合、対応するデッドレター キュー トピックは「topic-kl.DLT」になります。

結論

最近、Kafka と Spring-kafka がビジネスで使われるようになったので、Spring-kafka のさまざまな用途を体系的に調査したところ、埋め込み Kafka サービスを有効にするアノテーション、RPC 呼び出しのような send\response セマンティック呼び出し、トランザクション メッセージ、その他の機能など、多くの興味深くクールな機能を発見しました。このブログ投稿が、Spring-kafka を使用している方、または使用しようとしている方の迂回や落とし穴を回避するのに役立つことを願っています。