手把手开发Flink程序-DataSet

最新推荐文章于 2023-03-14 09:16:54 发布
最新推荐文章于 2023-03-14 09:16:54 发布
阅读量1k 收藏
点赞数 2
分类专栏： 手把手 文章标签： flink 大数据 docker mysql DataSet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boroborome/article/details/104223136
版权

目的:

  1. 学习Flink的基本使用方法

  2. 掌握在一般使用中需要注意的事项

 

手把手的过程中会讲解各种问题的定位方法，相对啰嗦，内容类似结对编程。

大家遇到什么问题可以在评论中说一下，我来完善文档

 

Flink专辑的各篇文章链接：

手把手开发Flink程序-基础

手把手开发Flink程序-DataSet

手把手开发Flink程序-DataStream

 

这里不在讲解基本的环境搭建过程，基本环境搭建过程，大家参见： 手把手开发Flink程序-基础

现在我们将做一个新的Flink程序，目标是提供一批100以内随机数字，计算数字中的奇偶数个数、质数个数、各种数字出现的个数。

步骤：

初始化一个新的Job

创建类NumStat

统计的步骤是

  1. 生成若干随机数字

  2. 统计奇数和偶数的个数

  3. 统计质数格式

  4. 统计每个数字出现的次数

package org.myorg.quickstart;

import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.aggregation.Aggregations;
import org.apache.flink.api.java.operators.MapOperator;
import org.apache.flink.api.java.tuple.Tuple2;

public class NumStat {
    public static void main(String[] args) throws Exception {
        // 从参数中获取统计数字的个数
        int size = 1000;
        if (args != null && args.length >= 1) {
            size = Integer.parseInt(args[0]);
        }

        statisticsNums(size);
    }

    private static void statisticsNums(int size) throws Exception {
        final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

        // 生成需要统计的速记数字
        MapOperator<Long, Integer> numbers = env.generateSequence(0, size)
                .map(num -> (int) (Math.random() * 100));

        // 统计奇数偶数的比例
        numbers.map(num -> num % 2) // 所有数字对2取余数，0的数字是偶数，1的数字是奇数
                .map(mod -> new Tuple2<Integer, Integer>(mod, 1))   // 包装一下统计结果方便后面group
                .groupBy(0) // 根据Tuple中第一个元素分组
                .aggregate(Aggregations.SUM, 1) // Tuple中第二个数字求和
                .print();   // 统计结果直接打印到控制台。最后结果只有0或者1两个数字和对应个数

        // 统计质数个数
        long primeCount = numbers.filter(num -> isPrime(num))
                .count();
        System.out.println(primeCount);

        // 统计每个数字出现的频率
        numbers.map(num -> new Tuple2<Integer, Integer>(num, 1))
                .groupBy(0)
                .aggregate(Aggregations.SUM, 1)
                .print();
    }

    private static boolean isPrime(int src) {
        if (src < 2) {
            return false;
        }
        if (src == 2 || src == 3) {
            return true;
        }
        if ((src & 1) == 0) {// 先判断是否为偶数，若偶数就直接结束程序
            return false;
        }
        double sqrt = Math.sqrt(src);
        for (int i = 3; i <= sqrt; i += 2) {
            if (src % i == 0) {
                return false;
            }
        }
        return true;
    }
}

编译调试

编译通过，运行一下试试

Caused by: org.apache.flink.api.common.functions.InvalidTypesException: The generic type parameters of 'Tuple2' are missing. In many cases lambda methods don't provide enough information for automatic type extraction when Java generics are involved. An easy workaround is to use an (anonymous) class instead that implements the 'org.apache.flink.api.common.functions.MapFunction' interface. Otherwise the type has to be specified explicitly using type information.

居然有一个错误，原来flink在map为一个Tuple之后，Tuple中每个元素的类型信息丢失了，需要增加类型信息。在每个map(n -> new Tuple2<>())的后面需要增加类型声明

// 统计奇数偶数的比例
numbers.map(num -> num % 2)
        .map(mod -> new Tuple2<Integer, Integer>(mod, 1))
        .returns(TypeInformation.of(new TypeHint<Tuple2<Integer, Integer>>() {}))   // 新增加的类型信息声明
        .groupBy(0)
        .aggregate(Aggregations.SUM, 1)
        .print();

同理在”统计每个数字出现的频率“的地方也需要增加returns。

编译通过，执行一个试试

(79,18)
(88,10)
(93,11)
(95,9)

BUILD SUCCESSFUL in 8s
3 actionable tasks: 2 executed, 1 up-to-date
3:43:20 PM: Task execution finished 'NumStat.main()'.

看起来有结果了，但是没有看到单独数字的，单独数字是质数个数。Debug的时候可以看到代码走到了，根据debug时看到的结果，在控制台其实可以搜索到。

15:51:00,187 INFO  org.apache.flink.runtime.rpc.akka.AkkaRpcService              - Stopped Akka RPC service.
15:51:00,197 INFO  org.apache.flink.runtime.blob.PermanentBlobCache              - Shutting down BLOB cache
15:51:00,197 INFO  org.apache.flink.runtime.blob.TransientBlobCache              - Shutting down BLOB cache
15:51:00,203 INFO  org.apache.flink.runtime.blob.BlobServer                      - Stopped BLOB server at 0.0.0.0:50386
15:51:00,203 INFO  org.apache.flink.runtime.rpc.akka.AkkaRpcService              - Stopped Akka RPC service.
247
15:51:50,274 INFO  org.apache.flink.api.java.ExecutionEnvironment                - The job has 0 registered types and 0 default Kryo serializers
15:51:50,274 INFO  org.apache.flink.runtime.minicluster.MiniCluster              - Starting Flink Mini Cluster
15:51:50,274 INFO  org.apache.flink.runtime.minicluster.MiniCluster              - Starting Metrics Registry

这种方式确实不太好，也不正规，下面我们把结果输出到Mysql.

将结果输出到Mysql

设计表结构

字段名称类型含义
id自增唯一标识一条记录
group时间戳计算的批次，同一批次的数据使用相同的时间戳
type字符串mod:表示奇数偶数的计算结果；count:表示质数个数统计结果； rate: 表示数字出现个数统计结果
key数字mod的时候只有0，1两种情况；count固定位0；rate就是需要统计的数字
value数字统计的结果

用docker启动mysql

项目中创建如下目录结构

├── mysql
│   ├── go.sh                       // 启动docker的脚本
│   └── init
│       └── create-database.sql     // 初始化数据的脚本

各文件内容分别是

create-database.sql

create TABLE result (
  id bigint(20) NOT NULL AUTO_INCREMENT,
  result_group datetime DEFAULT NULL,
  result_type varchar(100) DEFAULT NULL,
  result_key BIGINT DEFAULT NULL,
  result_value BIGINT DEFAULT NULL,
  PRIMARY KEY (id)
)

go.sh

#!/usr/bin/env bash

docker run -d \
  -p 3326:3306 \
  -e MYSQL_DATABASE=db \
  -e MYSQL_ROOT_PASSWORD=123456\
  -e character-set-server=utf8mb4\
  -e collation-server=utf8mb4_unicode_ci\
  -v `pwd`/init:/docker-entrypoint-initdb.d/:ro\
  --name boroborome_flink_mysql \
  mysql:5.7

在控制台执行如下命令启动mysql

➜  quickstart git:(master) ✗ cd mysql
➜  mysql git:(master) ✗ ./go.sh
5af6fe6e836c94542263aac79191ac41238be9b98ab44bb4e57bce270b187a89
➜  mysql git:(master) ✗

此时可以使用IDE自带的数据库连接工具，连接一下试试。

注意链接信息如下端口号是3326

不需要用的时候可以使用如下命令停止mysql

docker rm -f boroborome_flink_mysql

修改逻辑，将结果写入mysql

1、首先引入Mysql包

     修改build.gradle，增加

runtimeOnly 'mysql:mysql-connector-java:8.0.19'

2、 创建一个用于保存结果的模型

  类名称是NumStatResult，使用lombok自动生成属性和构造方法。 builde.gradle中增加配置

compileOnly 'org.projectlombok:lombok:1.18.10'
annotationProcessor 'org.projectlombok:lombok:1.18.10'

增加类

package org.myorg.quickstart.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.io.Serializable;
import java.util.Date;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class NumStatResult implements Serializable {
    private long id;
    private Date group;
    private String type;
    private int key;
    private long value;

    @Override
    public String toString() {
       return String.join(",", String.valueOf(group), type, String.valueOf(key), String.valueOf(value));
    }
}

3、 创建将结果保存到Mysql的sink

这里我们简化一点，数据库的链接信息直接hardcode在代码中，正常情况我们应该使用MultipleParameterTool从参数中获取，估计这块大家不会成问题。

还有一个注意事项，数据库的IP地址需要使用机器的IP地址，不能使用localhost或者127.0.0.1。为什么呢？因为flink虽然运行在我们自己的机器上，但是更准确的说是运行在docker里面，127.0.0.1或者localhost表示daocker自己，所以自行修改IP地址。

package org.myorg.quickstart.component;

import org.apache.flink.api.common.io.OutputFormat;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.SinkFunction;
import org.myorg.quickstart.model.NumStatResult;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Timestamp;

public class MysqlSink implements OutputFormat<NumStatResult>, SinkFunction<NumStatResult> {
    private Connection conn;
    private PreparedStatement ps;

    @Override
    public void configure(Configuration parameters) {

    }

    @Override
    public void open(int taskNumber, int numTasks) throws IOException {
        String driverName = "com.mysql.cj.jdbc.Driver";
        try {
            Class.forName(driverName);
            conn = DriverManager.getConnection(
                    "jdbc:mysql://192.168.3.4:3326/db?useSSL=false&allowPublicKeyRetrieval=true",
                    "root", "123456");

            // close auto commit
            conn.setAutoCommit(false);
        } catch (Exception e) {
            throw new IOException(e.getMessage(), e);
        }
    }

    @Override
    public void writeRecord(NumStatResult value) throws IOException {
        try {
            ps = conn.prepareStatement("insert into result(result_group, result_type, result_key, result_value) values(?,?,?,?)");
            ps.setTimestamp(1, new Timestamp(value.getGroup().getTime()));
            ps.setString(2, value.getType());
            ps.setInt(3, value.getKey());
            ps.setLong(4, value.getValue());

            ps.execute();
            conn.commit();
        } catch (SQLException e) {
            throw new IOException(e.getMessage(), e);
        }
    }

    @Override
    public void close() throws IOException {
        if (conn != null) {
            try {
                conn.commit();
                conn.close();
            } catch (SQLException e) {
                throw new IOException(e.getMessage(), e);
            }

        }
    }
}

4、修改统计代码，将结果保存到mysql

     代码中带有注释的部分为变化的部分

    private static void statisticsNums(int size) throws Exception {
        final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
        
        // 这里增加了生成group和mysqlsink的代码
        Date group = new Date();
        MysqlSink mysqlSink = new MysqlSink();

        MapOperator<Long, Integer> numbers = ...

        numbers.map(num -> num % 2)
                ...
                .aggregate(Aggregations.SUM, 1)
                .map(result -> NumStatResult.builder()	// 这里增加将结果格式化然后输出到mysqlSink的逻辑
                        .group(group)
                        .type("mod")
                        .key(result.f0)
                        .value(result.f1)
                        .build())
                .output(mysqlSink);

        long primeCount = numbers.filter(num -> isPrime(num))
                .count();
        // 这里增加将结果格式化然后输出到mysqlSink的逻辑
        env.fromElements(primeCount)
                .map(result -> NumStatResult.builder()
                        .group(group)
                        .type("count")
                        .key(0)
                        .value(result)
                        .build())
                .output(mysqlSink);

        numbers.map(num -> new Tuple2<Integer, Integer>(num, 1))
                ...
                .aggregate(Aggregations.SUM, 1)
                .map(result -> NumStatResult.builder()	// 这里增加将结果格式化然后输出到mysqlSink的逻辑
                        .group(group)
                        .type("rate")
                        .key(result.f0)
                        .value(result.f1)
                        .build())
                .output(mysqlSink);
    }

本地测试

在启动了mysql的情况下，在IDE中直接执行一下看效果。

运行没有报错，看数据库数据

select * from result
idresult_groupresult_typeresult_keyresult_value
12020-02-08 02:30:19mod0486
22020-02-08 02:30:19mod1515

结果中只有奇偶数的结果，其他结果都没有。怎么回事呢？查阅官网 https://ci.apache.org/projects/flink/flink-docs-release-1.9/dev/api_concepts.html#anatomy-of-a-flink-program

有这样一段

Anatomy of a Flink Program
Flink programs look like regular programs that transform collections of data. Each program consists of the same basic parts:

1、Obtain an execution environment,
2、Load/create the initial data,
3、Specify transformations on this data,
4、Specify where to put the results of your computations,
5、Trigger the program execution

原来flink在执行的时候，并没有直接执行我们写的代码，而是创建了一个执行计划，等到execute的时候才会真的去执行，而且执行的方法会根据不同的环境采取不同的执行方式。所以我们本地能执行，服务器上不一定正确。

原来我们的WordCount程序中，其实也没有执行execute，但是因为是本地环境，Local的Environment执行逻辑还是执行了，所以看到了结果，其实程序不对。

刚才我们的统计程序中，我们做了1、2、3、4，但是没有做5。

我们只需要在方法的最末尾增加如下代码

env.execute();

删除数据库中所有记录，重新执行一下看看。此时数据库中这三类数据都有了。

idresult_groupresult_typeresult_keyresult_value
5142020-02-08 03:22:45mod0521
5152020-02-08 03:22:45mod1480
5162020-02-08 03:22:45count0256
5172020-02-08 03:22:45rate178
5182020-02-08 03:22:45rate415
5192020-02-08 03:22:45rate1310

统计结果看起来也是正常的

select result_type, count(1) from result
        group by result_type
result_typecount(1)
count1
mod2
rate100

部署到flink

修改build.gradle文件

mainClassName = 'org.myorg.quickstart.NumStat'

执行如下命令制作发布的jar包

./gradlew clean shadowJar

 

参照手把手开发Flink程序-基础中方法将之后的jar包quickstart-0.1-SNAPSHOT-all.jar发布到flink，执行看结果

失败了，我们来看一下失败原因。

从这里可以看到，出错的原因是数据库驱动没有加载。我们把上传的jar包解压缩看看里面是什么？

➜  quickstart-0.1-SNAPSHOT-all tree
.
├── META-INF
│   └── MANIFEST.MF
├── log4j.properties
└── org
    └── myorg
        └── quickstart
            ├── BatchJob.class
            ├── NumStat$1.class
            ├── NumStat$2.class
            ├── NumStat.class
            ├── StreamingJob.class
            ├── WordCount$Tokenizer.class
            ├── WordCount.class
            ├── component
            │   ├── MysqlSink.class
            │   └── NumberSource.class
            └── model
                ├── NumStatResult$NumStatResultBuilder.class
                └── NumStatResult.class

6 directories, 13 files
➜  quickstart-0.1-SNAPSHOT-all

从这里可以看到，包里面只有我们的代码，需要的驱动并不在里面，这个不是一个fatjar。

为了做一个Fat Jar我们做如下修改，修改build.gralde文件

// 将runtimeOnly修改为compile
compile 'mysql:mysql-connector-java:8.0.19'

// 增加fatJar Task
task fatJar(type: Jar) {
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
    with jar
    manifest {
        attributes 'Main-Class': mainClassName
    }
}

参考：https://intfrog.github.io/website/Dev/Gradle%E6%9E%84%E5%BB%BAFatJar.html。

通过如下命令构建Fat Jar

./gradlew clean fatJar

注意此时的jar文件名称变量，从quickstart-0.1-SNAPSHOT-all.jar变成了quickstart-0.1-SNAPSHOT.jar。大小从16K到52.9M。

下面我们重新上传看效果。这次不过，马上完成了，我们来看一下数据库

select result_type, count(1) from result group by result_type
select * from result
result_typecount(1)
mod2
idresult_groupresult_typeresult_keyresult_value
5142020-02-08 03:22:45mod0521
5152020-02-08 03:22:45mod1480

居然只有奇偶数的结果。怎么回事呢？从代码和运行的plan上看不出来原因在哪里，我们看到的效果都是下图的样子。

flink提供命名方法来让Plan更易读，每一个Operator都用于命名的name方法。比如map，filter，aggregate，output的放回结果都可以给添加一个名字。添加后重新上传jar包，不需要执行了，我们可以直接看plan。

从这个有名字的Plan上可以更好的和我们的代码对应，从这个Plan上看我们现在有这么几个问题

  • 创建的随机数字列表，只分配给了两个任务Mod计算和Count计算，没有计算Rate。

  • Prime Count计算的逻辑有，而且有保存过程，但是结果中没有对应的数据。

我理解，flink的程序的执行过程分为本地执行和集群执行两种情况

  • 在本地执行的时候有一部分是在jvm上执行，原封不动的执行我们写的逻辑

  • 在集群上执行时，flink重新解读了我们的代码，之后按照他理解的Plan执行了

所以本地和集群执行的效果会有出入，我们写的程序应该做到让flink认识才行。

我没有搞清楚DataSet.count()方法到底应该在什么时候使用，在官网的DataSet页面上没有看到count方法的介绍，大家谨慎使用count方法。

基本原则应该是

  • 所有操作都在流上进行

重新修改后代码如下：

private static void statisticsNums(int size) throws Exception {
    // set up the execution environment
    final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
    Date group = new Date();
    MysqlSink mysqlSink = new MysqlSink();

    MapOperator<Long, Integer> numbers = env.generateSequence(0, size)
            .name("Generate index")
            .map(num -> (int) (Math.random() * 100))
            .name("Generate Numbers");

    // 统计奇数偶数的比例
    numbers.map(num -> num % 2)
            .name("Calculate Mod value")
            .map(mod -> new Tuple2<Integer, Integer>(mod, 1))
            .name("Create mod result item")
            .returns(TypeInformation.of(new TypeHint<Tuple2<Integer, Integer>>() {}))
            .groupBy(0)
            .aggregate(Aggregations.SUM, 1)
            .name("Sum Mod result")
            .map(result -> NumStatResult.builder()
                    .group(group)
                    .type("mod")
                    .key(result.f0)
                    .value(result.f1)
                    .build())
            .name("Convert to db result")
            .output(mysqlSink)
            .name("Save data to mysql");

    // 统计每个数字出现的频率
    numbers.map(num -> new Tuple2<Integer, Integer>(num, 1))
            .name("Create rate item")
            .returns(TypeInformation.of(new TypeHint<Tuple2<Integer, Integer>>() {}))
            .groupBy(0)
            .aggregate(Aggregations.SUM, 1)
            .name("Sum rate result")
            .map(result -> NumStatResult.builder()
                    .group(group)
                    .type("rate")
                    .key(result.f0)
                    .value(result.f1)
                    .build())
            .name("Convert to db model")
            .output(mysqlSink)
            .name("Save to mysql");

    // 统计质数个数
    numbers.filter(num -> isPrime(num))
            .map(num -> new Tuple2<Integer, Integer>(0, 1))
            .name("Wrap to count item")
            .returns(TypeInformation.of(new TypeHint<Tuple2<Integer, Integer>>() {}))
            .groupBy(0)
            .aggregate(Aggregations.SUM, 1)
            .name("Sum Prime count result")
            .map(result -> NumStatResult.builder()
                    .group(group)
                    .type("count")
                    .key(0)
                    .value(result.f1)
                    .build())
            .name("Convert to db item")
            .output(mysqlSink)
            .name("Save data to mysql");

    env.execute();
}

原来Prime Count计算逻辑有比较大的调整。 重新部署查看Plan效果如图

执行结果如图

select result_type, count(1) from result
        group by result_type
result_typecount(1)
count1
mod2
rate100

不仅仅集群环境执行结果如此，本地执行情况也是这样的。到此大功告成。

大家遇到什么问题可以在评论中说一下，我来完善文档

大家既然看到了这里，那就顺手给个赞吧👍

 

本期的最终代码参见文件num-stat.zip

链接:https://pan.baidu.com/s/19PQzxWQsQsf8E7v-a-sRUA 密码:9uuq

后面将会继续讲解如何使用DataStream的API处理这段复杂逻辑。

BoRoBoRoMe
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Apache Flink（flink-1.15.0-bin-scala_2.12.tgz）
05-07
Apache Flink（flink-1.15.0-bin-scala_2.12.tgz）是由Apache软件基金会开发的开源流处理框架，其核心是用Java和Scala编写的分布式流数据流引擎。Flink以数据并行和流水线方式执行任意流数据程序，Flink的流水线运行...
示例代码：使用golang进行flink开发
学亮编程手记
03-14 2958
以上示例代码使用 Flink 的 REST API 连接到 Flink 作业集群，并定义了一个输入数据流和一个输出数据流。然后，使用 Map 操作对输入数据进行处理，并将处理后的数据写入输出数据流。最后，执行作业并等待作业结束。请注意，以上示例代码仅供参考，具体实现可能会因为您的实际需求而有所不同。
Golang：分布式高并发场景, 服务限流实现方案
qq_23024699的博客
02-28 2407
服务限流场景 在高并发大流量系统中，由于并发大造成服务资源不足，负载过高，进而引发致一系列问题，这里的流量一般都是突发性的，由于系统准备不足，很难短期扩容来应对 ，进行限流是最常用的手段，所以说限流也是服务稳定性治理重要的手段。 限流可能发生在多个层面： 1.用户网络层：突发的流量场景如热点事件流量（秒杀事件、热门抢购，微博热搜），恶意刷流，竞对爬虫等。 2.内部应用层：上游服务的异常调用，脚本异常请求，失败重试策略造成流量突发。 实现限流方案 常用的限流方法主要有三种：计数器算法，漏斗桶算
golang能做大数据开发吗？主流的开发框架有哪些？
学亮编程手记
03-14 1647
一种快速的大规模数据处理框架，支持批处理和流式数据处理，可以使用 Golang 编写 Spark 应用程序。Golang 在大数据领域的应用越来越广泛，可以处理大规模的数据集，同时具有高并发，低延迟和高可用性等优点。：一种分布式的流式数据处理框架，具有低延迟和高吞吐量的特点，支持包括 Golang 在内的多种编程语言。：一种开源的容器编排系统，可以管理和调度大规模的容器化应用程序，同时也支持 Golang 开发。：一种流式数据处理框架，可以处理批处理数据和流式数据，支持多种计算引擎和数据存储系统。
实时计算：Apache Flink在滴滴的应用与实践
勇往直前的专栏
04-26 861
导读：Apache Flink 是一个分布式大数据处理引擎，可对有限数据流和无限数据流进行有状态计算。可部署在各种集群环境，对各种大小的数据规模进行快速计算。 滴滴基于 Apache Flink 做了大量的优化，也增加了更多的功能，比如扩展 DDL、内置消息格式解析、扩展 UDX 等，使得 Flink 能够在滴滴的业务场景中发挥更大的作用。本文中，滴滴出行实时计算负责人、高级技术专家梁李印分享了...
7.Flink实时项目之独立访客开发
www_xuhss_com的博客
03-06 2715
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 1.架构说明 在上6节当中，我们已经完成了从ods层到dwd层的转换，包括日志数据和业务数据，下面我们开始做dwm层的任务。 DWM 层主要服务 DWS，因为部分需求直接从 DWD 层到DWS 层中间会有一定的计算量，而且这部分计算的结果很有可能被多个 DWS 层主题复用，所以
flink-shaded-hadoop-3下载
05-19
flink-shaded-hadoop-3下载
Apache Flink（flink-1.14.4-bin-scala_2.12.tgz）
05-07
Apache Flink（flink-1.14.4-bin-scala_2.12.tgz）是由Apache软件基金会开发的开源流处理框架，其核心是用Java和Scala编写的分布式流数据流引擎。Flink以数据并行和流水线方式执行任意流数据程序，Flink的流水线运行...
flink-1.14.0-bin-scala_2.11.tgz
07-18
flink-1.14.0-bin-scala_2.11.tgz
flink-table-planner-blink-2.11-1.12.7-API文档-中文版.zip
07-07
赠送jar包：flink-table-planner-blink_2.11-1.12.7.jar； 赠送原API文档：flink-table-planner-blink_2.11-1.12.7-javadoc.jar； 赠送源代码：flink-table-planner-blink_2.11-1.12.7-sources.jar； 赠送Maven依赖...
Flink面试通关手册
微信搜：import_bigdata，大数据领域硬核原创作者
12-04 696
大数据技术与架构点击右侧关注，大数据开发领域最强公众号！暴走大数据点击右侧关注，暴走大数据！概述2019 年是大数据实时计算领域最不平凡的一年，2019 年 1 月阿里巴巴 Blink ...
flink 本地_flink本地模式简单入门-Go语言中文社区
weixin_39963523的博客
12-22 1456
一 本地模式flink 可以运行在 linux，mac os 和 windows上，flink需要工作在 java8以上得版本。window的用户，请参照 flink on windows的文档操作下面是 我 虚拟机 的环境 及 JAVA 环境变量[root@localhost bin]# cat /etc/redhat-releaseCentOS Linux release 7.5.1804 ...
Recommendation Golang & Flink On Kubernetes is preferred IceBerg Apache Hudi Deltalake Kylin技术总结待续
weixin_40426261的博客
08-02 210
Recommendation Golang & Flink On Kubernetes is preferred IceBerg Apache Hudi Deltalake Kylin技术总结待续
转载 Flink goGroup
qq_31866793的博客
08-15 653
简介 Join和coGroup都是flinkSQL中用于连接多个流的算子，但是有一定的区别，推荐能使用coGroup不要使用Join，因为coGroup更强大。下面让我们简单看一下两个算子的用法 Window Join DataStream，DataStream→DataStream 在给定密钥和公共窗口上连接两个数据流。 dataStream.join(otherStream) ...
Flink源码解析（四）Flink应用程序的提交
Yuan_CSDF的博客
08-11 1293
这里包含Graph的处理，最终生成物理执行图，以及Slot到发布Task到TaskExecutor上运行。如下所示： Flink编程套路总结 Flink提交执行脚本分析 Flink CliFronted提交应用程序源码剖析 ExecutionEnvironment源码解析 Job提交流程源码分析 StreamGraph构建和提交源码解析 JobGragh构建和提交源码解析 ExecutionGragh构建和提交源码解析 Slot管理（申请）源码解析 Task提交到Task...
FlinK运行一段时间后任务任务自己挂掉的问题排查
热门推荐
梦想成真那天
07-10 1万+
最近在做自定义实时报表,由于在前期测试Flink发现Flink拥有比较好的性能,并且天然支持窗口,所以在实时计算的时候,我们选择Flink在做计算框架.在所有的代码完成,代码准备上线的时候,发现Flink程序运行一段时间后,要么自己直接挂掉要么过一段时间,程序从checkpoint恢复.在排查日志的过程中,程序中并没有什么异常报出,最终排查每个taskManager的日志发现在其中一个TaskMa...
Flink 的组件栈有哪些
weixin_59295776的博客
12-18 781
根据 Flink 官网描述，Flink 是一个分层架构的系统，每一层所包含的组件都提供了特定的抽象，用来服务于上层组件。 自下而上，每一层分别代表：Deploy 层：该层主要涉及了Flink的部署模式，在上图中我们可以看出，Flink 支持包括local、Standalone、Cluster、Cloud等多种部署模式。Runtime 层：Runtime层提供了支持 Flink 计算的核心实现，比如：支持分布式 Stream 处理、JobGraph到ExecutionGraph的映射、调度等等，为上层.
技术选型：为什么批处理我们却选择了Flink
github_36774378的博客
10-28 327
最近接手了一个改造多平台日志服务的需求，经过梳理，我认为之前服务在设计上存在缺陷。经过一段时间的技术方案调研，最终我们决定选择使用 Flink 重构该服务。 目前重构后的服务已成功经受了国庆节流量洪峰的考验，今日特来总结回顾，和大家分享一下经验。 业务需求及背景 在了解改造服务的需求前，我们首先要明确，要解决什么问题以及目前的服务是如何解决的。 当前的业务逻辑还是比较清晰的： 采集同一时段不同数据源的日志； 对采集的数据进行处理； 将处理后的数据上传到指定位置，供客户下载。 我们面临的痛点和
Apache Flink在滴滴的应用与实践
过往记忆大数据
04-24 1220
分享嘉宾：梁李印 滴滴出行高级技术专家编辑整理：张策内容来源：Flink Forward ASIA出品平台：DataFunTalk导读：Apache Flink 是一个分布式大数据处理...
flink upsert-kafka 注意事项
最新发布
11-08
2. 在使用Upsert-Kafka时，需要在Flink的pom.xml文件中添加flink-connector-kafka依赖。 3. 在使用Upsert-Kafka时，需要在Flink的代码中指定Kafka的ProducerConfig，例如设置bootstrap.servers、acks、retries等参数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值