二、Flink Hello World

1、批处理word count

首先新建idea 项目：

引入POM依赖：

```
<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <flink.version>1.12.1</flink.version>
    <scala.binary.version>2.12</scala.binary.version>
</properties>

<dependencies>
    <!-- fink -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>


</dependencies>

代码实现：

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;

/**
 * 批处理
 * @author xxx
 * @date Created in 2022/11/7 3:39 PM
 */
public class BatchWordCount {
    public static void main(String[] args) throws Exception {
        // 创建执行环境
        ExecutionEnvironment executionEnvironment = ExecutionEnvironment.getExecutionEnvironment();

        // 从文件中读取数据
        String filePath = "/Users/xxx/IdeaProjects/wdy/src/main/java/daily/flink/hello.txt";
        DataSource<String> dataSource = executionEnvironment.readTextFile(filePath);

        // 对数据集进行处理，按空格分词展开，转换成（word，1）二元组进行统计
        DataSet<Tuple2<String, Integer>> resultSet = dataSource.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                        // 按空格分词
                        String[] words = s.split(" ");
                        // 遍历所有word，组装成二元组输出
                        for (String str : words) {
                            collector.collect(new Tuple2<>(str, 1));
                        }
                    }
                })
                .groupBy(0)
                .sum(1);
        resultSet.print();
    }
}

读取的数据文件， hello.txt  自己随便写

hello world
hello flink
hello spark
how are you
fine thank you
and you
i am fine too

输出：

(thank,1)
(spark,1)
(and,1)
(fine,1)
(flink,1)
(world,1)
(are,1)
(you,3)
(hello,3)
(how,1)

2. 流处理word count

在批处理的基础上，新建一个类进行改动。

• 批处理=>几组或所有数据到达后才处理；流处理=>有数据来就直接处理，不等数据堆叠到一定数量级
• 这里不像批处理有groupBy => 所有数据统一处理，而是用流处理的keyBy => 每一个数据都对key进行hash计算，进行类似分区的操作，来一个数据就处理一次，所有中间过程都有输出！
• 并行度：开发环境的并行度默认就是计算机的CPU逻辑核数

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.client.program.StreamContextEnvironment;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

/**
 * 流处理
 *
 * 批处理=>几组或所有数据到达后才处理；流处理=>有数据来就直接处理，不等数据堆叠到一定数量级
 *
 * 这里不像批处理有groupBy => 所有数据统一处理，而是用流处理的keyBy => 每一个数据都对key进行hash计算，进行类似分区的操作，来一个数据就处理一次，所有中间过程都有输出！
 *
 * 并行度：开发环境的并行度默认就是计算机的CPU逻辑核数
 *
 * @author xxx
 * @date Created in 2022/11/7 3:50 PM
 */
public class StreamWordCount {

    public static void main(String[] args) throws Exception {
        // 创建流处理执行环境
        StreamExecutionEnvironment env = StreamContextEnvironment.getExecutionEnvironment();

        // 设置并行度，默认值 = 当前计算机的CPU逻辑核数（设置成1则是单线程处理）
//        env.setMaxParallelism(32);

        // 从文件中读取数据
        String filePath = "/Users/wangdanyang1/IdeaProjects/wdy/src/main/java/daily/flink/hello.txt";
//        DataStreamSource<String> inputDataStream = env.readTextFile(filePath);

        // 从socket文本流读取数据
        DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 7777);

        // 基于数据流进行转换计算
        SingleOutputStreamOperator<Tuple2<String, Integer>> resultStream = inputDataStream.flatMap(new FlatMapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
                // 按空格分词
                String[] words = s.split(" ");
                // 遍历所有word，组装成二元组输出
                for (String str : words) {
                    collector.collect(new Tuple2<>(str, 1));
                }
            }
        }).keyBy(new KeySelector<Tuple2<String, Integer>, String>() {
            @Override
            public String getKey(Tuple2<String, Integer> tuple2) throws Exception {
                return tuple2.f0;
            }
        }).sum(1);

        // out : 这里因为是流处理，所以所有中间过程都会被输出，前面的序号就是并行执行任务的线程编号
        resultStream.print();

        // 执行任务（此之前的代码，是在定义任务，执行此处后Flink才把前面代码片段当成任务整体
        env.execute();
    }
}

这里env.execute();之前的代码，可以理解为是在定义任务，只有执行env.execute()后，Flink才把前面的代码片段当作一个任务整体（每个线程根据这个任务操作，并行处理流数据）。

输出：

这里因为是流处理，所以所有中间过程都会被输出，前面的序号就是并行执行任务的线程编号。

7> (world,1)
4> (hello,1)
1> (spark,1)
4> (hello,2)
4> (hello,3)
10> (flink,1)
7> (you,1)
11> (and,1)
5> (thank,1)
7> (fine,1)
7> (you,2)
6> (are,1)
9> (how,1)
7> (you,3)

3、流式数据源测试

1、通过**nc -lk <port>** 打开一个socket服务，用于模拟实时的流数据

nc -lk 7777

2、代码修改inputStream的部分

// 从socket文本流读取数据
DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 7777);

3、在本地开启的socket中输入数据，观察IDEA的console输出。