Kafka Streaming

Kafka Streams:深度探索实时流处理应用程序 Kafka Streams 是 Apache Kafka 生态系统中的一部分,它不仅简化了流处理应用的构建,还提供了强大的功能,如事件时间处理、状态管理、交互式查询等。其核心理念是将流处理与事件日志结合,使应用程序能够实时处理数据流。通过深度探索 Kafka Streams 的各个方面,本文为大家提供了更加详细的理解和应用指南。Kafka Streams 不仅提供了强大的流处理功能,还支持容器化、全局状态共享、弹性扩展等特性,使其成为构建实时流处理应用的理想选择。 阅读详情

Kafka Streaming概述

Kafka Streams是一个用于构建应用程序和微服务的客户端库,其中的输入和输出数据存储在Kafka集群中。它结合了在客户端编写和部署标准Java和Scala应用程序的简单性,以及Kafka服务器端集群技术的优点。

特点

  1. 弹性、高可扩展、容错
  2. 可以部署在容器、虚拟机、单独、云环境中
  3. 同样适用于小型、中型和大型用例
  4. 集成Kafka Security
  5. 写标准的JAVA和Scala应用
  6. 精确一次处理语义
  7. 无需单独的处理群集
  8. 支持多种开发平台

核心概念

Topology():表示一个流计算任务,等价于MapReduce中的job。不同的是MapReduce的job作业最终会停止,但是Topology会一直运行在内存中,除非人工关闭该Topology

Stream:它代表了一个无限的,不断更新的Record数据集。流是有序,可重放和容错的不可变数据记录序列,其中数据记录被定义为键值对

States:用以持久化存放流计算状态结果,可以用以容错和故障恢复

Time:Event time(事件时间)、Processing time(处理时间)、Ingestion time(摄入时间)

所谓的流处理就是通过Topology编织程序对Stream中Record元素的处理的逻辑/流程。

架构

Kafka Streams通过构建Kafka生产者和消费者库并利用Kafka的本机功能来提供数据并行性,分布式协调,容错和操作简便性,从而简化了应用程序开发。
在这里插入图片描述

Kafka的消息分区用于存储和传递消息, Kafka Streams对数据进行分区以进行处理。 Kafka Streams使用Partition和Task的概念作为基于Kafka Topic分区的并行模型的逻辑单元。在并行化的背景下,Kafka Streams和Kafka之间有着密切的联系:

  1. 每个stream分区都是完全有序的数据记录序列,并映射到Kafka Topic分区。
  2. Stream中的数据记录映射到该Topic的Kafka消息。
  3. 数据记录的key决定了Kafka和Kafka Streams中数据的分区,即数据如何路由到Topic的特定分区。
任务的并行度

Kafka Streams基于应用程序的输入流分区创建固定数量的Task,每个任务(Task)分配来自输入流的分区列表(即Kafka主题)。分区到任务的分配永远不会改变,因此每个任务都是应用程序的固定平行单元。然后,任务可以根据分配的分区实例化自己的处理器拓扑; 它们还为每个分配的分区维护一个缓冲区,并从这些记录缓冲区一次一个地处理消息。因此,流任务可以独立并行地处理,无需人工干预。

用户可以启动多个KafkaStream实例,这样等价启动了多个Stream Tread,每个Thread处理1~n个Task。一个Task对应一个分区,因此Kafka Stream流处理的并行度不会超越Topic的分区数。需要值得注意的是Kafka的每个Task都维护这自身的一些状态,线程之间不存在状态共享和通信。因此Kafka在实现流处理的过程中扩展是非常高效的。

容错

Kafka Streams构建于Kafka本地集成的容错功能之上。 Kafka分区具有高可用性和复制性;因此当流数据持久保存到Kafka时,即使应用程序失败并需要重新处理它也可用。 Kafka Streams中的任务利用Kafka消费者客户端提供的容错功能来处理故障。如果任务运行的计算机故障了,Kafka Streams会自动在其余一个正在运行的应用程序实例中重新启动该任务。

此外,Kafka Streams还确保local state store也很有力处理故障容错。对于每个state store,Kafka Stream维护一个带有副本changelog的Topic,在该Topic中跟踪任何状态更新。这些changelog Topic也是分区的,该分区和Task是一一对应的。如果Task在运行失败并Kafka Stream会在另一台计算机上重新启动该任务,Kafka Streams会保证在重新启动对新启动的任务的处理之前,通过重播相应的更改日志主题,将其关联的状态存储恢复到故障之前的内容。

实战篇

注:创建Kafka Streaming Topology有两种方式

  • low-level:Processor API
  • high-level:Kafka Streams DSL(DSL:提供了通用的数据操作算子,如:map, filter, join, and aggregations等)

low-level:Processor API

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>2.2.0</version>
</dependency>
  • 编写stream应用
package lowlevel;

import org.apache.kafka.common.serialization.LongSerializer;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.common.serialization.StringSerializer;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.Topology;

import java.util.Properties;

public class WortCountWithProcessorAPI {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "gaozhy:9092");
        properties.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        properties.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        properties.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-processor-application");

        // 创建Topology
        Topology topology = new Topology();
        topology.addSource("input", "input");
        topology.addProcessor("wordCountProcessor", () -> new WordCountProcessor(), "input");
        topology.addSink("output", "output", new StringSerializer(), new LongSerializer(), "wordCountProcessor");

        KafkaStreams streams = new KafkaStreams(topology, properties);
        streams.start();
    }
}
  • 编写自定义Processor
package lowlevel;

import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorContext;
import org.apache.kafka.streams.processor.PunctuationType;

import java.time.Duration;
import java.util.HashMap;

public class WordCountProcessor implements Processor<String, String> {
    private HashMap<String, Long> wordPair;
    private ProcessorContext context;

    @Override
    public void init(ProcessorContext context) {
        wordPair = new HashMap<>();
        this.context = context;
        // 每隔1秒将处理的结果向下游传递
        this.context.schedule(Duration.ofSeconds(1), PunctuationType.STREAM_TIME, timestamp -> {
            System.out.println("----------- " + timestamp + " ----------- ");
            wordPair.forEach((k,v) -> {
                System.out.println(k +" | "+v);
                this.context.forward(k,v);
            });
        });
    }

    @Override
    public void process(String key, String value) {
        String[] words = value.split(" ");
        for (String word : words) {
            Long num = wordPair.getOrDefault(word, 0L);
            num++;
            wordPair.put(word, num);
        }
        context.commit();
    }

    @Override
    public void close() {

    }
}
  • 测试

上面案列存在的问题:

  1. 宕机则计算的状态丢失
  2. 并没有考虑状态中keys的数目,一旦数目过大,会导致流计算服务内存溢出。
  • 状态存储

配置状态存储

// 创建state,存放状态信息
Map<String, String> changelogConfig = new HashMap();
// override min.insync.replicas
changelogConfig.put("min.insyc.replicas", "1");
changelogConfig.put("cleanup.policy","compact");
StoreBuilder<KeyValueStore<String, Long>> countStoreSupplier = Stores.keyValueStoreBuilder(
    Stores.persistentKeyValueStore("Counts"),
    Serdes.String(),
    Serdes.Long()).withLoggingEnabled(changelogConfig);

事实StateStore本质是一个Topic,但是改topic的清除策略不在是delete,而是compact.

关联StateStore和Processor

// 创建Topology
Topology topology = new Topology();
topology.addSource("input", "input");
topology.addProcessor("wordCountProcessor", () -> new WordCountProcessor(), "input");
// 创建state,存放状态信息
Map<String, String> changelogConfig = new HashMap();
// override min.insync.replicas
changelogConfig.put("min.insyc.replicas", "1");
changelogConfig.put("cleanup.policy","compact");
StoreBuilder<KeyValueStore<String, Long>> countStoreSupplier = Stores.keyValueStoreBuilder(
        Stores.persistentKeyValueStore("Counts"),
        Serdes.String(),
        Serdes.Long()).withLoggingEnabled(changelogConfig);

topology.addStateStore(countStoreSupplier,"wordCountProcessor");
topology.addSink("output", "output", new StringSerializer(), new LongSerializer(), "wordCountProcessor");

在自定义Processor实现类中使用state

package lowlevel;

import org.apache.kafka.streams.KeyValue;
import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorContext;
import org.apache.kafka.streams.processor.PunctuationType;
import org.apache.kafka.streams.state.KeyValueIterator;
import org.apache.kafka.streams.state.KeyValueStore;

import java.time.Duration;
import java.util.HashMap;

public class WordCountProcessor implements Processor<String, String> {
    private KeyValueStore<String, Long> keyValueStore;
    private ProcessorContext context;

    @Override
    public void init(ProcessorContext context) {
        keyValueStore = (KeyValueStore<String, Long>) context.getStateStore("Counts");
        this.context = context;
        // 定期向下游输出计算结果
        this.context.schedule(Duration.ofSeconds(1), PunctuationType.STREAM_TIME, timestamp -> {
            System.out.println("----------- " + timestamp + " ----------- ");
            KeyValueIterator<String, Long> iterator = keyValueStore.all();
            while (iterator.hasNext()) {
                KeyValue<String, Long> entry = iterator.next();
                this.context.forward(entry.key, entry.value);
            }
            iterator.close();
        });
    }

    @Override
    public void process(String key, String value) {
        String[] words = value.split(" ");
        for (String word : words) {
            Long oldValue = keyValueStore.get(word);
            if (oldValue == null) {
                keyValueStore.put(word, 1L);
            } else {
                keyValueStore.put(word, oldValue + 1L);
            }
        }
        context.commit();
    }

    @Override
    public void close() {

    }
}

high-level:Kafka Streams DSL(重点)

Kafka Streams DSL(Domain Specific Language)构建于Streams Processor API之上。它是大多数用户推荐的,特别是初学者。大多数数据处理操作只能用几行DSL代码表示。在 Kafka Streams DSL 中有这么几个概念KTable、KStream和GlobalKTable

KStream是一个数据流,可以认为所有记录都通过Insert only的方式插入进这个数据流里。而KTable代表一个完整的数据集,可以理解为数据库中的表。由于每条记录都是Key-Value对,这里可以将Key理解为数据库中的Primary Key,而Value可以理解为一行记录。可以认为KTable中的数据都是通过Update only的方式进入的。也就意味着,如果KTable对应的Topic中新进入的数据的Key已经存在,那么从KTable只会取出同一Key对应的最后一条数据,相当于新的数据更新了旧的数据。

以下图为例,假设有一个KStream和KTable,基于同一个Topic创建,并且该Topic中包含如下图所示5条数据。此时遍历KStream将得到与Topic内数据完全一样的所有5条数据,且顺序不变。而此时遍历KTable时,因为这5条记录中有3个不同的Key,所以将得到3条记录,每个Key对应最新的值,并且这三条数据之间的顺序与原来在Topic中的顺序保持一致。这一点与Kafka的日志compact相同。

此时如果对该KStream和KTable分别基于key做Group,对Value进行Sum,得到的结果将会不同。对KStream的计算结果是<Jack,4>,<Lily,7>,<Mike,4>。而对Ktable的计算结果是<Mike,4>,<Jack,3>,<Lily,5>。

GlobalKTable:和KTable类似,不同点在于KTable只能表示一个分区的信息,但是GlobalKTable表示的是全局的状态信息。

基于DSL风格的WordCount

pom.xml
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>2.2.0</version>
</dependency>
WordCountAppliction
package lowlevel;

import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.kstream.KStream;
import org.apache.kafka.streams.kstream.KTable;
import org.apache.kafka.streams.kstream.Produced;

import java.util.Arrays;
import java.util.Properties;

public class WordCountAppliction {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "gaozhy:9092");
        properties.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        properties.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
        properties.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");

        // 流处理构建对象
        StreamsBuilder builder = new StreamsBuilder();
        // input stream
        KStream<String, String> textLines = builder.stream("input");

        // 流处理
        // Hello World
        // k: Hello World v: Hello
        // k: Hello World v: World
        KTable<String, Long> wordCount = textLines.flatMapValues(v -> Arrays.asList(v.split(" ")))
                // hello hello
                // world word
                .groupBy((k, v) -> v)
                // hello 1
                // ....
                .count();

        // output stream
        wordCount.toStream().to("output", Produced.with(Serdes.String(), Serdes.Long()));

        KafkaStreams kafkaStreams = new KafkaStreams(builder.build(), properties);
        // 启动
        kafkaStreams.start();
    }
}
创建Topic——Producer Input和Consumer output
 gaozhy@MacBook  ~/app/kafka_2.11-2.0.0  bin/kafka-topics.sh --create --topic input --zookeeper gaozhy:2181 --partitions 1 --replication-factor 1
Created topic "input".
 gaozhy@MacBook  ~/app/kafka_2.11-2.0.0  bin/kafka-topics.sh --create --topic output --zookeeper gaozhy:2181 --partitions 1 --replication-factor 1
Created topic "output".
运行stream application

右键run->WordCountAppliction main()

Producer生产数据作为stream application的输入
 gaozhy@MacBook  ~/app/kafka_2.11-2.0.0  bin/kafka-console-producer.sh --broker-list gaozhy:9092 --topic input
>Hello World
>Hello Spark
>Hello Scala
>
从Consumer获取stream application的处理结果
bin/kafka-console-consumer.sh --bootstrap-server gaozhy:9092 \
    --topic output \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.LongDeserializer
Hello	1
World	1
Spark	1
Hello	3
Scala	1
结果剖析(略)

第一条record:all streams lead to kafka
图1

第二条record:hello kafka streams
图2

// 打印kafka streaming拓扑关系图
System.out.println(builder.build().describe());

Topologies:
   Sub-topology: 0
    Source: KSTREAM-SOURCE-0000000000 (topics: [input])
      --> KSTREAM-FLATMAPVALUES-0000000001
    Processor: KSTREAM-FLATMAPVALUES-0000000001 (stores: [])
      --> KSTREAM-KEY-SELECT-0000000002
      <-- KSTREAM-SOURCE-0000000000
    Processor: KSTREAM-KEY-SELECT-0000000002 (stores: [])
      --> KSTREAM-FILTER-0000000006
      <-- KSTREAM-FLATMAPVALUES-0000000001
    Processor: KSTREAM-FILTER-0000000006 (stores: [])
      --> KSTREAM-SINK-0000000005
      <-- KSTREAM-KEY-SELECT-0000000002
    Sink: KSTREAM-SINK-0000000005 (topic: KSTREAM-AGGREGATE-STATE-STORE-0000000003-repartition)
      <-- KSTREAM-FILTER-0000000006

  Sub-topology: 1
    Source: KSTREAM-SOURCE-0000000007 (topics: [KSTREAM-AGGREGATE-STATE-STORE-0000000003-repartition])
      --> KSTREAM-AGGREGATE-0000000004
    Processor: KSTREAM-AGGREGATE-0000000004 (stores: [KSTREAM-AGGREGATE-STATE-STORE-0000000003])
      --> KTABLE-TOSTREAM-0000000008
      <-- KSTREAM-SOURCE-0000000007
    Processor: KTABLE-TOSTREAM-0000000008 (stores: [])
      --> KSTREAM-SINK-0000000009
      <-- KSTREAM-AGGREGATE-0000000004
    Sink: KSTREAM-SINK-0000000009 (topic: output)
      <-- KTABLE-TOSTREAM-0000000008

剖析:

  1. 在kafka streaming拓扑关系图中有两个子拓扑Sub-topology: 0和Sub-topology: 1
  2. Sub-topology: 0的KSTREAM-SOURCE-0000000000会将input topic中的record作为数据源,然后经过处理器(Processor)KSTREAM-FLATMAPVALUES-0000000001、KSTREAM-KEY-SELECT-0000000002、KSTREAM-FILTER-0000000006(过滤掉key为空的中间结果),最终将处理完成的结果存放到topic KSTREAM-AGGREGATE-STATE-STORE-0000000003-repartition中。为什么这里需要*-repartition的topic呢?主要原因是保证在shuffle结束后key相同的record存放在*-repartition相同的分区中,这样就为下一步的统计做好了准备
  3. Sub-topology: 1的KSTREAM-SOURCE-0000000007将*-repartitiontopic中的record作为数据源,然后经过ProcessorKSTREAM-AGGREGATE-0000000004进行聚合操作,并且将聚合的状态信息存放大topicKSTREAM-AGGREGATE-STATE-STORE-0000000003中,继续经过ProcessorKTABLE-TOSTREAM-0000000008,最终将处理完成的结果存放到output中
状态存储
KTable<String, Long> wordCount = textLines.flatMapValues(v -> Arrays.asList(v.split(" ")))
                .groupBy((k, v) -> v)
                // 状态存储
                .count(Materialized.<String,Long,KeyValueStore<Bytes,byte[]>>as("counts"));
        // output stream
        wordCount.toStream().to("output", Produced.with(Serdes.String(), Serdes.Long()));
        System.out.println(builder.build().describe());
        KafkaStreams kafkaStreams = new KafkaStreams(builder.build(), properties);
        // 启动
        kafkaStreams.start();
无状态的转换算子(stateless)
  • Branch

    分流

    KStream<String, Long> stream = ...;
    KStream<String, Long>[] branches = stream.branch(
        (key, value) -> key.startsWith("A"), /* first predicate  */
        (key, value) -> key.startsWith("B"), /* second predicate */
        (key, value) -> true                 /* third predicate  */
      );
    
    // KStream branches[0] contains all records whose keys start with "A"
    // KStream branches[1] contains all records whose keys start with "B"
    // KStream branches[2] contains all other records
    
  • Filter | filterNot

    Filter: 保留符合条件的结果

    filterNot:保留不符合条件的结果

    // 保留所有的大于零的正数
    KStream<String, Long> onlyPositives = stream.filter((key, value) -> value > 0);
    
    KStream<String, Long> onlyPositives = stream.filterNot((key, value) -> value <= 0);
    
  • FlatMap

    将一条record变为多条record并且将多条记录展开

    KStream<String, Integer> transformed = stream.flatMap(
         // Here, we generate two output records for each input record.
         // We also change the key and value types.
         // Example: (345L, "Hello") -> ("HELLO", 1000), ("hello", 9000)
        (key, value) -> {
          List<KeyValue<String, Integer>> result = new LinkedList<>();
          result.add(KeyValue.pair(value.toUpperCase(), 1000));
          result.add(KeyValue.pair(value.toLowerCase(), 9000));
          return result;
        }
      );
    
  • FlatMapValues

    将一条record变为多条record并且将多条记录展开

    (k,v) -> (k,v1),(k,v2)….

    KStream<byte[], String> words = sentences.flatMapValues(value -> Arrays.asList(value.split("\\s+")));
    
  • Map | MapValues

    将一条record映射为另外的一条record

    KStream<String, Integer> transformed = stream.map(
        (key, value) -> KeyValue.pair(value.toLowerCase(), value.length()));
    
    KStream<byte[], String> uppercased = stream.mapValues(value -> value.toUpperCase());
    
  • Foreach

    最终操作,对每一个record进行函数处理

    stream.foreach((key, value) -> System.out.println(key + " => " + value));
    
  • GroupByKey | GroupBy

    根据Key分组或者根据指定Key分组

    KGroupedStream<byte[], String> groupedStream = stream.groupByKey();
    
    
    KGroupedStream<String, String> groupedStream = stream.groupBy(
        (key, value) -> value,
        Grouped.with(
          Serdes.String(), /* key (note: type was modified) */
          Serdes.String())  /* value */
      );
    
  • Merge

    将两个流合并为一个

    KStream<byte[], String> stream1 = ...;
    
    KStream<byte[], String> stream2 = ...;
    
    KStream<byte[], String> merged = stream1.merge(stream2);
    
  • Peek

    作为程序执行的探针,一般用于debug调试,因为peek并不会对后续的流数据带来任何影响。

    KStream<byte[], String> unmodifiedStream = stream.peek(
        (key, value) -> System.out.println("key=" + key + ", value=" + value));
    
  • Print

    最终操作,将每一个record进行输出打印

    stream.print(Printed.toSysOut());
    // 或
    stream.print(Printed.toFile("streams.out").withLabel("streams"));
    
  • SelectKey

    修改记录中key (k,v)—>(newkey,v)

    KStream<String, String> rekeyed = stream.selectKey((key, value) -> value.split(" ")[0])
    
有状态的转换算子(stateful)

有状态转换值得是每一次的处理都需要操作关联StateStore实现有状态更新。例如,在aggregating 操作中,window state store用于收集每个window的最新聚合结果。在join操作中,窗口状态存储用于收集到目前为止在定义的window边界内接收的所有记录。状态存储是容错的。如果发生故障,Kafka Streams保证在恢复处理之前完全恢复所有状态存储。

DSL中可用的有状态转换包括:

下图显示了它们之间的关系:

  • Aggregate

    滚动聚合 按分组键聚合(非窗口化)记录的值

    KTable<byte[], Long> aggregatedStream = groupedStream.aggregate(
        () -> 0L, /* initializer */
        (aggKey, newValue, aggValue) -> aggValue + newValue.length(), /* adder */
        Materialized.as("aggregated-stream-store") /* state store name */
            .withValueSerde(Serdes.Long()); /* serde for aggregate value */
    
  • Count

    滚动聚合 按分组键计算记录数

    KTable<String, Long> aggregatedStream = groupedStream.count();
    
  • Reduce

    滚动聚合 通过分组键组合(非窗口)记录的值

    KTable<String, Long> aggregatedStream = groupedStream.reduce(
        (aggValue, newValue) -> aggValue + newValue /* adder */);
    
  • 注意:有状态的算子在聚合操作时的状态存储

    KTable<String, Integer> aggregated = groupedStream.aggregate(
        () -> 0, /* initializer */
        (aggKey, newValue, aggValue) -> aggValue + newValue, /* adder */
        Materialized.<String, Long, KeyValueStore<Bytes, byte[]>as("aggregated-stream-store" /* state store name */)
          .withKeySerde(Serdes.String()) /* key serde */
          .withValueSerde(Serdes.Integer()); /* serde for aggregate value */
    
Window
  • Tumbling(翻滚) 固定大小 无重叠

    翻滚窗口将流元素按照固定的时间间隔,拆分成指定的窗口,窗口和窗口间元素之间没有重叠。在下图不同颜色的record表示不同的key。可以看是在时间窗口内,每个key对应一个窗口。前闭后开

    import org.apache.kafka.common.serialization.Serdes;
    import org.apache.kafka.common.utils.Bytes;
    import org.apache.kafka.streams.KafkaStreams;
    import org.apache.kafka.streams.KeyValue;
    import org.apache.kafka.streams.StreamsBuilder;
    import org.apache.kafka.streams.StreamsConfig;
    import org.apache.kafka.streams.kstream.*;
    import org.apache.kafka.streams.state.KeyValueStore;
    import org.apache.kafka.streams.state.WindowStore;
    
    import java.text.SimpleDateFormat;
    import java.time.Duration;
    import java.util.ArrayList;
    import java.util.Properties;
    
    public class KafkaStreamingWordCountWithWindow {
        public static void main(String[] args) {
            Properties properties = new Properties();
            properties.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount22");
            properties.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "gaozhy:9092");
            properties.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
            properties.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
    
            StreamsBuilder builder = new StreamsBuilder();
            // 流处理 数据的来源
            KStream<String, String> kStream = builder.stream("input");
    
            kStream
                    .flatMap((k, v) -> {
                        ArrayList<KeyValue<String, String>> keyValues = new ArrayList<>();
                        String[] words = v.split(" ");
                        for (String word : words) {
                            keyValues.add(new KeyValue<String, String>(k, word));
                        }
                        return keyValues;
                    })
                    .map((k, v) -> new KeyValue<String, Long>(v, 1L))
                    .groupBy((k, v) -> k, Grouped.with(Serdes.String(), Serdes.Long()))
              			// 滚动窗口的大小
                    .windowedBy(TimeWindows.of(Duration.ofSeconds(10)))
                    .reduce((value1, value2) -> value1 + value2, Materialized.<String, Long, WindowStore<Bytes, byte[]>>as("counts").withKeySerde(Serdes.String()).withValueSerde(Serdes.Long()))
                    .toStream()
                    .peek(((Windowed<String> key, Long value) -> {
                        Window window = key.window();
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                        long start = window.start();
                        long end = window.end();
                        System.out.println(sdf.format(start) + " ~ " + sdf.format(end) + "\t" + key.key() + "\t" + value);
                    }));
    
            // 构建kafka streaming 应用
            KafkaStreams kafkaStreams = new KafkaStreams(builder.build(), properties);
            kafkaStreams.start();
        }
    }
    
  • Hopping (跳跃) 固定大小 有重叠

    Hopping time windows是基于时间间隔的窗口。他们模拟固定大小的(可能)重叠窗口。跳跃窗口由两个属性定义:窗口大小和其提前间隔(又名“hop”)。

    import java.time.Duration;
    import org.apache.kafka.streams.kstream.TimeWindows;
    
    // A hopping time window with a size of 5 minutes and an advance interval of 1 minute.
    // The window's name -- the string parameter -- is used to e.g. name the backing state store.
    Duration windowSizeMs = Duration.ofMinutes(5);
    Duration advanceMs =    Duration.ofMinutes(1);
    TimeWindows.of(windowSizeMs).advanceBy(advanceMs);
    
  • Sliding (滑动) 固定大小 有重合 每一个窗口至少有一个事件

    窗口只用于2个KStream进行Join计算时。该窗口的大小定义了Join两侧KStream的数据记录被认为在同一个窗口的最大时间差。假设该窗口的大小为5秒,则参与Join的2个KStream中,记录时间差小于5的记录被认为在同一个窗口中,可以进行Join计算。

  • Session 动态 无重叠 数据驱动的窗口

    Session Window该窗口用于对Key做Group后的聚合操作中。它需要对Key做分组,然后对组内的数据根据业务需求定义一个窗口的起始点和结束点。一个典型的案例是,希望通过Session Window计算某个用户访问网站的时间。对于一个特定的用户(用Key表示)而言,当发生登录操作时,该用户(Key)的窗口即开始,当发生退出操作或者超时时,该用户(Key)的窗口即结束。窗口结束时,可计算该用户的访问时间或者点击次数等。

    Session Windows用于将基于key的事件聚合到所谓的会话中,其过程称为session化。会话表示由定义的不活动间隔(或“空闲”)分隔的活动时段。处理的任何事件都处于任何现有会话的不活动间隙内,并合并到现有会话中。如果事件超出会话间隙,则将创建新会话。会话窗口的主要应用领域是用户行为分析。基于会话的分析可以包括简单的指标.

    如果我们接收到另外三条记录(包括两条迟到的记录),那么绿色记录key的两个现有会话将合并为一个会话,从时间0开始到结束时间6,包括共有三条记录。蓝色记录key的现有会话将延长到时间5结束,共包含两个记录。最后,将在11时开始和结束蓝键的新会话。

    import java.time.Duration;
    import org.apache.kafka.streams.kstream.SessionWindows;
    
    // A session window with an inactivity gap of 5 minutes.
    SessionWindows.with(Duration.ofMinutes(5));
    
bigdata_kafka与streaming 一丶Kafka应用 鉴于kafka在实际使用时,绝大多数应用场景均为Producer和Consumer的API配合使用,故在此只介绍这两种API操作方法,其它的Connector和Streams还有admin可以视自身情况自行学习。 1.java版 实现步骤 创建maven项目(done) 加入kafka依赖 producer push message实现 consumerpull message实现 效... 阅读详情

相关推荐

Kafka Stream简介及基本运用(含案例)

参考博客: 1、Kafka Stream背景 1.1 Kafka Stream是什么 Kafka Streams是一套客户端类库,它可以对存储在Kafka内的数据进行流式处理和分析。 1.2 什么是流式计算 流式计算:输入是持续的,一般先定义目标计算,然后数据到来之后将计算逻辑应用于数据,往往用增量计算代替全量计算。 批量计算:一般先有全量数据集,然后定义计算逻辑,并将计算应用于全量数据。特点是全量计算,并且计算结果一次性全量输出。 1.3 为什么要有Kafka Stream 开源流式处理系统有:Spa

小财迷嘻嘻的博客 1万+

Kafka Streams——轻量级的流处理库

Kafka Streaming概述 Kafka Streams是一个用于构建应用程序和微服务的客户端库,其中的输入和输出数据存储在Kafka集群中。它结合了在客户端编写和部署标准Java和Scala应用程序的简单性,以及Kafka服务器端集群技术的优点。 特点 弹性、高可扩展、容错 可以部署在容器、虚拟机、单独、云环境中 同样适用于小型、中型和大型用例 集成Kafka Security 写标准的...

高興 1566

基于PySpark整合Spark Streaming与Kafka

本文介绍了基于PySpark整合Spark Streaming和Kafka实现实时消息处理的方案。首先搭建了单机Kafka环境(版本2.11-2.4.0),配置了Zookeeper和Kafka服务,并测试了消息生产消费功能。然后详细说明了Spark Streaming连接Kafka所需的两个关键JAR包,给出了PySpark程序示例,演示了如何通过KafkaUtils.createDirectStream接口实时消费Kafka消息并进行单词计数。程序采用Direct API模式,每5秒统计一次单词频率并输出

pysense的博客 9277

Spark streaming+Kafka

本文总结了Spark Streaming与Kafka集成的两种方式(Receiver方式与Direct方式)及其特点,重点介绍了Direct方式的优势:简化并行、高效存储和精确一次消费。文章详细阐述了如何通过KafkaManager实现offset管理,以及优化Spark向Kafka写入数据的方法。在WeTest舆情监控项目中,该方案成功应用于千万级游戏评论的实时词频统计。最后从批处理时间、Kafka拉取量、缓存、GC、并行度等维度提出了优化建议,展示了稳定运行的监控指标。为大规模流数据处理提供了实践参考。

zh_19995的博客 886

streaming-kafka:streaming消费kafka数据

Kafka-消费模型 High Level Consumer API 不需要自己管理offset 默认实现最少一次消息传递语义(At least once) comsumer数量 大于 partiton数量, 浪费。 comsumer数量 小于 partiton数量, 一个comsumer对应多个partiton 最好partiton数目是consumer数目的整数倍 Low Level Cons...

ll谢安生的博客 2151

整合Kafka到Spark Streaming——代码示例和挑战

作者Michael G. Noll是瑞士的一位工程师和研究员,效力于Verisign,是Verisign实验室的大规模数据分析基础设施(基础Hadoop)的技术主管。本文,Michael详细的演示了如何将Kafka整合到Spark Streaming中。 期间, Michael还提到了将Kafka整合到 Spark Streaming中的一些现状,非常值得阅读,虽然有一些信息在Spark 1.2版

stark_summer的专栏 12万+

spark streaming消费kafka maven依赖选择

当我们的spark streaming程序需要消费kafka数据,我们需要根据自己的spark版本和kafka broker版本选择合适的maven依赖   spark-streaming-kafka-0-8 spark-streaming-kafka-0-10 支持的kafka版本 0.8+ 0.10+ 依赖包使用的spark版本 2.0-及2.0+ ...

zhaolq1024的博客 6488

Structured_Streaming和Kafka整合

结构化流与Kafka的整合

qq_50215015的博客 1619

Structured-Streaming集成Kafka

Structured-Streaming初识》博客中已经初步认识了Structured-Streaming,Kafka作为目前最流行的一个分布式的实时流消息系统,是众多实时流处理框架的最优数据源之一。下面我们就跟着官方例子来看看Structured-Streaming是如何集成Kafka的?

lu070828的博客 1661

Spark Streaming基于kafka的Direct详解

本博文主要包括一下内容: 1,SparkStreaming on Kafka Direct工作原理机制 2,SparkStreaming on Kafka Direct 案例实战 3,SparkStreaming on Kafka Direct源码解析一:SparkStreaming on Kafka Direct工作原理机制:1、Direct方式特点:(1)Direct的方式是会直接操作ka

吾心光明 1万+

基于Python的Spark Streaming+Kafka编程实践

说明Spark Streaming的原理说明的文章很多,这里不做介绍。本文主要介绍使用Kafka作为数据源的编程模型,编码实践,以及一些优化说明 spark streaming:http://spark.apache.org/docs/1.6.0/streaming-programming-guide.html streaming-kafka-integration:http://sp

不积跬步,无以至千里;不积小流,无以成江海! 2万+

Kafka Streaming处理数据

用kafka streaming从kafka中拿数据,处理完数据后,再存到kafka中 有两种方式 第一种:直接全部写在main方法中 package com.wang.events; import org.apache.kafka.common.serialization.Serdes; import org.apache.kafka.streams.*; import org.apache.kafka.streams.kstream.KStream; import java.util.ArrayLi

Messi的小迷弟 475

Spark Streaming+kafka+eclipse编程

eclipse本身对Scala的支持不是很友好,但还是有一部分同学(比如我)习惯用eclipse来做开发。所以这里提供结合spark streaming+kafka编程在eclipse上实现的过程。###安装配置单机版kafka **如果已经有kafka,这一步跳过。参考官网介绍步骤进行。**(1) 下载kafka包并解压 > tar -xzf kafka_2.10-0.8.2.0.t

Amber_amber的专栏 2693

PySpark Structured Streaming kafka示例

PySpark Structured Streaming kafka示例 直接上代码: #!/usr/bin/env python3 # -*- coding: utf-8 -*- from pyspark.sql import SparkSession from pyspark.sql.functions import from_json from pyspark.sql.types...

Widsom的博客 3265

Spark Streaming 读取Kafka数据

1.引入Maven依赖 <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-core_2.11</artifactId> <version>2.1.1</vers...

fczheng的博客 365

Spark Streaming 之 Kafka 偏移量管理

本文主要介绍 Spark Streaming 应用开发中消费 Kafka 消息的相关内容,文章着重突出了开发环境的配置以及手动管理 Kafka 偏移量的实现。 一、开发环境 1、组件版本 CDH 集群版本:6.0.1 Spark 版本:2.2.0 Kafka 版本:1.0.1 2、Maven 依赖 &amp;lt;!-- scala --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;gr...

rochy_he的博客 2704

spark streaming 输出数据到kafka

一般都使用spark streaming从kafka 中消费数据,然后写到其他存储;项目中需要从kafka topic中读数据然后经过 spark streaming 处理后回写到kafka 另一个topic,此处记录下实现方法。环境:spark:1.6.1 stremaing-kafka: spark-streaming-kafka_2.10,1.6.1本例中,每个executor上存在一个单例

xueba207的专栏 1万+

一文读懂 MAVLink、PPM、SBUS:无人机通信协议的工作原理与适用场景

本文系统对比无人机领域三大核心通信协议:MAVLink作为全链路数据协议,支持飞控与地面站的双向通信,适合航拍测绘等专业场景;SBUS是数字化的高效控制协议,具备16通道、抗干扰特性,成为中高端设备标配;PPM作为传统模拟协议,成本低廉但性能有限,适合入门级应用。文章深入解析各协议的工作原理、帧结构、适用场景及调试技巧,指出MAVLink侧重状态监控、SBUS/PPM专注控制指令的互补关系,并给出新手选型建议:入门选PPM,进阶用SBUS,开发必备M

bother3000的博客 7130
上一篇: kafka学习资料
下一篇: Apache Storm学习资料
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值