一、前言
在上一篇文章中,我们学习了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() 提供了更灵活的合流方式,允许两条流的数据类型不同,一次只能连接两条流。
使用步骤:
案例代码:
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 的条件:
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 分流合流注意事项
6.3 Sink 端一致性保证
| Kafka | Exactly-Once | 基于两阶段提交(2PC) |
| FileSystem | Exactly-Once | 基于 Checkpoint 和文件重命名 |
| JDBC | At-Least-Once | 幂等写入或事务控制 |
| 自定义 | 视实现而定 | 需自行保证幂等或事务 |


