Flink流式框架过程问题

已于 2024-08-26 17:14:50 修改
阅读量735 收藏 7
点赞数 18
分类专栏： Flink 流式处理 文章标签： flink 大数据
于 2024-08-05 14:35:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694906/article/details/140925724
版权

注：博主使用的版本就是：<flink.version>1.16.1</flink.version>

前提环境：

因公司业务需要，使用Flink对数据进行流式处理，具体处理流程就是，从kafka接到数据，然后连续请求十多个接口（算法）对数据进行打标；

主程序：
在这里插入图片描述
具体的异步IO代码(随便找一个展示)：

package com.wenge.datagroup.storage.process;

import com.alibaba.fastjson.JSONObject;
import com.wenge.datagroup.storage.bean.ParamConfig;
import com.wenge.datagroup.storage.common.ArgsConstants;
import com.wenge.datagroup.storage.process.base.BaseETL;
import com.wenge.datagroup.storage.service.YaYiService.YaYiPolarityService;
import com.wenge.datagroup.storage.utils.ConfigUtil;
import com.wenge.datagroup.storage.utils.Funnel;
import com.wenge.datagroup.storage.utils.YaYiUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.AsyncDataStream;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.functions.async.ResultFuture;
import org.apache.flink.streaming.api.functions.async.RichAsyncFunction;

import java.util.Collections;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

@Slf4j
public class AnalyerAsyncIOProcessPolarity {

    public static DataStream<JSONObject> process(DataStream<JSONObject> dataStream) {

        log.error("----------------------------开始异步IO处理----------------");
        String topic = Funnel.contains(ArgsConstants.TOPIC) ? Funnel.getString(ArgsConstants.TOPIC) : "";
        String configFile = Funnel.contains(ArgsConstants.CONFIG) ? Funnel.getString(ArgsConstants.CONFIG) : "config.properties";
        int asyncNum = Funnel.contains(ArgsConstants.ASYNC_NUM) ? Funnel.getInt(ArgsConstants.ASYNC_NUM) : ConfigUtil.getInteger(ArgsConstants.ASYNC_NUM);
        int mapParallelism = Funnel.contains(ArgsConstants.MAP_PARALLELISM) ? Funnel.getInt(ArgsConstants.MAP_PARALLELISM) : ConfigUtil.getInteger(ArgsConstants.MAP_PARALLELISM);
        int filterParallelism = Funnel.contains(ArgsConstants.FILTER_PARALLELISM) ? Funnel.getInt(ArgsConstants.FILTER_PARALLELISM) : ConfigUtil.getInteger(ArgsConstants.FILTER_PARALLELISM);
        int TranslateParallelism = (Funnel.contains(ArgsConstants.Translate_MAP_PARALLELISM) ? Funnel.getInt(ArgsConstants.Translate_MAP_PARALLELISM) : ConfigUtil.getInteger(ArgsConstants.Translate_MAP_PARALLELISM));

        // 异步IO
        RichAsyncFunction richAsyncFunction = new RichAsyncFunction<JSONObject, JSONObject>() {
            private transient ExecutorService executorService;
            private ParamConfig paramConfig;
            private YaYiUtil yaYiUtil;

            @Override
            public void open(Configuration parameters) {
                // 重新加载配置文件
                log.error("重新加载配置文件");
                ConfigUtil.setConfigFile(configFile);
                ConfigUtil.setTopic(topic);
                ConfigUtil.init();
                this.executorService = Executors.newFixedThreadPool(asyncNum);
                paramConfig = new ParamConfig(ConfigUtil.getString("YaYiappKey"), ConfigUtil.getString("YaYiappSecret"));
                yaYiUtil = new YaYiUtil(paramConfig);
            }

            @Override
            public void close() throws Exception {
                // 关闭线程池
                if (executorService != null) {
                    executorService.shutdown();
                }
                log.error("----------------------------情感分析-线程池关闭----------------------");
            }

            @Override
            public void timeout(JSONObject input, ResultFuture<JSONObject> resultFuture) {
                JSONObject data = input;
                String uuid = data.getString("uuid");
                log.error("-----------------------数据超时----------------------:{}", uuid);
                //对超时数据进行处理
                resultFuture.complete(Collections.singleton(data));
            }

            @Override
            public void asyncInvoke(JSONObject json, ResultFuture<JSONObject> resultFuture) {

                CompletableFuture.supplyAsync(new Supplier<JSONObject>() {

                    @Override
                    public JSONObject get() {
                        String uuid = json.getString("uuid");
                        long start =System.currentTimeMillis();
                        try {
                            //TODO: 根据业务逻辑进行处理
                            String title = json.getString("title");
                            String content = json.getString("content");
                            String translate_title = json.getString("translate_title");
                            String translate_content = json.getString("translate_content");
                            String languageRecognition = json.getJSONObject("analysis").getString("language");
                            String dataSourceType = json.getJSONObject("platform").getString("data_source_type");

                            
                            if (StringUtils.isNotBlank(translate_content)) {
                                String polarity = new String();
                                Integer polaritySum = 0;
								//具体算法调用
                                YaYiPolarityService yaYiPolarityService = new YaYiPolarityService();
                                polarity = yaYiPolarityService.yaYiPolarity(translate_content);
                                if (StringUtils.isNotBlank(polarity)) {
                                    polaritySum = StringUtils.equals(polarity, "A") ? 0 : StringUtils.equals(polarity, "B") ? 1 : 2;
                                    JSONObject analysis = json.getJSONObject("analysis");
                                    if (Objects.nonNull(analysis)) {
                                        analysis.put("polarity", polaritySum);
                                        json.put("analysis", analysis);
                                    } else {
                                        JSONObject analysisJson = new JSONObject();
                                        analysisJson.put("polarity", polaritySum);
                                        json.put("analysis", analysisJson);
                                    }
                                }
                                log.error("uuid:{},分析后数据:{}", uuid, polarity);
                                long end =System.currentTimeMillis();
                                log.error("uuid:{},分析,耗时：{} ms", uuid,(end-start));
                            }
                            return json;
                        } catch (Exception e) {
                            log.error("--------分析异常:{},数据:{}",uuid, e);
                            return json;
                        }
                    }
                }, executorService).thenAccept((JSONObject dbResult) -> {
                    resultFuture.complete(Collections.singleton(dbResult));
                });
            }
        };
        DataStream<JSONObject> downloadStream = AsyncDataStream.unorderedWait(
                dataStream,
                richAsyncFunction,
                50000,
                TimeUnit.MILLISECONDS,
                asyncNum).name("qinggan").setParallelism(TranslateParallelism);

        return downloadStream;
    }


}

问题

1：异步io访问接口直接引发关闭

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

解决方案：

方法中传递参数不要使用 Set

具体的原因我没深究，只是经过验证在异步IO中使用如下就会导致线程关闭：
在这里插入图片描述
改成如下就行：
在这里插入图片描述

2：数据格式问题直接引发关闭

在这里插入图片描述
解决方案：
在这里插入图片描述
在这里插入图片描述

整体来说，flink中如果数据格式传输导致错误，就会引发线程关闭，
所以 DataStream 改为DataStream 一定要通过map和filter 筛选

3：flink 消费kafka不提交offset

虽然在new FlinkKafkaConsumer<> 中设置了自动提交间隔，如下：

 properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");//自动提交的时间间隔
 properties.setProperty(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "20000");//自动提交的时间间隔

但是在实际应用过程中发现，到了设置的20000ms既20s，依然不提交offset，以为flink读取kafka失败。
实际上是因为我们再代码中开启了Checkpoint，就会覆盖kafka的配置，所以是经过规定的Checkpoint时间后才会提交offset
在这里插入图片描述

4：flink本地运行，发现默认并行度为6

当我们在本地中可以通过一下开启本地webui模式

// 使用本地模式并开启WebUI
Configuration configuration = new Configuration();
configuration.setInteger("rest.port", 8083);
streamEnv = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(configuration);

当时我们本地打开web UI发现，默认的并行度是6
在这里插入图片描述
这样有时候影响我们异步调用外部接口的qps设置，

解决方案：
在开发环境中，没有配置文件，默认并行度就是当前机器的 CPU 核心数（巨坑！）
所以我们需要自己手动指定每个算子的并行度，不要使用默认的，可以通过.setParallelism(2)来指定某一个算子的并行度

5：java代码的jar包，本地运行可以，flink框架上运行异常

问题：
我写的flink处理程序，在我本地和我打包放在flink框架都可以正常运行，
但是我的朋友打包成功后，放在flink框架上运行就异常。

解决：
经过各种尝试后，我的同事将自己maven的版本由3.5.3升级到了3.6.1只有就正常了
具体原因未知。

苍煜
关注
专栏目录
【大数据】Flink + Kafka 实现通用流式数据处理详解
congge
10-27 7601
Flink + Kafka 实现通用流式数据处理详解
流式处理框架之flink
CherryXieのblog
05-10 877
Apache Flink 是一个开源的流式处理框架，旨在处理和分析大规模、高吞吐量的实时数据流。与传统的批处理框架不同，Flink 支持事件驱动的流式处理，能够以低延迟和高吞吐量处理数据，并提供准确的结果。
Flink分布式流式处理框架
weixin_50648720的博客
01-22 1565
FlinkFlink概述数据流与流计算Flink简介应用场景Flink架构安装配置示例演示单词统计示例创建Flink工程 Flink概述 数据流与流计算 数据流是一串连续不断的数据的集合，就象水管里的水流，在水管的一端一点一点地供水，而在水管的另一端看到的是一股连续不断的水流。类似于人们对河流的理解本质上也就是流的概念，但是这条河没有开始也没有结束，数据流非常适合于离散的、没有开头或结尾的数据。例如，交通信号灯的数据是连续的，没有“开始”或“结束”，是连续的过程而不是分批发送的数据记录。通常情况下，数据流对
【Flink流式计算框架】Flink简介_Flink架构图
一梦
07-25 1360
001FlinkFlink简介处理无界和有界数据部署应用到任意地方运行任意规模应用利用内存性能Flink架构图 Flink简介 SparkStreaming需要整合hbase/redis才灵活管理状态，会复杂 Flink是有状态的流 数据的输入 数据的处理 数据的输出 横线代表数据库，竖线代表消息系统（MQ） Apache Flink® — Stateful Computations over Data Streams Apache Flink 是一个框架和分布式处理引擎，用于在无边界和有边界数据流上进
从浅入深理解流式计算框架Flink
Garvin的专栏
11-10 2203
随着互联网的不断发展，行业内对于数据的处理能力和计算的实时性要求都在不断增加，随之而来的是计算框架的升级。经过了十余年开源社区的不断演进，现在计算框架已经从第一代的雅虎开源的Hadoop体系进化到目前主流的Spark框架，这两套框架的计算主要是从强依赖硬盘存储能力的计算发展到了内存计算，大大增强了计算力。下一代计算引擎，也就是第三代计算引擎，将会从计算实时性的角度突破，也就是今天要讲到的Flink...
大数据流式处理框架Flink介绍
weixin_47019045的博客
06-30 2125
随着数据的飞速发展，出现了很多热门的开源社区，比如：hadoop、spark、storm社区，他们都有各自专注的适用场景，比如hadoop主要是做数据的存储及批处理计算，spark既可以做批处理也可以做准实时计算，同时也支持机器学习和图计算，storm主要专注于实时计算。 在国外一些开源社区将flink分为四代：hadoop： 使用DAG（Tez）+MR Spark问题？为什么在企业中很多公司依然使用Mr进行离线计算？主要是Mr的稳定性要远远的大于Spark，因为Mr是基于io的计算，基于io
Flink流式计算从入门到实战 一
roykingw的专栏
10-08 2265
文章目录一、理解Flink与流计算1、初识Flink2、Flink的适用场景3、流式计算梳理二、Flink安装部署1、Flink的部署方式2、获取Flink3、实验环境与前置软件4、集群搭建5、Standalone模式启动6、Yarn模式提交任务6.1、首先在yarn上启动yarn-session。6.2、提交测试任务6.3 Application Mode 应用模式6.4 Per-job Cluster Mode 单任务模式6.5 Session Mode 会话模式 Flink流式计算实战专题一 ==楼
python 流式计算框架_Flink流式计算系统
weixin_39933356的博客
12-11 918
本文将以这些概念为基础，逐一介绍 Flink 的发展背景、核心概念、时间推理与正确性工具、安装部署、客户端操作、编程API等内容，让开发人员对 Flink 有较为全面的认识并拥有一些基础操作与编程能力。一、发展背景1.1 数据处理架构在流处理器出现之前，数据处理架构主要由批处理器组成，其是对无限数据的有限切分，具有吞吐量大、数据较为准确的特点。然而我们知道，批处理器在时间切分点附近仍然...
Apache Flink流处理框架
weixin_44594317的博客
10-11 1036
Apache Flink 是一个强大且灵活的分布式流处理框架，能够处理海量实时数据和批处理任务。它的优势在于对流处理的深度支持、强大的容错能力和统一的流批处理模型
Flink流式处理框架中的Table API和Flink SQL
Running-小猛的博客
06-20 1061
一、Table API和Flink SQL是什么？ 1）Flink对批处理和流处理，提供了统一的上层API； 2）Table API是一套内嵌在Java和Scala语言中的查询API，它允许以非常直观的方式组合来自一些关系运算符的查询； 3）Flink的SQL支持基于实现了SQL标准的Apache Calcite； 1、基本程序结构 1）Table API和SQL的程序结构，与流式处理的程序结构十分类似 2、创建TableEnvironment 1）创建表的执行环境，需...
Flink流式计算实际生产项目代码
12-19
《Flink流式计算在实际生产项目中的应用详解》 Apache Flink，作为一个强大的开源流处理框架，已在大数据处理领域占据重要地位。本项目“Flink流式计算实际生产项目代码”聚焦于系统运维领域的流式处理，为初学者...
flink流式处理框架的架构与应用
10-22
Flink的应用场景丰富多样，包括实时优化电子商务搜索结果、为数据科学团队提供流式处理服务、网络和传感器监控及错误检测，以及业务智能基础设施中的ETL处理。Flink的实时处理能力使这些应用能够快速响应数据变化，...
【Flink】-- flink新版本发布：v2.0-preview1
欢迎来到我的博客，一起探索代码里的世界！
11-13 238
Apache Flink 社区已于2024-10-23发布了 Flink 2.0版本，这是自 Flink 1.0 发布以来的首个重大更新。Flink 2.0 将引入多项激动人心的功能和改进，包括存算分离状态管理、物化表、批作业自适应执行等，同时也包含了一些不兼容的变更。目前提供的预览版旨在让用户提前尝试新功能并收集反馈。Flink 2.0 preview 版，而不是 stable 版本，所以请不要应用于生产环境。
大数据入门-什么是Flink
最新发布
水坚石青的博客
11-17 493
Apache Flink 是一个框架和分布式处理引擎，用于在无边界和有边界数据流上进行有状态的计算。
flink StreamGraph 构造flink任务
csdn问鼎
11-13 271
手工生成flink 作业有向无环图
Flink_DataStreamAPI_输出算子Sink
qq_45972323的博客
11-13 835
如果我们想将数据存储到我们自己的存储设备中，而Flink并没有提供可以直接使用的连接器，就只能自定义Sink进行输出了。与Source类似，Flink为我们提供了通用的SinkFunction接口和对应的RichSinkDunction抽象类，只要实现它，通过简单地调用DataStream的.addSink()方法就可以自定义写入任何外部存储。在实现SinkFunction的时候，需要重写的一个关键方法invoke()，在这个方法中我们就可以实现将流里的数据发送出去的逻辑。
Flink算子
weixin_42828342的博客
11-14 1084
flink算子，包含以下类别：map，filter，flatMap，keyBy，aggregations，reduce，物理分区算子，富函数，分流算子split和side output，合流算子union(联合)和connect(连接）。
Flink新版Source接口源码解析
MCC_MCC_MCC的博客
11-14 1013
本文主要介绍了Flink的新版Source接口的核心类源代码解析，核心模块主要分为三大块，分别为Source、SplitEnumerator和SourceReader。分别讲述了核心类的功能以及各个接口方法的调用时机，泛型类型。最后给出了一个新版Source的实现步骤。
Flink Joins
chbxw
11-17 165
让一条流去Join另一条流中前后一段时间内的数据。,然后这样一个流既可以关联另外一个流过去一段时间范围内的数据,还能关联另外一个流未来一段时间内的数据。未来的数据是指当前时刻,还没有到的数据。要做到这一点,必须要把当前流的数据也保留起来,等另外一个流的未来的数据到了,要通知到当前这条数据去重新关联一下。
深入解析Flink流式窗口计算技术
资源摘要信息:"Flink Streaming 流式窗口计算是Apache Flink提供的一种核心功能，用于处理无界数据流。在实时数据分析和处理场景中，窗口计算允许我们对数据流进行切分和聚合操作。本文将详细介绍Flink Streaming中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

苍煜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值