【大数据Flink】入门案例 -- WordCount（DataStream）

下面主要是使用 DataStream 的方式去实现，在 Flink 1.14版本之后，DataSet 的方式被弃用，主要开始使用 DataStream 的方式

这种方式有流处理和批处理两种方式，但是批处理 是用流处理模式做批处理，因此在最后要有一个启动的代码 env.execute()

不能强制用 批处理去处理流数据

1. 环境准备

StreamExecutionEnvironment 是所有 Flink 程序的基础。可以使用 StreamExecutionEnvironment 的如下静态方法获取 StreamExecutionEnvironment：

getExecutionEnvironment()

createLocalEnvironment()

createRemoteEnvironment(String host, int port, String... jarFiles)

通常，你只需要使用 getExecutionEnvironment() 即可，因为该方法会根据上下文做正确的处理

示例：

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

2. 数据加载

可以直接通过给变量赋值，也可以直接从文件中取值

DataStream<String> lineDS = env.fromElements("Who's there?",
                "I think I hear them. Stand, ho! Who's there?");

DataStream<String> text = env.readTextFile("file:///path/to/file");		//从文件中取值

3. 数据处理

3.1 切割

DataStream<String> words = lineDS.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                /*
                value 表示每一行数据，out表示输出的数据
                 */
                String[] arrStr = value.split(" ");
                for(String s:arrStr){
                    out.collect(s);
                }
            }
        });

3.2 标记

数据标记为1，wordAndOne是被标记完成的数据

MapFunction 方法的功能为数据标记，输入String，输出Tuple2

DataStream<Tuple2<String,Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String,Integer>>() {
    @Override
    public Tuple2<String, Integer> map(String s) throws Exception {
        // s 表示每一个单词。输入类型String，返回类型Tuple2<String, Integer>
        return Tuple2.of(s,1);
    }
});

3.3 分组

f0 表示对Tuple中的第一个参数进行分组

KeyedStream<Tuple2<String, Integer>, Object> grouped = wordAndOne.keyBy(value->value.f0);

3.4 聚合

/* sum 原函数，参数表示 以tuple中的哪个位置的参数聚合。1 表示对Tuple中的第二个参数进行聚合
public SingleOutputStreamOperator sum(int positionToSum) {
return this.aggregate(new SumAggregator(positionToSum, this.getType(), this.getExecutionConfig()));
}
*/

SingleOutputStreamOperator<Tuple2<String, Integer>> sum = grouped.sum(1);

4. 数据输出

sum.print();
env.execute();

源码

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

/*
DataStream 处理方式  --有流处理和批处理
 */

public class WordCount2 {

    public static void main(String[] args) throws Exception {
        //ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();         //DataSet方式处理数据
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<String> lineDS = env.fromElements("Who's there?", "I think I hear them. Stand, ho! Who's there?");

        // 数据切割-匿名函数
        DataStream<String> words = lineDS.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                /*
                value 表示每一行数据，out表示输出的数据
                 */
                String[] arrStr = value.split(" ");
                for(String s:arrStr){
                    out.collect(s);
                }
            }
        });

        // 数据标记为1，wordAndOne是被标记完成的数据
        // MapFunction 方法的功能为数据标记，输入String，输出Tuple2
        DataStream<Tuple2<String,Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String,Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String s) throws Exception {
                // s 表示每一个单词。输入类型String，返回类型Tuple2<String, Integer>
                return Tuple2.of(s,1);
            }
        });

        // 分组 -- 对标记完成的数据进行分组。
        // 0 表示对Tuple中的第一个参数进行分组
        KeyedStream<Tuple2<String, Integer>, Object> grouped = wordAndOne.keyBy(value->value.f0);

        // 聚合
        /* sum 原函数，参数表示 以tuple中的哪个位置的参数聚合。1 表示对Tuple中的第二个参数进行聚合
        public SingleOutputStreamOperator<T> sum(int positionToSum) {
            return this.aggregate(new SumAggregator(positionToSum, this.getType(), this.getExecutionConfig()));
         }
         */
        SingleOutputStreamOperator<Tuple2<String, Integer>> sum = grouped.sum(1);

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