写了半个月近3万字，助你直接上手Flink，原来这就是流批一体的处理方式

已于 2023-01-17 15:43:18 修改
阅读量1.2k 收藏 7
点赞数 4
分类专栏： Flink 文章标签： 大数据 flink 数据仓库 java
于 2022-11-19 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chad_it/article/details/127931135
版权

Flink即刻出发

flink中文官网： https://flink.apache.org/zh/

1.1.Flink 数据流

在 Flink 中，应用程序由数据流组成，这些数据流可以由用户定义的运算符（注：有时我们称这些运算符为“算子”）进行转换。这些数据流形成有向图，从一个或多个源开始，以一个或多个输出结束。

在这里插入图片描述
在这里插入图片描述

Flink 支持流处理和批处理，它是一个分布式的流批结合的大数据处理引擎。在 Flink 中，认为所有的数据本质上都是随时间产生的流数据，把批数据看作是流数据的特例，只不过流数据是一个无界的数据流，而批数据是一个有界的数据流（例如固定大小的数据集）。如下图所示：
在这里插入图片描述
在这里插入图片描述

因此，Flink 是一个用于在无界和有界数据流上进行有状态计算的通用的处理框架，它既具有处理无界流的复杂功能，也具有专门的运算符来高效地处理有界流。通常我们称无界数据为实时数据，来自消息队列或分布式日志等流源（如 Apache Kafka 或 Kinesis）。而有界数据，通常指的是历史数据，来自各种数据源（如文件、关系型数据库等）。由 Flink 应用程序产生的结果流可以发送到各种各样的系统，并且可以通过 REST API 访问 Flink 中包含的状态。
在这里插入图片描述

当 Flink 处理一个有界的数据流时，就是采用的批处理工作模式。在这种操作模式中，我们可以选择先读取整个数据集，然后对数据进行排序、计算全局统计数据或生成总结所有输入的最终报告。当 Flink 处理一个无界的数据流时，就是采用的流处理工作模式。对于流数据处理，输入可能永远不会结束，因此我们必须在数据到达时持续不断地对这些数据进行处理。

1.2.Flink 分层 API

Flink 提供了开发流/批处理应用程序的API供开发者使用，越往上抽象程度越高，使用起来越方便；越往下越底层，使用起来难度越大，如下图所示：
在这里插入图片描述

Flink 提供了三个分层的 API。每个 API 在简洁性和表达性之间提供了不同的权衡，并针对不同的应用场景。
在这里插入图片描述
在这里插入图片描述

注意：在Flink1.12时支持流批一体，DataSetAPI已经不推荐使用了，所以博主在文章中除了个别案例使用DataSet外，后续其他案例都会优先使用DataStream流式API，既支持无界数据处理/流处理，也支持有界数据处理/批处理！当然Table&SQL-API会单独学习

https://ci.apache.org/projects/flink/flink-docs-release-1.14/zh/docs/dev/dataset/overview/

1.3.Flink流处理程序的一般流程

  • 获取Flink流处理执行环境
  • 构建source
  • 数据处理
  • 构建sink

1.4.搭建Flink工程

1.4.1.创建Maven项目

创建maven项目，项目名称：flinkbase
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.4.2.导入pom依赖
在这里插入图片描述

<!-- 指定仓库位置，依次为aliyun、apache和cloudera仓库 -->
<repositories>
    <repository>
        <id>aliyun</id>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    </repository>
    <repository>
        <id>apache</id>
        <url>https://repository.apache.org/content/repositories/snapshots/</url>
    </repository>
    <repository>
        <id>cloudera</id>
        <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
</repositories>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <flink.version>1.14.0</flink.version>
    <hive.version>3.1.2</hive.version>
    <mysql.version>5.1.48</mysql.version>
    <vertx.version>3.9.0</vertx.version>
    <commons.collections4>4.4</commons.collections4>
    <fastjson.version>1.2.68</fastjson.version>
    <log4j.version>1.7.7</log4j.version>
    <lombok.version>1.18.22</lombok.version>
    <kafka.version>3.0.0</kafka.version>
    <flink-shaded-hadoop.version>3.1.1.7.2.9.0-173-9.0</flink-shaded-hadoop.version>
    <collections4.version>4.4</collections4.version>
    <avro.version>1.10.2</avro.version>
    <flink-filesystem.version>1.11.4</flink-filesystem.version>
    <!-- sdk -->
    <java.version>1.8</java.version>
    <scala.version>2.12</scala.version>
    <scala.binary.version>2.12</scala.binary.version>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>
</properties>
<dependencies>
    <dependency>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <version>${scala.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-scala_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- web ui的依赖 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-runtime-web_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- Apache Flink 的依赖 -->
    <!-- 这些依赖项，不应该打包到JAR文件中. -->
    <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-streaming-java_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- 用于通过自定义功能，格式等扩展表生态系统的通用模块-->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-api-scala-bridge_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-api-java-bridge_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-planner_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-common</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-queryable-state-runtime</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- flink连接器-->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-sql-connector-kafka_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-pulsar_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-csv</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-json</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-filesystem_${scala.binary.version}</artifactId>
        <version>${flink-filesystem.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-parquet_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.bahir</groupId>
        <artifactId>flink-connector-redis_2.11</artifactId>
        <version>1.0</version>
        <exclusions>
            <exclusion>
                <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
                <groupId>org.apache.flink</groupId>
            </exclusion>
            <exclusion>
                <artifactId>flink-runtime_${scala.binary.version}</artifactId>
                <groupId>org.apache.flink</groupId>
            </exclusion>
            <exclusion>
                <artifactId>flink-core</artifactId>
                <groupId>org.apache.flink</groupId>
            </exclusion>
            <exclusion>
                <artifactId>flink-java</artifactId>
                <groupId>org.apache.flink</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-hive_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hive</groupId>
        <artifactId>hive-metastore</artifactId>
        <version>${hive.version}</version>
        <exclusions>
            <exclusion>
                <artifactId>hadoop-hdfs</artifactId>
                <groupId>org.apache.hadoop</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.hive</groupId>
        <artifactId>hive-exec</artifactId>
        <version>${hive.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-shaded-hadoop-3-uber</artifactId>
        <version>${flink-shaded-hadoop.version}</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    <!-- 高性能异步组件：Vertx-->
    <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-core</artifactId>
        <version>${vertx.version}</version>
    </dependency>
    <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-jdbc-client</artifactId>
        <version>${vertx.version}</version>
    </dependency>
    <dependency>
        <groupId>io.vertx</groupId>
        <artifactId>vertx-redis-client</artifactId>
        <version>${vertx.version}</version>
    </dependency>
    <!-- 日志 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${log4j.version}</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${fastjson.version}</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>${collections4.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.thrift</groupId>
        <artifactId>libfb303</artifactId>
        <version>0.9.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.avro</groupId>
        <artifactId>avro</artifactId>
        <version>${avro.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-avro</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>${kafka.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-streams</artifactId>
        <version>${kafka.version}</version>
    </dependency>
</dependencies>
<build>
    <sourceDirectory>src/main/java</sourceDirectory>
    <plugins>
        <!-- 编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.5.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <!--<encoding>${project.build.sourceEncoding}</encoding>-->
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.18.1</version>
            <configuration>
                <useFile>false</useFile>
                <disableXmlReport>true</disableXmlReport>
                <includes>
                    <include>**/*Test.*</include>
                    <include>**/*Suite.*</include>
                </includes>
            </configuration>
        </plugin>
        <!-- 打包插件(会包含所有依赖) -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>2.3</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <!--
                                    zip -d learn_spark.jar META-INF/*.RSA META-INF/*.DSA META-INF/*.SF -->
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <!-- 设置jar包的入口类(可选) -->
                                <mainClass></mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

1.5.批处理的单词统计

1.5.1.示例

编写Flink程序，读取文件中的字符串，并以空格进行单词拆分打印。

1.5.2.开发步骤

  • 获取批处理运行环境
  • 指定读取文件路径，获取数据
  • 对获取到的数据进行空格拆分
  • 对拆分后的单词，每个单词记一次数
  • 对拆分后的单词进行分组
  • 根据单词的次数进行聚合
  • 打印输出
  • 启动执行

1.5.3.参考代码

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

/**
 * 需求：批的方式统计单词出现的次数
 * todo 使用flink1.12版本之前流批一体架构不太成熟，因此批流开发需要使用两套api实现，但是从该版本以后，可以使用一套既可以跑批作业，也可以跑流作业
 *  批作业的数据抽象是：DataSet
 *  流作业的数据抽象是：DataStream
 *
 *  在flink1.12以后，批流作业的数据抽象是：DataStream
 */
public class BatchWordCount {
    public static void main(String[] args) throws Exception {
        /**
         * 实现步骤
         * 1）获取批处理的运行环境
         * 2）指定文件路径，获取数据
         * 3）对获取到的数据进行空格拆分
         * 4）对拆后的数据进行单词计数，每个单词记一次数
         * 5）对第四步的结果进行按照单词进行分组
         * 6）根据单词出现的计数进行聚合操作
         * 7）打印输出
         * 8）启动运行
         */
        //todo 1）获取批处理的运行环境
        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

        //todo 2）指定文件路径，获取数据(ctrl+p：查看方法参数说明)
        DataSource<String> textFile = env.readTextFile("./data/input/wordcount.txt");

        //todo 3）对获取到的数据进行空格拆分(ctrl+n：搜索类)
        FlatMapOperator<String, String> words = textFile.flatMap(new FlatMapFunction<String, String>() {
            //（ctrl+i：重写父类的方法）
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //根据空格拆分字符串
                String[] words = value.split(" ");
                //循环单词数组，将每个单词返回
                for (String word : words) {
                    //返回数据
                    out.collect(word);
                }
            }
        });
        //todo 4）对拆后的数据进行单词计数，每个单词记一次数
        MapOperator<String, Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                return Tuple2.of(value, 1);
            }
        });
        //todo 5）对第四步的结果进行按照单词进行分组
        UnsortedGrouping<Tuple2<String, Integer>> grouped = wordAndOne.groupBy(0);

        //todo 6）根据单词出现的计数进行聚合操作
        AggregateOperator<Tuple2<String, Integer>> sumed = grouped.sum(1);

        //todo 7）打印输出
        sumed.print();

        //todo 8）启动运行（批处理里面可以忽略，print方法会触发作业执行）
    }
}

1.6.流处理的单词统计

1.6.1.示例

编写Flink程序，接收socket的单词数据，并以空格进行单词拆分打印。

1.6.2.开发步骤

  • 获取流处理运行环境
    -构建socket流数据源，并指定IP地址和端口号
  • 对接收到的数据进行空格拆分
  • 对拆分后的单词，每个单词记一次数
  • 对拆分后的单词进行分组
  • 根据单词的次数进行聚合
  • 打印输出
  • 启动执行
  • 在Linux中，使用nc -lk 端口号监听端口，并发送单词
  • 安装nc: yum install -y nc
  • nc -lk 9999 监听9999端口的信息

1.6.3. 参考代码：java语言实现

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.operators.FlatMapOperator;
import org.apache.flink.api.java.operators.MapOperator;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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;

/**
 * 需求：编写Flink程序，接收socket的单词数据，并以空格进行单词拆分打印。
 */
public class StreamingWordCount {
    public static void main(String[] args) {
        /**
         * 实现步骤：
         * 1）获取流处理的运行环境
         * 2）构建socket数据源接受数据，指定ip和端口号
         * 3）对接收到的数据进行空格拆分
         * 4）对拆后的数据进行单词计数，每个单词记一次数
         * 5）对第四步的结果进行按照单词进行分组
         * 6）根据单词出现的计数进行聚合操作
         * 7）打印输出
         * 8）启动运行
         */

        //todo 1）获取流处理的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //设置全局并行度
        env.setParallelism(1);

        //todo 2）构建socket数据源接受数据，指定ip和端口号
        DataStreamSource<String> socketTextStream = env.socketTextStream("node1", 9999);

        //todo 3）对接收到的数据进行空格拆分
        SingleOutputStreamOperator<String> streamOperator = socketTextStream.flatMap(new FlatMapFunction<String, String>() {
            //（ctrl+i：重写父类的方法）
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //根据空格拆分字符串
                String[] words = value.split(" ");
                //循环单词数组，将每个单词返回
                for (String word : words) {
                    //返回数据
                    out.collect(word);
                }
            }
        });

        //todo 4）对拆后的数据进行单词计数，每个单词记一次数
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = streamOperator.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                return Tuple2.of(value, 1);
            }
        });

        //todo 5）对第四步的结果进行按照单词进行分组
        KeyedStream<Tuple2<String, Integer>, String> keyedStream = wordAndOne.keyBy(new KeySelector<Tuple2<String, Integer>, String>() {
            @Override
            public String getKey(Tuple2<String, Integer> value) throws Exception {
                return value.f0;
            }
        });
        //todo 6）根据单词出现的计数进行聚合操作
        SingleOutputStreamOperator<Tuple2<String, Integer>> sumed = keyedStream.sum(1);
        //todo 7）打印输出
        sumed.printToErr();
        //try。。。(ctrl+alt+t)
        try {
            //todo 8）启动运行
            env.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.6.4.参考代码：Lambda实现

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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;

import java.util.Arrays;

/**
 * 需求：编写Flink程序，接收socket的单词数据，并以空格进行单词拆分打印。
 */
public class LambdaStreamingWordCount {
    public static void main(String[] args) {
        /**
         * 实现步骤：
         * 1）获取流处理的运行环境
         * 2）构建socket数据源接受数据，指定ip和端口号
         * 3）对接收到的数据进行空格拆分
         * 4）对拆后的数据进行单词计数，每个单词记一次数
         * 5）对第四步的结果进行按照单词进行分组
         * 6）根据单词出现的计数进行聚合操作
         * 7）打印输出
         * 8）启动运行
         */

        //todo 1）获取流处理的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //todo 2）构建socket数据源接受数据，指定ip和端口号
        DataStreamSource<String> socketTextStream = env.socketTextStream("node1", 9999);

        //todo 3）对接收到的数据进行空格拆分
        SingleOutputStreamOperator<String> streamOperator = socketTextStream.flatMap((String line, Collector<String> out) ->
                Arrays.stream(line.split(" ")).forEach(out::collect)).returns(Types.STRING);

        //todo 4）对拆后的数据进行单词计数，每个单词记一次数
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = streamOperator
                .map(word -> (Tuple2.of(word, 1))).returns(Types.TUPLE(Types.STRING, Types.INT));

        //todo 5）对第四步的结果进行按照单词进行分组
        KeyedStream<Tuple2<String, Integer>, Tuple> keyedStream = wordAndOne.keyBy(0);

        //todo 6）根据单词出现的计数进行聚合操作
        SingleOutputStreamOperator<Tuple2<String, Integer>> sumed = keyedStream.sum(1);
        //todo 7）打印输出
        sumed.printToErr();
        //try。。。(ctrl+alt+t)
        try {
            //todo 8）启动运行
            env.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.6.5.参考代码：使用批流一体API编程模型实现

import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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;

/**
 * 使用流批一体的方式实现wordCount的单词统计
 *  既可以跑批作业也可以跑流，根据数据源的类型决定
 */
public class UnifyWordCount {
    public static void main(String[] args) {
        /**
         * 实现步骤：
         * 1）获取流处理的运行环境
         * 2）构建socket数据源接受数据，指定ip和端口号
         * 3）对接收到的数据进行空格拆分
         * 4）对拆后的数据进行单词计数，每个单词记一次数
         * 5）对第四步的结果进行按照单词进行分组
         * 6）根据单词出现的计数进行聚合操作
         * 7）打印输出
         * 8）启动运行
         */

        //todo 1）获取流处理的运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //env.setRuntimeMode(RuntimeExecutionMode.BATCH); //将当前作业强制按照批的方式运行，报错，因为数据源本身决定了无法以批的方式来运行
        //env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//将当前作业强制按照流的方式运行
        //env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//默认的运行模式，根据数据源自动判断

        //todo 2）构建socket数据源接受数据，指定ip和端口号
        //DataStreamSource<String> socketTextStream = env.socketTextStream("node1", 9999);
        DataStreamSource<String> socketTextStream = env.readTextFile("./data/input/wordcount.txt");

        //todo 3）对接收到的数据进行空格拆分
        SingleOutputStreamOperator<String> streamOperator = socketTextStream.flatMap(new FlatMapFunction<String, String>() {
            //（ctrl+i：重写父类的方法）
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //根据空格拆分字符串
                String[] words = value.split(" ");
                //循环单词数组，将每个单词返回
                for (String word : words) {
                    //返回数据
                    out.collect(word);
                }
            }
        });

        //todo 4）对拆后的数据进行单词计数，每个单词记一次数
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = streamOperator.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                return Tuple2.of(value, 1);
            }
        });

        //todo 5）对第四步的结果进行按照单词进行分组
        KeyedStream<Tuple2<String, Integer>, String> keyedStream = wordAndOne.keyBy(new KeySelector<Tuple2<String, Integer>, String>() {
            @Override
            public String getKey(Tuple2<String, Integer> value) throws Exception {
                return value.f0;
            }
        });
        //todo 6）根据单词出现的计数进行聚合操作
        SingleOutputStreamOperator<Tuple2<String, Integer>> sumed = keyedStream.sum(1);
        //todo 7）打印输出
        sumed.printToErr();
        //try。。。(ctrl+alt+t)
        try {
            //todo 8）启动运行
            env.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.7.Flink程序提交部署

Flink程序递交方式有两种：

  • 以UI的方式递交
  • 以命令的方式递交

1.7.1.编写程序

写入HDFS如果存在权限问题:
进行如下设置:

hadoop fs -chmod -R 777  /

并在代码中添加:

System.setProperty("HADOOP_USER_NAME", "root")

import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
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;

import java.util.Arrays;

/**
 * 编写Flink程序，读取文件中的字符串，并以空格进行单词拆分打印
 *
 */
public class BatchWordCountToYarn {
    public static void main(String[] args) throws Exception {
        ParameterTool parameterTool = ParameterTool.fromArgs(args);
        String output = "";
        if (parameterTool.has("output")) {
            output = parameterTool.get("output");
            System.out.println("指定了输出路径使用:" + output);
        } else {
            output = "hdfs://node1:8020/wordcount/output47_";
            System.out.println("可以指定输出路径使用 --output ,没有指定使用默认的:" + output);
        }

        //TODO 0.env
        //ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //env.setRuntimeMode(RuntimeExecutionMode.BATCH);//注意:使用DataStream实现批处理
        //env.setRuntimeMode(RuntimeExecutionMode.STREAMING);//注意:使用DataStream实现流处理
        //env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//注意:使用DataStream根据数据源自动选择使用流还是批

        //TODO 1.source
        //DataSet<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");
        DataStream<String> lines = env.fromElements("itcast hadoop spark", "itcast hadoop spark", "itcast hadoop", "itcast");

        //TODO 2.transformation
        //切割
        /*
        @FunctionalInterface
        public interface FlatMapFunction<T, O> extends Function, Serializable {
            void flatMap(T value, Collector<O> out) throws Exception;
        }
         */
        /*DataStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                //value就是每一行数据
                String[] arr = value.split(" ");
                for (String word : arr) {
                    out.collect(word);
                }
            }
        });*/
        SingleOutputStreamOperator<String> words = lines.flatMap(
                (String value, Collector<String> out) -> Arrays.stream(value.split(" ")).forEach(out::collect)
        ).returns(Types.STRING);


        //记为1
        /*
        @FunctionalInterface
        public interface MapFunction<T, O> extends Function, Serializable {
            O map(T value) throws Exception;
        }
         */
        /*DataStream<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String value) throws Exception {
                //value就是一个个单词
                return Tuple2.of(value, 1);
            }
        });*/
        DataStream<Tuple2<String, Integer>> wordAndOne = words.map(
                (String value) -> Tuple2.of(value, 1)
        ).returns(Types.TUPLE(Types.STRING, Types.INT));

        //分组:注意DataSet中分组是groupBy,DataStream分组是keyBy
        //wordAndOne.keyBy(0);
        /*
        @FunctionalInterface
        public interface KeySelector<IN, KEY> extends Function, Serializable {
            KEY getKey(IN value) throws Exception;
        }
         */
        KeyedStream<Tuple2<String, Integer>, String> grouped = wordAndOne.keyBy(t -> t.f0);

        //聚合
        SingleOutputStreamOperator<Tuple2<String, Integer>> result = grouped.sum(1);

        //TODO 3.sink
        //如果执行报hdfs权限相关错误,可以执行 hadoop fs -chmod -R 777  /
        System.setProperty("HADOOP_USER_NAME", "root");//设置用户名
        //result.print();
        //result.writeAsText("hdfs://node1:8020/wordcount/output47_"+System.currentTimeMillis()).setParallelism(1);
        result.writeAsText(output + System.currentTimeMillis()).setParallelism(1);

        //TODO 4.execute/启动并等待程序结束
        env.execute();
    }
}

package cn.itcast.day01.b;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.*;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
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;

/**
 * 需求：批的方式统计单词出现的次数
 * todo 使用flink1.12版本之前流批一体架构不太成熟，因此批流开发需要使用两套api实现，但是从该版本以后，可以使用一套既可以跑批作业，也可以跑流作业
 *  批作业的数据抽象是：DataSet
 *  流作业的数据抽象是：DataStream
 *
 *  在flink1.12以后，批流作业的数据抽象是：DataStream
 */
public class BatchWordCount {
    public static void main(String[] args) throws Exception {
        // 获取参数
        ParameterTool parameterTool = ParameterTool.fromArgs(args);

        String output = "";
        if(parameterTool.has("output")) {
            output = parameterTool.get("output");
            System.out.println("制定了输入路径使用: " + output);
        } else {
            output = "hdfs://node1:8020/wordcount/output66_";
            System.out.println("可以指定输出路径使用 --output ,没有指定使用默认的:" + output);
        }

        // 环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 数据源
        DataStreamSource<String> source = env.fromElements("hello flink spark hadoop", "hello flink spark", "hello flink");

        // 数据转换
        // 切割
        SingleOutputStreamOperator<String> words = source.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String line, Collector<String> out) throws Exception {
                String[] arr = line.split(" ");
                for (String word : arr) {
                    out.collect(word);
                }
            }
        });

        // word, 1
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordAndOne = words.map(new MapFunction<String, Tuple2<String, Integer>>() {
            @Override
            public Tuple2<String, Integer> map(String word) throws Exception {
                return Tuple2.of(word, 1);
            }
        });

        // 分组 求和
        KeyedStream<Tuple2<String, Integer>, Tuple> tuple2TupleKeyedStream = wordAndOne.keyBy(0);

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


        // sink 写
        System.setProperty("HADOOP_USER_NAME", "root");
        result.writeAsText(output + System.currentTimeMillis()).setParallelism(1);

        // 执行
        env.execute();

    }
}

使用 maven视图的 package 打包.

1.7.2.以UI的方式递交

1.7.2.1.启动 hadoop

/onekey/hd1_start.sh

1.7.2.2.启动 flink 集群

cd /export/server/flink
bin/start-cluster.sh

1.7.2.3.上传jar包

jar包位置
在这里插入图片描述

1.7.2.4.指定参数 开始执行

在这里插入图片描述
在这里插入图片描述

1.7.2.5.查看结果

在这里插入图片描述
在这里插入图片描述

1.7.3. 以命令的方式递交

参考官网：

https://ci.apache.org/projects/flink/flink-docs-release-1.14/zh/docs/dev/datastream/execution_mode/

  1. 上传作业jar包到linux服务器

在这里插入图片描述

./bin/flink run \
-Dexecution.runtime-mode=BATCH -m yarn-cluster -yjm 1024 -ytm 1024 \
-c cn.itcast.day01.b.BatchWordCount /root/original-flink-base-01-1.0-SNAPSHOT.jar  \
--output hdfs://node1:8020/wordcount/output_50
  1. 查看任务运行概述

在这里插入图片描述
在这里插入图片描述

chad__chang
关注
专栏目录
基于Java的Flink流批一体数据处理快速集成开发框架设计源码
03-29
这是一个基于Java的Flink流批一体数据处理快速集成开发框架设计，使用Java语言开发，包含203个文件。主要文件类型包括169个Java源文件、11个XML文件、7个gitignore文件、3个PNG图片文件、2个Markdown文档、2个...
Flink流处理Demo(含源码)
beishanyingluo的博客
07-14 3484
Flink流处理的Source 基于集合 基于文件 基于Socket 自定义数据源 使用Kafka作为数据源 使用MySql作为数据源 Flink流处理的Transformation keyby connect split和select Flink流处理的Sink sink到kafka sink到mysql Flink的Window操作 时间窗口 计数窗口 自定义窗口 Flink的水印机制 1. 输入数据集DataSource Flink 中你可以使用 StreamExecuti.
Flink从入门到真香（1-分别使用流模式和批模式运行第一个demo)
oMaFei的博客
11-05 722
基本概念部分，批处理和流处理的区别 批处理在大数据世界有着悠久的历史,比较典型的就是spark。批处理主要操作大容量静态数据集，并在计算过程完成后返回结果。 批处理模式中使用的数据集通常符合下列特征： (1) 有界：批处理数据集代表数据的有限集合 (2) 持久：数据通常始终存储在某种类型的持久存储位置中 (3) 大量：批处理操作通常是处理极为海量数据集的唯一方法 批处理非常适合需要访问全套记录才能...
Flink-执行模式（流/批）
最新发布
tiger_ziren的博客
09-13 213
不管流模式亦或者是批模式，采取统一的处理方式（大部分的API两者都适用）；如果适用批（BACH）模式,Flink 可以对有边界作业进行额外的优化。例如，可以使用不同的关联（join）/ 聚合（aggregation）策略、不同 shuffle 实现来提高任务调度和故障恢复的效率。批模式一般用于处理已知输入、不会连续运行的任务；流模式一般用于处理连续的无界数据；
flink 流批一体
热门推荐
张伟的专栏
03-12 1万+
目录 当我们谈论批流一体，我们在谈论什么？ 一、流计算与批计算 一）流计算与批计算 二）流计算与批计算的比较 三）为什么要搞流批一体 二、流批一体的场景 一）数据集成的流批一体 二）数仓架构的流批一体 三）数据湖的流批一体 四）存储的流批一体 1.Pulsar 2.Hologres 1）Hologres的架构图 2）Hologres的流批一体 三、Flink中的流批一体 一）流批一体的DataStream 1.目前的
Flink高手之路4-Flink流批一体
W_chuanqi的博客
04-20 1746
env.fromElements(可变参数)env.fromCollection(各种集合)env.generateSequence(开始,结束)env.fromSequence(开始,结束SourceFunction：非并行的随机数据源（并行度为1）RichSourceFunction：丰富的非并行的随机数据源（并行度为1）ParallelSourceFunction：并行的随机数据源（并行度可以大于等于1）
统一批处理流处理——Flink批流一体实现原理
weixin_30416497的博客
09-06 1512
实现批处理的技术许许多多，从各种关系型数据库的sql处理，到大数据领域的MapReduce，Hive，Spark等等。这些都是处理有限数据流的经典方式。而Flink专注的是无限流处理，那么他是怎么做到批处理的呢？ 无限流处理：输入数据没有尽头；数据处理从当前或者过去的某一个时间 点开始，持续不停地进行 另一种处理形式叫作有限流处理，即从某一个时间点开始处理数据，然后在另一个时间点结束...
基于Java的Clink Flink流批一体开发框架源码
03-25
本项目是基于Java语言开发的Clink Flink流批一体开发框架，旨在为数据处理提供快速集成的开发解决方案。框架包含203个文件，其中主要构成如下： - Java源文件：169个，构成了框架的核心功能； - 配置文件：11个XML...
基于Flink DataStream API的流批一体处理.pdf
03-21
在大数据处理领域，Apache Flink 是一个强大的开源流处理框架，以其高效、低延迟和状态管理能力而闻名。本文将详细解析基于Flink DataStream API的流批一体处理技术及其重要性。 首先，Flink DataStream API是Flink...
flink流批一体存储
05-26
Flink流批一体存储是 Apache Flink 的一个重要组件，旨在统一流式数据和批量数据的存储，提供了一个统一的存储层，支持流式数据和批量数据的处理和查询。 业务需求： 流批统一存储是当前大数据处理的重要需求之一...
基于 Apache Pulsar 和 Apache Flink 进行批流一体的弹性数据处理.pdf
12-08
这篇文档讨论了如何结合这两个工具实现批流一体的弹性数据处理，即在同一平台上同时处理批量数据和实时流数据。 **Apache Pulsar 知识点** 1. **云原生架构**：Pulsar 设计为云环境中的服务，提供无状态的服务层和...
Flink实操 : 算子操作
张伯毅的专栏
03-03 1414
.一 .前言二 .算子操作2.1. map2.2. flatMap2.3. mapPartition2.4. filter2.5. reduce/groupBy2.6. reduceGroup/groupBy2.7. aggregate2.8. join2.9. union2.10. rebalance2.11. hashPartition2.12. sortPartition2.13. keyBy2.14. Connect 一 .前言 Transformation 说明 map 将Data
3、Flink执行模式（流/批）详解（上）
猫猫爱吃小鱼粮
04-25 2036
Flink执行模式（流/批）详解（上）
Flink SQL实现流批一体
大数据研习社
04-22 7858
1 Flink流批统一思想 1.1 有界流和无界流 在Flink中，批处理时流处理的一个特例。 1.2 Flink老架构与问题 1.从Flink用户角度（企业开发人员） （1）开发的时候，Flink SQL支持的不好，就需要在两个底层API中进行选择，甚至维护两套代码。 （2）不同的语义、不同的connector支持、不同的错误恢复策略等。 （3）Table API也会受不同的底层API、不同的connector等问题的影响。 2.从Flink开发者角度（Flink社区人员）
流批一体技术简介
Ververica的博客
05-30 1184
本文由阿里云 Flink 团队苏轩楠老师撰写，旨在向 Flink 用户整体介绍 Flink 流批一体的技术和挑战。
基于flink&hudi批流一体技术
weixin_44687655的博客
04-21 1298
Hudi是Hadoop Updates and Incrementals的简写，它是由Uber开发并开源的Data Lakes解决方案。Hudi 用于管理的数据库层上构建具有增量数据管道的流式数据湖，同时针对湖引擎和常规批处理进行了优化。简言之，Hudi是一种针对分析型业务的、扫描优化的数据存储抽象，它能够使DFS数据集在分钟级的时延内支持变更，也支持下游系统对这个数据集的增量处理。
Flink 流处理
qq_38634896的博客
08-09 1202
大数据 Flink 流处理
Flink -- 批流一体
weixin_46362494的博客
12-06 1192
-spark和Flink都是粗粒度资源调度(在任务提交之前，将任务资源全部申请下来，这样会节约了任务开始执行时资源申请的时间，但是会浪费资源 -- 和mapreduce(细资源调度)比较)-- 在流出模式中使用常规的关联方式，flink会将两个表的数据一直保持在状态中，状态会越来越大 -- 可以设置状态过期时间，一段时间清理状态，比如值保留最近一天的状态。kv1:KeyValue(word=yujie, num=1) -- kv1中存储的是之前计算的结果，也就是状态(第一条数据除外)
Flink 快速上手（批处理+流处理）
mengxianglong123的博客
03-26 7300
一、环境准备 工欲善其事，必先利其器。在进行代码的编写之前，先将我们使用的开发环境和工具介绍一下： 系统环境为 Windows 10。 需提前安装 Java 8。 集成开发环境（IDE）使用 IntelliJ IDEA，具体的安装流程参见 IntelliJ 官网。 安装 IntelliJ IDEA 之后，还需要安装一些插件——Maven 和Git。Maven 用来管理项目依赖；通过 Git 可以轻松获取我们的示例代码，并进行本地代码的版本控制。 二、创建项目 在准备好所有的开发环境之后，我们就可以开始开
Flink DataStream API：流批一体处理探索
"基于Flink DataStream API的流批一体处理" 在大数据处理领域，Apache Flink是一个强大的开源流处理框架，其核心特性之一是能够处理流数据和批数据的统一。本文将深入探讨如何利用Flink的DataStream API实现流批...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chad__chang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值