欢迎光临
我们一直在努力

Flink DataStream物理分区、分流合流与Sink算子详解

一、前言

在上一篇文章中,我们学习了Flink DataStream API的基础转换算子(map/filter/flatMap)和聚合算子(keyBy/sum/reduce)。本文将继续深入,探讨以下几个核心主题:

  • 物理分区算子:控制数据在并行子任务间的分发策略
  • 分流操作:将一条数据流拆分成多条独立流
  • 合流操作:将多条流合并为一条流处理
  • Sink算子:将处理结果输出到外部系统

这些算子是构建复杂流处理管道的关键组件,也是面试中的高频考点。

在这里插入图片描述


二、物理分区算子(Physical Partitioning)

2.1 为什么需要物理分区

在Flink中,当数据从一个算子流向另一个算子时,如果两个算子的并行度不同,或者需要改变数据的分发策略,就需要进行物理分区。物理分区决定了数据如何在不同的并行子任务之间传递。

在这里插入图片描述

上图展示了Flink数据流在算子间的传输形式,可以是一对一(One-to-one)的直通模式,也可以是打乱的重分区(Redistributing)模式。物理分区算子让我们能够精细控制这一过程。

2.2 随机分区(shuffle)

shuffle() 是最简单的重分区方式,通过调用 DataStream.shuffle() 方法,将数据随机地分配到下游算子的并行任务中。

  • 服从均匀分布(uniform distribution)
  • 可以将流中的数据随机打乱,均匀传递到下游任务分区
  • 因为是完全随机的,对于同样的输入数据,每次执行结果可能不同

stream.shuffle().print();

适用场景:数据倾斜时做负载均衡,但会牺牲一定的顺序性。

2.3 轮询分区(rebalance)

rebalance() 使用 Round-Robin 负载均衡算法,将输入流数据平均分配到下游的并行任务中。

stream.rebalance().print();

适用场景:数据均匀分布,需要保证每个下游任务处理的数据量大致相等。

2.4 重缩放分区(rescale)

rescale() 与 rebalance() 非常相似,底层也使用 Round-Robin 算法,但只会将数据轮询发送到下游并行任务的一部分中。

  • rebalance:所有上游 subtask 向所有下游 subtask 发数据(完全轮询)
  • rescale:上游 subtask 只向部分下游 subtask 发数据(组内轮询)

stream.rescale().print();

在这里插入图片描述

如上图所示,rebalance 是全局轮询,而 rescale 是组内轮询,减少了网络传输开销。

适用场景:上下游并行度呈倍数关系时,使用 rescale 可以优化性能。

2.5 广播(broadcast)

broadcast() 将输入数据复制并发送到下游算子的所有并行任务中。每个下游任务都会收到完整的数据集。

stream.broadcast();

适用场景:需要将配置信息、规则表等广播到所有并行任务中。

2.6 全局分区(global)

global() 将所有输入流数据都发送到下游算子的第一个并行子任务中。

stream.global().print();

⚠️ 注意:这相当于强行让下游任务并行度变成1,可能对程序造成很大压力,使用时需要非常谨慎。

2.7 自定义分区(Custom)

当Flink提供的分区策略不能满足需求时,可以通过 partitionCustom() 方法自定义分区策略。

步骤一:实现 Partitioner 接口

public class MyPartitioner implements Partitioner<String> {
@Override
public int partition(String key, int numPartitions) {
return Integer.parseInt(key) % numPartitions;
}
}

步骤二:使用自定义分区

DataStream<String> socketDS = env.socketTextStream("hadoop102", 7777);

DataStream<String> myDS = socketDS
.partitionCustom(new MyPartitioner(), value -> value);

myDS.print();

适用场景:需要按照业务逻辑(如用户ID、地区等)将数据定向分发到特定分区。


三、分流操作(Split Stream)

3.1 什么是分流

所谓"分流",就是将一条数据流拆分成完全独立的两条甚至多条流。也就是基于一个 DataStream,定义一些筛选条件,将符合条件的数据拣选出来放到对应的流里。

在这里插入图片描述

3.2 简单实现:filter 分流

最直接的方式是针对同一条流多次独立调用 .filter() 方法进行筛选。

案例需求:读取整数数字流,划分为奇数流和偶数流。

public class SplitStreamByFilter {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env =
StreamExecutionEnvironment.getExecutionEnvironment();

SingleOutputStreamOperator<Integer> ds = env
.socketTextStream("hadoop102", 7777)
.map(Integer::valueOf);

// 使用filter过滤两次
SingleOutputStreamOperator<Integer> evenDS = ds.filter(x -> x % 2 == 0);
SingleOutputStreamOperator<Integer> oddDS = ds.filter(x -> x % 2 == 1);

evenDS.print("偶数");
oddDS.print("奇数");

env.execute();
}
}

缺点:

  • 代码冗余,处理逻辑重复写了多次
  • 本质上将原始数据流复制多份,分别筛选,效率不够高

3.3 侧输出流(Side Output)

更优雅的分流方式是使用侧输出流(Side Output)。通过调用上下文的 ctx.output() 方法,可以将数据输出到指定的侧输出流中。

在这里插入图片描述

核心概念:

  • OutputTag:侧输出流的标记,指定了侧输出流的id和类型
  • 主流:原始数据流经过处理后继续向下传递的数据
  • 侧输出流:从主流中分离出来的特定数据

案例需求:将 WaterSensor 按照 Id 类型进行分流。

public class SplitStreamByOutputTag {
public static void main(String[] args) throws Exception {
StreamExecutionEnvironment env =
StreamExecutionEnvironment.getExecutionEnvironment();

SingleOutputStreamOperator<WaterSensor> ds = env
.socketTextStream("hadoop102", 7777)
.map(new WaterSensorMapFunction());

// 定义侧输出流标签
OutputTag<WaterSensor> s1 = new OutputTag<>("s1",
Types.POJO(WaterSensor.class)){};
OutputTag<WaterSensor> s2 = new OutputTag<>("s2",
Types.POJO(WaterSensor.class)){};

// 使用ProcessFunction进行分流
SingleOutputStreamOperator<WaterSensor> ds1 = ds.process(
new ProcessFunction<WaterSensor, WaterSensor>() {
@Override
public void processElement(WaterSensor value, Context ctx,
Collector<WaterSensor> out) throws Exception {
if ("s1".equals(value.getId())) {
ctx.output(s1, value); // 输出到侧输出流s1
} else if ("s2".equals(value.getId())) {
ctx.output(s2, value); // 输出到侧输出流s2
} else {
out.collect(value); // 主流
}
}
}
);

// 打印主流
ds1.print("主流,非s1,s2的传感器");

// 获取侧输出流
SideOutputDataStream<WaterSensor> s1DS = ds1.getSideOutput(s1);
SideOutputDataStream<WaterSensor> s2DS = ds1.getSideOutput(s2);

s1DS.printToErr("s1");
s2DS.printToErr("s2");

env.execute();
}
}

侧输出流的优势:

  • 只需一次处理,不需要复制数据流
  • 可以同时输出到多个侧输出流
  • 数据类型可以灵活定义
  • 是处理迟到数据、异常数据的常用手段

四、合流操作

4.1 联合(Union)

union() 是最简单的合流操作,直接将多条流合在一起。要求流中的数据类型必须相同。

DataStreamSource<Integer> ds1 = env.fromElements(1, 2, 3);
DataStreamSource<Integer> ds2 = env.fromElements(2, 2, 3);
DataStreamSource<Integer> ds3 = env.fromElements(4, 5, 6);

// 多条流合并
DataStream<Integer> unionDS = ds1.union(ds2, ds3);
unionDS.print();

特点:

  • 可以合并多条流(参数可以是多个 DataStream)
  • 要求所有流的数据类型必须相同
  • 合并后的新流包含所有流中的元素

4.2 连接(Connect)

connect() 提供了更灵活的合流方式,允许两条流的数据类型不同,一次只能连接两条流。

使用步骤:

  • 基于一条 DataStream 调用 .connect() 方法,传入另一条 DataStream
  • 得到 ConnectedStreams
  • 调用 .map() / .flatMap() / .process() 进行同处理
  • 案例代码:

    public class ConnectDemo {
    public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env =
    StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    SingleOutputStreamOperator<Integer> source1 = env
    .socketTextStream("hadoop102", 7777)
    .map(i -> Integer.parseInt(i));

    DataStreamSource<String> source2 = env
    .socketTextStream("hadoop102", 8888);

    // 使用 connect 合流
    ConnectedStreams<Integer, String> connect = source1.connect(source2);

    SingleOutputStreamOperator<String> result = connect.map(
    new CoMapFunction<Integer, String, String>() {
    @Override
    public String map1(Integer value) throws Exception {
    return "来源于数字流:" + value.toString();
    }

    @Override
    public String map2(String value) throws Exception {
    return "来源于字母流:" + value;
    }
    }
    );

    result.print();
    env.execute();
    }
    }

    Connect 的特点:

    • 一次只能连接 2条流
    • 流的数据类型可以不一样
    • 连接后各处理各的(通过 CoMapFunction/CoProcessFunction)

    4.3 CoProcessFunction 实现双流Join

    CoProcessFunction 是处理函数家族中的一员,用于处理 ConnectedStreams,可以实现更复杂的双流关联逻辑。

    案例需求:连接两条流,输出能根据 id 匹配上的数据(类似 inner join 效果)。

    public class ConnectKeybyDemo {
    public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env =
    StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(2);

    DataStreamSource<Tuple2<Integer, String>> source1 = env.fromElements(
    Tuple2.of(1, "a1"),
    Tuple2.of(1, "a2"),
    Tuple2.of(2, "b"),
    Tuple2.of(3, "c")
    );

    DataStreamSource<Tuple3<Integer, String, Integer>> source2 = env.fromElements(
    Tuple3.of(1, "aa1", 1),
    Tuple3.of(1, "aa2", 2),
    Tuple3.of(2, "bb", 1),
    Tuple3.of(3, "cc", 1)
    );

    // 连接两条流
    ConnectedStreams<Tuple2<Integer, String>, Tuple3<Integer, String, Integer>>
    connect = source1.connect(source2);

    // 根据关联条件 keyBy,保证 key 相同的数据到一起去
    ConnectedStreams<Tuple2<Integer, String>, Tuple3<Integer, String, Integer>>
    connectKey = connect.keyBy(s1 -> s1.f0, s2 -> s2.f0);

    SingleOutputStreamOperator<String> result = connectKey.process(
    new CoProcessFunction<Tuple2<Integer, String>,
    Tuple3<Integer, String, Integer>, String>
    () {

    // 缓存来过的数据
    Map<Integer, List<Tuple2<Integer, String>>> s1Cache = new HashMap<>();
    Map<Integer, List<Tuple3<Integer, String, Integer>>> s2Cache = new HashMap<>();

    @Override
    public void processElement1(Tuple2<Integer, String> value,
    Context ctx, Collector<String> out) throws Exception {
    Integer id = value.f0;

    // 1. 存储s1数据
    if (!s1Cache.containsKey(id)) {
    List<Tuple2<Integer, String>> s1Values = new ArrayList<>();
    s1Values.add(value);
    s1Cache.put(id, s1Values);
    } else {
    s1Cache.get(id).add(value);
    }

    // 2. 根据id查找s2数据,输出匹配结果
    if (s2Cache.containsKey(id)) {
    for (Tuple3<Integer, String, Integer> s2Element : s2Cache.get(id)) {
    out.collect("s1:" + value + " <——> s2:" + s2Element);
    }
    }
    }

    @Override
    public void processElement2(Tuple3<Integer, String, Integer> value,
    Context ctx, Collector<String> out) throws Exception {
    Integer id = value.f0;

    // 1. 存储s2数据
    if (!s2Cache.containsKey(id)) {
    List<Tuple3<Integer, String, Integer>> s2Values = new ArrayList<>();
    s2Values.add(value);
    s2Cache.put(id, s2Values);
    } else {
    s2Cache.get(id).add(value);
    }

    // 2. 根据id查找s1数据,输出匹配结果
    if (s1Cache.containsKey(id)) {
    for (Tuple2<Integer, String> s1Element : s1Cache.get(id)) {
    out.collect("s1:" + s1Element + " <——> s2:" + value);
    }
    }
    }
    }
    );

    result.print();
    env.execute();
    }
    }

    实现原理:

    • 使用 HashMap 缓存两条流中已经到达的数据
    • 当一条流的数据到达时,先存入缓存,然后去另一条流的缓存中查找匹配项
    • 匹配成功则输出关联结果

    ⚠️ 注意:这种实现会无限制地增长状态,生产环境中需要配合状态TTL或窗口使用。


    五、Sink算子(输出算子)

    5.1 Sink 概述

    Flink作为数据处理框架,最终需要将计算结果写入外部存储,为外部应用提供支持。DataStream API 专门提供了向外部写入数据的方法。

    在这里插入图片描述

    Flink 1.12 之前使用 addSink() 方法,传入 SinkFunction 实现:

    stream.addSink(new SinkFunction<>(...));

    Flink 1.12 开始重构了 Sink 架构,使用 sinkTo() 方法:

    stream.sinkTo(...);

    5.2 输出到文件(FileSink)

    Flink 提供了流式文件系统连接器 FileSink,支持行编码(Row-encoded)和批量编码(Bulk-encoded)两种格式。

    public class SinkFile {
    public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env =
    StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(2);

    // 必须开启checkpoint,否则文件一直处于.inprogress状态
    env.enableCheckpointing(2000, CheckpointingMode.EXACTLY_ONCE);

    DataGeneratorSource<String> dataGeneratorSource = new DataGeneratorSource<>(
    new GeneratorFunction<Long, String>() {
    @Override
    public String map(Long value) throws Exception {
    return "Number:" + value;
    }
    },
    Long.MAX_VALUE,
    RateLimiterStrategy.perSecond(1000),
    Types.STRING
    );

    DataStreamSource<String> dataGen = env.fromSource(
    dataGeneratorSource,
    WatermarkStrategy.noWatermarks(),
    "data-generator"
    );

    // 构建 FileSink
    FileSink<String> fileSink = FileSink
    .<String>forRowFormat(
    new Path("f:/tmp"),
    new SimpleStringEncoder<>("UTF-8")
    )
    .withOutputFileConfig(
    OutputFileConfig.builder()
    .withPartPrefix("atguigu-")
    .withPartSuffix(".log")
    .build()
    )
    // 按小时分桶
    .withBucketAssigner(
    new DateTimeBucketAssigner<>("yyyy-MM-dd HH", ZoneId.systemDefault())
    )
    // 文件滚动策略
    .withRollingPolicy(
    DefaultRollingPolicy.builder()
    .withRolloverInterval(Duration.ofMinutes(1))
    .withMaxPartSize(new MemorySize(1024 * 1024))
    .build()
    )
    .build();

    dataGen.sinkTo(fileSink);
    env.execute();
    }
    }

    关键配置说明:

    配置项说明
    withPartPrefix / withPartSuffix 输出文件的前缀和后缀
    withBucketAssigner 分桶策略(如按时间分目录)
    withRollingPolicy 文件滚动策略(按时间或大小)
    CheckpointingMode 必须开启Checkpoint才能生成正式文件

    5.3 输出到 Kafka

    Flink 提供了 KafkaSink 连接器,支持 精准一次(Exactly-Once) 写入。

    在这里插入图片描述

    精准一次写入 Kafka 的条件:

  • 开启 Checkpoint
  • 设置事务前缀
  • 设置事务超时时间:checkpoint间隔 < 事务超时时间 < max(15分钟)
  • public class SinkKafka {
    public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env =
    StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    // 必须开启checkpoint
    env.enableCheckpointing(2000, CheckpointingMode.EXACTLY_ONCE);

    SingleOutputStreamOperator<String> sensorDS = env
    .socketTextStream("hadoop102", 7777);

    KafkaSink<String> kafkaSink = KafkaSink.<String>builder()
    .setBootstrapServers("hadoop102:9092,hadoop103:9092,hadoop104:9092")
    .setRecordSerializer(
    KafkaRecordSerializationSchema.<String>builder()
    .setTopic("ws")
    .setValueSerializationSchema(new SimpleStringSchema())
    .build()
    )
    // 精准一次
    .setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE)
    // 事务前缀
    .setTransactionalIdPrefix("atguigu-")
    // 事务超时时间
    .setProperty(ProducerConfig.TRANSACTION_TIMEOUT_CONFIG,
    10 * 60 * 1000 + "")
    .build();

    sensorDS.sinkTo(kafkaSink);
    env.execute();
    }
    }

    自定义序列化器(带key写入):

    KafkaSink<String> kafkaSink = KafkaSink.<String>builder()
    .setBootstrapServers("hadoop102:9092")
    .setRecordSerializer(
    new KafkaRecordSerializationSchema<String>() {
    @Nullable
    @Override
    public ProducerRecord<byte[], byte[]> serialize(
    String element, KafkaSinkContext context, Long timestamp) {
    String[] datas = element.split(",");
    byte[] key = datas[0].getBytes(StandardCharsets.UTF_8);
    byte[] value = element.getBytes(StandardCharsets.UTF_8);
    return new ProducerRecord<>("ws", key, value);
    }
    }
    )
    .setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE)
    .setTransactionalIdPrefix("atguigu-")
    .build();

    5.4 输出到 MySQL(JDBC Sink)

    Flink 通过 JDBC 连接器可以将数据写入 MySQL 等关系型数据库。

    依赖配置:

    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.27</version>
    </dependency>

    <dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-jdbc</artifactId>
    <version>1.17-SNAPSHOT</version>
    </dependency>

    代码实现:

    public class SinkMySQL {
    public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env =
    StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    SingleOutputStreamOperator<WaterSensor> sensorDS = env
    .socketTextStream("hadoop102", 7777)
    .map(new WaterSensorMapFunction());

    // JDBCSink的4个参数
    SinkFunction<WaterSensor> jdbcSink = JdbcSink.sink(
    // 1. 执行的SQL
    "insert into ws values(?,?,?)",

    // 2. 预编译SQL,填充占位符
    new JdbcStatementBuilder<WaterSensor>() {
    @Override
    public void accept(PreparedStatement ps, WaterSensor sensor)
    throws SQLException {
    ps.setString(1, sensor.getId());
    ps.setLong(2, sensor.getTs());
    ps.setInt(3, sensor.getVc());
    }
    },

    // 3. 执行选项(攒批、重试)
    JdbcExecutionOptions.builder()
    .withMaxRetries(3) // 重试次数
    .withBatchSize(100) // 批次大小
    .withBatchIntervalMs(3000) // 批次时间间隔
    .build(),

    // 4. 连接选项
    new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
    .withUrl("jdbc:mysql://hadoop102:3306/test?serverTimezone=Asia/Shanghai")
    .withUsername("root")
    .withPassword("000000")
    .withConnectionCheckTimeoutSeconds(60)
    .build()
    );

    sensorDS.addSink(jdbcSink);
    env.execute();
    }
    }

    JdbcExecutionOptions 配置说明:

    参数说明
    withBatchSize 每批写入的数据条数
    withBatchIntervalMs 批次时间间隔
    withMaxRetries 写入失败时的重试次数

    5.5 自定义 Sink

    如果 Flink 没有提供对应的外部系统连接器,可以自定义 Sink。

    stream.addSink(new MySinkFunction<String>());

    实现 SinkFunction 接口,重写 invoke() 方法:

    public class MySinkFunction<T> implements SinkFunction<T> {
    @Override
    public void invoke(T value, Context context) throws Exception {
    // 将数据发送到外部系统的逻辑
    System.out.println("写入数据: " + value);
    }
    }

    也可以继承 RichSinkFunction 获取生命周期方法:

    public class MyRichSink extends RichSinkFunction<String> {
    private Connection conn;

    @Override
    public void open(Configuration parameters) throws Exception {
    // 初始化连接
    }

    @Override
    public void invoke(String value, Context context) throws Exception {
    // 写入数据
    }

    @Override
    public void close() throws Exception {
    // 关闭连接
    }
    }


    六、常见问题与注意事项

    6.1 物理分区选择建议

    场景推荐分区方式
    数据倾斜,需要负载均衡 shuffle() 或 rebalance()
    上下游并行度呈倍数关系 rescale()
    配置广播到所有任务 broadcast()
    需要按业务规则定向分发 partitionCustom()
    强制单线程处理 global()(慎用)

    6.2 分流合流注意事项

  • Union 要求数据类型必须相同,且只是简单合并,不会去重
  • Connect 可以连接不同类型流,但一次只能连两条
  • CoProcessFunction 实现双流 Join 时,注意状态无限增长问题,生产环境需配合 TTL
  • 侧输出流 是分流的首选方式,性能优于多次 filter
  • 6.3 Sink 端一致性保证

    外部系统一致性保证说明
    Kafka Exactly-Once 基于两阶段提交(2PC)
    FileSystem Exactly-Once 基于 Checkpoint 和文件重命名
    JDBC At-Least-Once 幂等写入或事务控制
    自定义 视实现而定 需自行保证幂等或事务
    赞(0)
    未经允许不得转载:171主机测评 » Flink DataStream物理分区、分流合流与Sink算子详解
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址