java Flink（三十二）Flink的异步IO访问外部数据

最新推荐文章于 2023-04-05 17:03:59 发布
最新推荐文章于 2023-04-05 17:03:59 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： Java Flink Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40771567/article/details/118897276
版权

 Flink的异步官方的介绍：

当我们使用 Flink 在与外部系统进行交互时（例如：使用存储在数据库中的数据来丰富流事件），这时便需要注意 Flink系统与外部系统的通信延迟了。

       我们使用 MapFunction() 的方式与外部数据库交互，使用的 同步交互 的方式。即：将请求发送到数据库，并MapFunction等待直到收到响应。在许多情况下，这种等待占据了功能的绝大部分时间。

       与数据库的异步交互，意味着单个并行函数实例可以同时处理许多请求并同时接收响应。这样，等待时间便可以与发送其他请求和接收响应重叠。至少，等待时间将被分摊到多个请求上。在大多数情况下，会使系统有更高的吞吐量。

 我们这里用异步的http请求（异步的前提是外部数据支持异步操作）来记录这个内容

 

 DataLocation POJO类：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
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.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.async.ResultFuture;
import org.apache.flink.streaming.api.functions.async.RichAsyncFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Collections;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public class HttpAsyncMain {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //创建pro配置
        Properties pro = new Properties();
        //添加集群配置信息
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "xx:9092,xx:9092,xx:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG, "group");
        pro.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        FlinkKafkaConsumer<String> kafkaConsumer = new FlinkKafkaConsumer<String>("locations", new SimpleStringSchema(), pro);
        DataStreamSource<String> kafkaStream = env.addSource(kafkaConsumer);

        //开启异步处理数据 异步任务超过10个就会阻塞,0代表不设置超时时间
        DataStream<DataLocation> resultStream = AsyncDataStream.unorderedWait(kafkaStream, new AsyncDatabaseRequest(), 0, TimeUnit.MICROSECONDS, 10);
        resultStream.print("result:");
        env.execute();
    }

    //异步请求第三方API
    public static class AsyncDatabaseRequest extends RichAsyncFunction<String, DataLocation> {

        private transient CloseableHttpAsyncClient httpAsyncClient = null;

        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            //初始化异步HttpClient
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(3000) //设置socket超时时间
                    .setConnectTimeout(3000) //设置连接超时时间
                    .build();
            HttpAsyncClients.custom()
                    .setMaxConnTotal(20) //设置最大连接数
                    .setDefaultRequestConfig(requestConfig).build();
        }


        public void asyncInvoke(String input, final ResultFuture<DataLocation> resultFuture) throws Exception {
            String[] fields = input.split(",");
            String id = fields[0];
            String name = fields[1];
            String date = fields[2];
            String lng = fields[3];
            String lat = fields[4];

            //API 地址
            String url = "";
            //执行查询
            final HttpGet request1 = new HttpGet(url);
            final Future<HttpResponse> future = httpAsyncClient.execute(request1, null);

            CompletableFuture.supplyAsync(new Supplier<String>() {
                public String get() {
                    try {
                        HttpResponse response = future.get();
                        String province = null;
                        if (response.getStatusLine().getStatusCode() == 200) {
                            //获取请求的Json字符串
                            String result = EntityUtils.toString(response.getEntity());
                            //将Json字符串转成Json对象
                            JSONObject jsonObject = JSON.parseObject(result);
                            //获取位置信息
                            JSONObject regeocode = jsonObject.getJSONObject("regeocode");

                            if (regeocode != null && !regeocode.isEmpty()) {
                                JSONObject address = regeocode.getJSONObject("addressComponent");
                                //获取省份信息
                                String province1 = address.getString("province");
                            }
                        }
                        return province;
                    } catch (Exception e) {
                        return null;
                    }
                }
            }).thenAccept((String dbResult) -> {
                resultFuture.complete(Collections.singleton(DataLocation.of(id, name, date, dbResult)));
            });
        }
    }
}

异步请求主程序：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
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.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.async.ResultFuture;
import org.apache.flink.streaming.api.functions.async.RichAsyncFunction;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Collections;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public class HttpAsyncMain {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //创建pro配置
        Properties pro = new Properties();
        //添加集群配置信息
        pro.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "xx:9092,xx:9092,xx:9092");
        pro.put(ConsumerConfig.GROUP_ID_CONFIG, "group");
        pro.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        FlinkKafkaConsumer<String> kafkaConsumer = new FlinkKafkaConsumer<String>("locations", new SimpleStringSchema(), pro);
        DataStreamSource<String> kafkaStream = env.addSource(kafkaConsumer);

        //开启异步处理数据 异步任务超过10个就会阻塞,0代表不设置超时时间
        DataStream<DataLocation> resultStream = AsyncDataStream.unorderedWait(kafkaStream, new AsyncDatabaseRequest(), 0, TimeUnit.MICROSECONDS, 10);
        resultStream.print("result:");
        env.execute();
    }

    //异步请求第三方API
    public static class AsyncDatabaseRequest extends RichAsyncFunction<String, DataLocation> {

        private transient CloseableHttpAsyncClient httpAsyncClient = null;

        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            //初始化异步HttpClient
            RequestConfig requestConfig = RequestConfig.custom()
                    .setSocketTimeout(3000) //设置socket超时时间
                    .setConnectTimeout(3000) //设置连接超时时间
                    .build();
            HttpAsyncClients.custom()
                    .setMaxConnTotal(20) //设置最大连接数
                    .setDefaultRequestConfig(requestConfig).build();
        }


        public void asyncInvoke(String input, final ResultFuture<DataLocation> resultFuture) throws Exception {
            String[] fields = input.split(",");
            String id = fields[0];
            String name = fields[1];
            String date = fields[2];
            String lng = fields[3];
            String lat = fields[4];

            //API 地址
            String url = "";
            //执行查询
            final HttpGet request1 = new HttpGet(url);
            final Future<HttpResponse> future = httpAsyncClient.execute(request1, null);

            CompletableFuture.supplyAsync(new Supplier<String>() {
                public String get() {
                    try {
                        HttpResponse response = future.get();
                        String province = null;
                        if (response.getStatusLine().getStatusCode() == 200) {
                            //获取请求的Json字符串
                            String result = EntityUtils.toString(response.getEntity());
                            //将Json字符串转成Json对象
                            JSONObject jsonObject = JSON.parseObject(result);
                            //获取位置信息
                            JSONObject regeocode = jsonObject.getJSONObject("regeocode");

                            if (regeocode != null && !regeocode.isEmpty()) {
                                JSONObject address = regeocode.getJSONObject("addressComponent");
                                //获取省份信息
                                String province1 = address.getString("province");
                            }
                        }
                        return province;
                    } catch (Exception e) {
                        return null;
                    }
                }
            }).thenAccept((String dbResult) -> {
                resultFuture.complete(Collections.singleton(DataLocation.of(id, name, date, dbResult)));
            });
        }
    }
}

小菜菜1223
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
flink datastream api 示例大全
10-19
1. **异步IO(Asynchronous I/O)**：在Flink中，异步IO允许用户在执行读写操作时避免阻塞主线程，提高系统效率。例如，当从远程服务读取数据或写入存储系统时，可以使用异步接口来并发处理多个请求。 2. **Join**：...
项目7-Flink-高级特性和新特性1
08-08
【Flink 高级特性和新特性】\n\nApache Flink作为一个强大的开源流...结合异步IO和Streaming file sink，Flink为开发者提供了更灵活的数据存储和输出方式，而与Hive的整合则进一步拓宽了其在大数据生态中的应用范围。
Flink--AsyncI/O
JinVijay的博客
02-24 867
使用异步IO查询高德地图关联数据 /** * 封装数据的对象 */ public class OrderBean { public String oid; public String cid; public Double money; public Double longitude; public Double latitude; public String province; public String city; pu
Flink 访问 Http请求
lck_csdn的博客
07-15 3014
Flink读取Http请求
Flink10：Kafka-Connector：Kafka Consumer的使用、Kafka Producer的使用
weixin_40612128的博客
03-16 2022
Flink 提供了很多Connector组件，其中应用较广泛的就是Kafka这个Connector了，下面我们针对Kafka-Connector在Flink中的应用做详细的分析。 一、Kafka-Connector 针对Flink的流处理，最常用的组件就是Kafka，原始日志数据产生后会被日志采集工具采集到Kafka中让Flink去处理，处理之后的数据可能也会继续写入到Kafka中，Kafka可以作为Flink的DataSource和DataSink来使用。 并且Kafka中的Partition机制和Fli
Flink之外部数据访问的异步 I/O
蔡政洁的博客
03-27 668
目录（1）对于异步 I/O 操作的需求（2）异步 I/O API超时处理结果的顺序事件时间容错保证（3）代码实现 （1）对于异步 I/O 操作的需求 在与外部系统交互（用数据库中的数据扩充流数据）的时候，需要考虑与外部系统的通信延迟对整个流处理应用的影响。 简单地访问外部数据库的数据，比如使用 MapFunction，通常意味着同步交互： MapFunction 向数据库发送一个请求然后一直等待，直到收到响应。在许多情况下，等待占据了函数运行的大部分时间。 与数据库异步交互是指一个并行函数实例可以并发地处理
Flink异步IO之HttpClient
我的祖传代码
05-31 2295
官方示例： // This example implements the asynchronous request and callback with Futures that have the // interface of Java 8's futures (which is the same one followed by Flink's Future) /** * An implementation of the 'AsyncFunction' that sends request...
通俗易懂之Flink DataStream API开发
02-07
本篇将深入探讨流处理的基本概念，以及Flink DataStream API的使用，包括算子操作、水印机制、状态管理、容错机制、异步IO、端对端一次性语义、Streaming file sink的运用，以及综合案例的开发。 1. **流处理基础**...
flink入门到精通视频教程
07-15
10.Flink进阶 异步IO，背压，内存管理 11.Flink Table API与SQL 课程目录介绍 第一章 Flink简介 01.Flink的引入 02.什么是Flink 03.Flink流处理特性 04.Flink基石 05.批处理与流处理 第二章 Flink架构体系 01.Flink...
flink-local-train:flink入门到项目实践
05-06
文章会对Flink中基本API如：DataSet、DataStream、Table、Sql和常用特性如：Time&Window、窗口函数、Watermark、触发器、分布式缓存、异步IO、侧输出、广播和高级应用如：ProcessFunction、状态管理等知识点进行整理...
flink sql自定义函数 多个参数调用http接口 并且实时调用
wudonglianga的专栏
04-05 1735
使用通过flink sql 自动定义函数（udf）将实时接入的数据输出到 http 接口当中
flink_kafka consumer
qq_31026281的博客
03-16 2130
import org.apache.flink.streaming.api.scala.DataStream import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment import org.apache.flink.api.scala._ import nn.MyKafkaUtil object StartupApp { def main(args: Array[String]): Unit = { val e...
flink的异步接口调用
qq_44962429的博客
02-14 2663
同步接口的调用，是在接口响应之后，才能进行下一数据的请求方法，在接口性能不佳的情况下，严重影响flink的性能，这与flink的实时思想有违背，为了避免这种情况，我们在接口调用的时候，可以采取异步的方式。 不废话，直接上代码，需要原理自行官方文档。 AsyncDataStream.unorderedWait(dataSource, new HttpAsyncFunction("url"), 300...
【Flink Rest-ful API 】
追赶者的博客
03-31 1413
Flink 有了一些查询job状态指标的API,这些监控API is a REST-ful API 接受 HTTP 请求并返回JSON data ；这些监控API以jobManager中web server 为基础，默认其监听端口为8081，当然你可以在flink-conf.yaml配置中通过rest.port 自定义其端口，下面我们就对其REST-ful API 进行尝试。 一：Flink 上传jar包REST-ful API PO...
flink接入http数据写到hive
cclovezbf的博客
09-26 867
因为http的数据一般很少，我这个是看班车的数据 一天差不多是3w多条。需求很奇怪，但是无所谓了。
Flink当中使用kafka Consumer
影子
03-29 6092
Flink与kafka结合使用的三个优势： 第一：kafka可以作为Flink的Source和Sink来使用； 第二：Kafka的Partition机制和Flink的并行度机制可以深度结合，从而提高数据的读取率和写入效率 第三：当Flink任务失败的时候，可以通过设置kafka的Offset来恢复应用从而重新消费数据 添加依赖： <dependency> <groupId>org.apache.flink</groupId&g
flink与kafka结合示例
热门推荐
feinifi的博客
11-15 2万+
flink作为实时流处理平台，可以与kafka很好地结合。 因为flink流处理的特点，需要source和sink作为流处理的源头和终端。与kafka的结合，可以让flink作为生产者，不断的向kafka消息队列中产生消息。这个作为今天的第一个示例。对应下图的场景。 还有一种情况，让flink作为kafka的消费者，读取消息队列中的消息，然后做处理。这时候flink的与kafka的角色发生了变化，对应下图的场景。 根据以上的两种情况，我们来编写相...
Flink-数据源(Source)&存储(Sink)
qq_34297258的博客
10-15 321
Source------------------------------------------------------------ 从Kafka读取数据 添加相应的依赖 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka_2.11</artifactId> <version>1.12.
Flink实战：自定义KafkaDeserializationSchema(Java/Scala)
陆继森的技术专栏
04-25 9744
微信公众号：大数据开发运维架构 关注可了解更多大数据相关的资讯。问题或建议，请公众号留言; 如果您觉得“大数据开发运维架构”对你有帮助，欢迎转发朋友圈 从微信公众号拷贝过来，格式有些错乱，建议直接去公众号阅读 kafka中的数据通常是键值对的，所以我们这里自定义反序列化类从kafka中消费键值对的消息，为方便大家学习，这里我实现了Java/Scala两个版本，由于比较简单这里直接上...
flink中的BroadcastConnectedStream如何实现异步io
最新发布
05-25
Flink中的BroadcastConnectedStream可以用于将广播流与主数据流连接起来。其中，广播流被异步地读取，而主数据流则被同步地读取。这样做的目的是为了提高程序的性能，避免阻塞主数据流的读取。 在具体实现中，广播流需要通过异步IO的方式进行读取。这个过程可以使用Flink中提供的异步IO接口来实现。在异步IO的实现中，需要定义一个异步IO执行器，该执行器会在后台线程中读取广播流数据，并将其存储在内存中。在主数据流处理过程中，可以通过异步IO执行器来获取广播流数据，从而实现异步读取。 需要注意的是，在使用BroadcastConnectedStream时，异步IO的执行过程需要与主数据流的处理过程保持同步。这可以通过Flink中提供的异步IO回调函数来实现。在异步IO执行器读取到广播流数据后，会调用异步IO回调函数，将读取到的数据传递给主数据流处理过程。这样，主数据流处理过程就可以在获取广播流数据时，避免阻塞，提高程序的性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值