Breaking News: Grepper is joining You.com. Read the official announcement!

Mention the APIs provided by Apache Kafka.

Pragya Keshap answered on February 6, 2023 Popularity 1/10 Helpfulness 1/10

answer Mention the APIs provided by Apache Kafka.

Mention the APIs provided by Apache Kafka.

Comment

There are four main APIs provided by Apache Kafka-

Kafka Producer API: The producer API allows applications to publish messages in the form of a stream of records to one or more Kafka topics.

Kafka Consumer API: The consumer API allows applications to subscribe to one or more Kafka topics. The consumer API also allows applications to process streams of messages that are produced for those topics.

Kafka Streams API: The Kafka streams API allows applications to process data in a stream processing paradigm. The application can fetch data in the form of input streams for one or more topics, process these streams, and then send output streams to one or more topics.

Kafka Connector API: The connector API helps connect applications to Kafka topics. It provides features for managing the running of producers and consumers and handling the connections between them.

@Slf4j
@Component
@Profile("avro")
public class StoreStreamsAvro {

    @Value("${spring.cloud.stream.kafka.streams.binder.configuration.schema.registry.url}")
    private String schemaRegistryUrl;

    private Serde<ProductDetailList> productDetailListSerde;
    private Serde<OrderDetailed> orderDetailedSerde;

    @Bean
    public Function<KStream<String, Order>,
            Function<GlobalKTable<String, Customer>,
                    Function<KStream<String, OrderProduct>,
                            Function<GlobalKTable<String, Product>,
                                    KStream<String, OrderDetailed>>>>> process() {
        return orderKStream -> (
                customerGlobalKTable -> (
                        orderProductKStream -> (
                                productGlobalKTable -> (
                                        orderKStream
                                                .peek(this::logKeyValue)
                                                .join(
                                                        customerGlobalKTable,
                                                        (s, order) -> String.valueOf(order.getCustomerId()),
                                                        this::toOrderDetailed
                                                )
                                                .join(
                                                        orderProductKStream
                                                                .peek(this::logKeyValue)
                                                                .join(
                                                                        productGlobalKTable,
                                                                        (s, orderProduct) -> String.valueOf(orderProduct.getProductId()),
                                                                        this::toProductDetail
                                                                )
                                                                .groupByKey()
                                                                .aggregate(
                                                                        ProductDetailList::new,
                                                                        (key, productDetail, productDetailList) -> addProductDetail(productDetail, productDetailList),
                                                                        Materialized.with(Serdes.String(), productDetailListSerde)
                                                                )
                                                                .toStream()
                                                                .peek(this::logKeyValue),
                                                        (orderDetailed, productDetailList) -> setProductDetailList(productDetailList, orderDetailed),
                                                        JoinWindows.ofTimeDifferenceWithNoGrace(Duration.ofMinutes(1)),
                                                        StreamJoined.with(Serdes.String(), orderDetailedSerde, productDetailListSerde)
                                                )
                                                .peek(this::logKeyValue)
                                )
                        )
                )
        );
    }

https://kafka.apache.org/documentation/

Popularity 1/10 Helpfulness 1/10 Language java

Source: Grepper

Tags: java mention

Link to this answer
Share Copy Link

Contributed on Feb 06 2023

Pragya Keshap

0 Answers Avg Quality 2/10

Mention the APIs provided by Apache Kafka.

Contents

More Related Answers

Mention the APIs provided by Apache Kafka.

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.