- **方法如下：**
相鄰的運算元：當兩個運算元直接連線在一起，沒有其他運算元或鍵控運運算元將它們分離時，它們就會被自動合併為一個運算元鏈。
相同的操作型別：當兩個運算元擁有相同的操作型別時，它們就可以被合併為一個運算元鏈。
運算元的並行度相同：當相鄰的兩個運算元擁有相同的並行度時，它們可以被合併為一個運算元鏈。
使用者手動合併：如果使用者透過呼叫 DataStream.transform() 方法來顯式地定義運算元鏈，那麼這些運算元也會被合併為一個運算元鏈。

- **相鄰的運算元**
```java
public class WordCountExample {
    
    public static void main(String[] args) throws Exception {
        
        // 獲取執行引數
        final ParameterTool params = ParameterTool.fromArgs(args);
        
        // 建立執行環境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        
        // 獲取輸入資料
        DataStream<string> text = env.readTextFile(params.get("input"));
        
        // 將每行字串拆分為單詞
        DataStream<string> words = text.flatMap(new FlatMapFunction<string string="">() {
            @Override
            public void flatMap(String value, Collector<string> out) throws Exception {
                for (String word : value.split("\\s")) {
                    out.collect(word);
                }
            }
        });
        
        // 計算單詞出現的次數
        DataStream<tuple2 integer="">> counts = words
                .map(new MapFunction<string tuple2="" integer="">>() {
                    @Override
                    public Tuple2<string integer=""> map(String value) throws Exception {
                        return new Tuple2<>(value, 1);
                    }
                })
                .keyBy(0)
                .sum(1);
        
        // 輸出結果
        if (params.has("output")) {
            counts.writeAsText(params.get("output"));
        } else {
            counts.print();
        }
        
        // 啟動執行程式
        env.execute("Word Count");
    }
}
```
flatMap 和 map 運算元被連線起來，並形成了一個運算元鏈，這是由於 flatMap 直接連線到 map 上，它們沒有任何其他運算元或鍵控運運算元將它們分離。

- **相同的操作型別**
```java
public class OperatorChainingExample {
    
    public static void main(String[] args) throws Exception {
        
        // 獲取執行引數
        final ParameterTool params = ParameterTool.fromArgs(args);
        
        // 建立執行環境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        
        // 獲取輸入資料
        DataStream<string> text = env.readTextFile(params.get("input"));
        
        // 轉換為大寫字母
        DataStream<string> upperCaseStream = text
                .map(new MapFunction<string string="">() {
                    @Override
                    public String map(String value) throws Exception {
                        return value.toUpperCase();
                    }
                })
                .map(new MapFunction<string string="">() {
                    @Override
                    public String map(String value) throws Exception {
                        return value + "!";
                    }
                });
        
        // 輸出結果
        if (params.has("output")) {
            upperCaseStream.writeAsText(params.get("output"));
        } else {
            upperCaseStream.print();
        }
        
        // 啟動執行程式
        env.execute("Operator Chaining");
    }
}
```
map 運算元被連線起來，並形成了一個運算元鏈，這是由於 map 運算元被重複使用，並且它們的操作型別相同。

- **運算元的並行度相同**
```java
DataStream<string> lines = env.socketTextStream("localhost", 9999).setParallelism(4);
DataStream<string> words = lines.flatMap(new FlatMapFunction<string string="">() {
    @Override
    public void flatMap(String line, Collector<string> out) {
        for (String word : line.split(" ")) {
            out.collect(word);
        }
    }
}).setParallelism(4);
DataStream<tuple2 integer="">> counts = words
        .map(new MapFunction<string tuple2="" integer="">>() {
            @Override
            public Tuple2<string integer=""> map(String word) {
                return new Tuple2<>(word, 1);
            }
        }).setParallelism(4)
        .keyBy(new KeySelector<tuple2 integer="">, String>() {
            @Override
            public String getKey(Tuple2<string integer=""> tuple) {
                return tuple.f0;
            }
        }).sum(1).setParallelism(4);
counts.print().setParallelism(4);
env.execute("WordCount");
```
相鄰的兩個運算元 flatMap 和 map 的並行度都設定為了 4。因此，它們被合併為了一個運算元鏈。

- **使用者手動合併**
```java
DataStream<string> lines = env.socketTextStream("localhost", 9999);
DataStream<tuple2 integer="">> wordCounts = lines
        .transform("MyWordCount", TypeInformation.of(new TypeHint<tuple2 integer="">>() {}), new MyWordCountFunction())
        .setParallelism(4);

wordCounts.print();

env.execute("User-defined Operator Chain Example");
```</tuple2></tuple2></string></string></tuple2></string></string></tuple2></string></string></string></string></string></string></string></string></string></string></tuple2></string></string></string></string>

Flink - 運算元鏈合併方法

相關文章