通過Spring Boot Webflux實現Reactor Kafka

banq發表於2019-04-20
Spring BootWebUXReactKafka

在Apache Kafka簡介中，我們研究了分散式流媒體平臺Apache Kafka。這一次，我們將關注Reactor Kafka，這個庫可以建立從Project Reactor到Kafka Topics的Reactive Streams，反之亦然。

我們將使用兩個小型示例應用程式，Paymentprocessor Gateway和PaymentValidator。這些應用程式的程式碼可以在這裡找到。

Paymentprocessor閘道器提供了一個小網頁，可以生成一個隨機的信用卡號碼（顯然是偽造的），以及支付金額。當使用者單擊提交按鈕時，表單將提交給閘道器的API。API具有針對Kafka群集上的未確認事務主題的反應流，這個未確認事務的主題的另外一邊消費者是PaymentValidator，監聽要驗證的傳入訊息。然後，這些訊息通過響應管道，驗證方法將其列印到命令列。

通過Reactive Streams向Kafka傳送訊息

我們的應用程式構建在Spring 5和Spring Boot 2之上，使我們能夠快速設定和使用Project Reactor。

Gateway應用程式的目標是設定從Web控制器到Kafka叢集的Reactive流。這意味著我們需要特定的依賴關係來彈簧webflux和reactor-kafka。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

<dependency>
<groupId>io.projectreactor.kafka</groupId>
<artifactId>reactor-kafka</artifactId>
<version>1.1.0.RELEASE</version>
</dependency>

Spring Webflux RestController提供支付API，為paymentGateway類的doPayment方法建立一個Reactive流。

/ ** 
     *呼叫返回的Mono將被髮送到Spring Webflux，後者依賴於multi-reactor 事件迴圈和NIO 
     *以非阻塞方式處理請求，從而實現更多的併發請求。結果將
     通過一個名為Server Sent Events 傳送。
     ** /

@PostMapping(value = "/payment")
    public Mono<Void> doPayment(@RequestBody CreatePaymentCommand payment) {
    / ** 
         當呼叫doPayment方法時，我們傳送付款資訊，獲得Mono <Void>作為響應。
         當我們的付款成功傳送事件到Kafka主題
         ** / 
        return paymentGateway.doPayment(payment);
    }

paymentGateway需要一個kafkaProducer，它使我們能夠將訊息作為管道的一部分放在Kafka主題中。它可以使用KafkaSender.create方法輕鬆建立，傳遞許多生產者選項。

 public PaymentGatewayImpl() {
        final Map<String, Object> producerProps = new HashMap<>();
        producerProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        producerProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        producerProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

        final SenderOptions<Integer, String> producerOptions = SenderOptions.create(producerProps);

        kafkaProducer = KafkaSender.create(producerOptions);
    }

建立之後，kafkaProducer可以用來輕鬆地將我們的訊息傳送到選擇的Kafka主題，成為控制器中啟動的管道的一部分。因為訊息是以非阻塞方式傳送到Kafka叢集的，所以我們可以使用專案Reactor的事件迴圈接收並將來自Web API的大量併發訊息路由到Kafka。

 @Override
    public Mono<Void> doPayment(final CreatePaymentCommand createPayment) {
        final PaymentEvent payment = new PaymentEvent(createPayment.getId(), createPayment.getCreditCardNumber(), createPayment.getAmount(), gatewayName);

        String payload = toBinary(payment);

        SenderRecord<Integer, String, Integer> message = SenderRecord.create(new ProducerRecord<>("unconfirmed-transactions", payload), 1);
        return kafkaProducer.send(Mono.just(message)).next();
    }

    private String toBinary(Object object) {
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException(e);
        }
    }

從Kafka主題建立反應流

當沒有消費者監聽時，向主題傳送訊息沒有多大意義，因此我們的第二個應用程式將使用一個反應管道來監聽未確認的事務主題。為此，使用KafkaReceiver.create方法建立kafkaReceiver物件，類似於我們之前建立kafkaProducer的方法。

通過使用kafkaReceiver.receive方法，我們可以獲得receiverRecords的Flux。進入我們讀取的主題中每條訊息都放入receiverRecord中。流入應用程式後，它們會進一步通過反應管道。然後，這些訊息傳遞processEvent方法，該方法呼叫paymentValidator，該方法將一些資訊輸出到控制檯。最後，在receiverOffset上呼叫acknowledge方法，向Kafka叢集傳送一條訊息已被處理的確認。

   public PaymentValidatorListenerImpl(PaymentValidator paymentValidator) {
        this.paymentValidator = paymentValidator;

        final Map<String, Object> consumerProps = new HashMap<>();
        consumerProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        consumerProps.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        consumerProps.put(ConsumerConfig.CLIENT_ID_CONFIG, "payment-validator-1");
        consumerProps.put(ConsumerConfig.GROUP_ID_CONFIG, "payment-validator");
        consumerProps.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");

        ReceiverOptions<Object, Object> consumerOptions = ReceiverOptions.create(consumerProps)
                .subscription(Collections.singleton("unconfirmed-transactions"))
                .addAssignListener(partitions -> log.debug("onPartitionsAssigned {}", partitions))
                .addRevokeListener(partitions -> log.debug("onPartitionsRevoked {}", partitions));

        kafkaReceiver = KafkaReceiver.create(consumerOptions);

        /**
         * We create a receiver for new unconfirmed transactions
         */
        ((Flux<ReceiverRecord>) kafkaReceiver.receive())
                .doOnNext(r -> {
                    /**
                     * Each unconfirmed payment we receive, we convert to a PaymentEvent and process it
                     */
                    final PaymentEvent paymentEvent = fromBinary((String) r.value(), PaymentEvent.class);
                    processEvent(paymentEvent);
                    r.receiverOffset().acknowledge();
                })
                .subscribe();
    }

    private void processEvent(PaymentEvent paymentEvent) {
        paymentValidator.calculateResult(paymentEvent);
    }

    private <T> T fromBinary(String object, Class<T> resultType) {
        try {
            return objectMapper.readValue(object, resultType);
        } catch (IOException e) {
            throw new IllegalArgumentException(e);
        }
    }

可以在此處找到此示例的程式碼

相關文章