Flink学习笔记之流处理核心编程--数据源读取(Source)

最新推荐文章于 2024-08-17 17:22:58 发布
最新推荐文章于 2024-08-17 17:22:58 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： Flink 文章标签： flink java 大数据 实时计算 流计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43224174/article/details/124654593
版权

本篇博客主要是写了如何从不同的数据源里读取数据，包括Flink从Java集合中读取数据、从本地文件当中读取数据、从Socket读取数据、从Kafka读取数据、从自定义Source获取数据。

目录

1、从Java集合中读取数据

一般情况下，可以将数据临时存储到内存中，形成特殊的数据结构后，作为数据源使用。这里的数据结构采用集合类型是比较普遍的。

package com.lqs.five.part1_source;

import com.lqs.bean.WaterSensor;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Arrays;
import java.util.List;

/**
 * @Author lqs
 * @Date 2022年03月28日 16:42:20
 * @Version 1.0.0
 * @ClassName SourceList
 * @Describe 从集合里面读取数据
 */
public class Test01_SourceList {

    public static void main(String[] args) throws Exception {
        
        //TODO 1、获取流的执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        //TODO 2、从集合中获取数据

        List<WaterSensor> waterSensors = Arrays.asList(
                new WaterSensor("1", 134L, 34),
                new WaterSensor("2", 1434L, 55),
                new WaterSensor("4", 1367L, 354)
        );

        env.fromCollection(waterSensors).print();

        /*//创建集合
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        DataStreamSource<Integer> streamSource = env.fromCollection(list).setParallelism(2);

        //多并行度方法
        env.fromCollection();*/

        //从元素中获取数据
        //The parallelism of non parallel operator must be 1
        DataStreamSource<Integer> streamSource = env.fromElements(1, 2, 3, 4, 5).setParallelism(1);

        streamSource.print();

        env.execute("SourceList");

    }
    
}

2、从本地文件当中读取数据

注意：

  1. 参数可以是目录也可以是文件
  2. 路径可以是相对路径也可以是绝对路径
  3. 相对路径是从系统属性user.dir获取路径: idea下是project的根目录, standalone模式下是集群节点根目录
  4. 也可以从hdfs目录下读取, 使用路径:hdfs://nwh120:8020/…, 由于Flink没有提供hadoop相关依赖, 需要pom中添加
    关依赖:
    <dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-client</artifactId>
    <version>3.1.3</version>
    </dependency>
package com.lqs.five.part1_source;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * @Author lqs
 * @Date 2022年03月28日 16:46:27
 * @Version 1.0.0
 * @ClassName Test02_SourceFile
 * @Describe 从文件读取数据
 */
public class Test02_SourceFile {

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

        //TODO 1、获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //TODO 2、读取文件里面的数据
        env.readTextFile("input/hcc").print();

        env.execute("SourceFile");

        /**
         * 注意；
         * 1.	参数可以是目录也可以是文件
         * 2.	路径可以是相对路径也可以是绝对路径
         * 3.	相对路径是从系统属性user.dir获取路径: idea下是project的根目录, standalone模式下是集群节点根目录
         * 4.	也可以从hdfs目录下读取, 使用路径:hdfs://hadoop102:8020/...., 由于Flink没有提供hadoop相关依赖, 需要pom中添加相关依赖:
         * <dependency>
         *     <groupId>org.apache.hadoop</groupId>
         *     <artifactId>hadoop-client</artifactId>
         *     <version>3.1.3</version>
         * </dependency>
         */

    }

}

3、从Socket读取数据

写法1

package com.lqs.five.part1_source;

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.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;

/**
 * @Author lqs
 * @Date 2022年03月28日 17:02:10
 * @Version 1.0.0
 * @ClassName Test03_SourceUnboundStream
 * @Describe 读取无界数据流
 */
public class Test03_SourceUnboundStream {

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

        //TODO 1、获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);

        //TODO 2、读取无界数据流
        //使用的nacat进行数据模拟
        DataStreamSource<String> streamSource = env.socketTextStream("nwh120", 8888);

        //TODO 3、将数据按照空格切分，切出每个单词
        SingleOutputStreamOperator<String> wordDataStream = streamSource.flatMap(
                new FlatMapFunction<String, String>() {
                    @Override
                    public void flatMap(String s, Collector<String> out) throws Exception {
                        for (String s1 : s.split(" ")) {
                            out.collect(s1);
                        }
                    }
                }
        )
                //设置共享度
//                .slotSharingGroup("gourp1")
                //与前后都断开
//                .disableChaining()
                //与前面都断开任务链
//                .startNewChain()
                //为某个算子单独设置并行度
//                .setParallelism(5)
                ;

        //TODO 4、将每个单词组成Tuple2元组
        SingleOutputStreamOperator<Tuple2<String, Integer>> wordToOneDataStream = wordDataStream.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> keyedDataStream = wordToOneDataStream.keyBy(
                new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                }
        );

        //TODO 1、做累加计数
        SingleOutputStreamOperator<Tuple2<String, Integer>> result = keyedDataStream.sum(1);

        result.print();

        env.execute("SourceUnboundStream");

    }

}

写法2

package com.lqs.five.part1_source;

import org.apache.flink.api.common.functions.RichFlatMapFunction;
import org.apache.flink.api.java.functions.KeySelector;
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;

/**
 * @Author lqs
 * @Date 2022年05月08日 21:08:48
 * @Version 1.0.0
 * @ClassName Test06_SourceSocket
 * @Describe 从Socket读取数据，也是无界流数据的读取
 */
public class Test03_SourceSocket {

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

        //TODO 1、获取流数据执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);

        //TODO 2、读取无界流数据
        DataStreamSource<String> streamSource = env.socketTextStream("nwh120", 8888);

        //TODO 3、转换数据结构
        //TODO 写法1
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = streamSource.flatMap(
                new RichFlatMapFunction<String, Tuple2<String, Long>>() {
                    @Override
                    public void flatMap(String value, Collector<Tuple2<String, Long>> out) throws Exception {
                        //按空格切分
                        String[] split = value.split(" ");
                        //循环将切分好的数据发送到下游（下一级）
                        for (String word : split) {
                            out.collect(Tuple2.of(word, 1L));
                        }
                    }
                }
        );

        //TODO 写法2
        /*SingleOutputStreamOperator<String> lineToWord = streamSource.flatMap(
                new RichFlatMapFunction<String, String>() {
                    @Override
                    public void flatMap(String value, Collector<String> out) throws Exception {
                        String[] words = value.split(" ");
                        for (String word : words) {
                            out.collect(word);
                        }
                    }
                }
        );
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = lineToWord.map(
                new MapFunction<String, Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> map(String value) throws Exception {
                        return Tuple2.of(value, 1L);
                    }
                }
        );*/

        //TODO 写法3
        /*SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = streamSource.flatMap(
                        (String line, Collector<String> out) -> {
                            Stream<String> words = Arrays.stream(line.split(" "));
//                    words.forEach(word -> out.collect(word));
                            words.forEach(out::collect);
                        }
                ).returns(Types.STRING)
                .map(value -> Tuple2.of(value, 1L))
                .returns(Types.TUPLE(Types.STRING, Types.LONG));*/

        //TODO 4、分组
        KeyedStream<Tuple2<String, Long>, String> keyedStream = wordAndOne.keyBy(
                new KeySelector<Tuple2<String, Long>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Long> value) throws Exception {
                        return value.f0;
                    }
                }
        );
        //简写
//        KeyedStream<Tuple2<String, Long>, String> keyedStream = wordAndOne.keyBy(value -> value.f0);

        //TODO 5、求和
        SingleOutputStreamOperator<Tuple2<String, Long>> result = keyedStream.sum(1);

        //TODO 6、打印
        result.print();

        //TODO 7、执行
        env.execute("WordCount");

    }

}

4、从Kafka读取数据

添加依赖

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-kafka_2.12</artifactId>
    <version>1.13.0</version>
</dependency>

新版写法

package com.lqs.five.part1_source;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.connector.kafka.source.KafkaSource;
import org.apache.flink.connector.kafka.source.enumerator.initializer.OffsetsInitializer;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * @Author lqs
 * @Date 2022年03月28日 17:30:05
 * @Version 1.0.0
 * @ClassName Test04_SourceKafka
 * @Describe 从Kafka读取数据流
 */
public class Test04_SourceKafka {

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

        //TODO 1、获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);

        //TODO 2、从Kafka读取数据流
        KafkaSource<String> kafkaSource = KafkaSource.<String>builder()
                .setBootstrapServers("nwh120:9092")
                .setTopics("test_kafka_source")
                .setGroupId("lqs_test")
                .setStartingOffsets(OffsetsInitializer.latest())
                .setValueOnlyDeserializer(new SimpleStringSchema())
                .build();

        DataStreamSource<String> streamSource = env.fromSource(kafkaSource, WatermarkStrategy.noWatermarks(), "kafka-source");

        streamSource.print();

        env.execute("SourceKafka");

    }

}

老版写法

package com.lqs.five.part1_source;

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

/**
 * @Author lqs
 * @Date 2022年03月28日 17:30:05
 * @Version 1.0.0
 * @ClassName Test04_SourceKafka
 * @Describe 从Kafka读取数据流
 */
public class Test04_SourceKafkaOld {

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

        //TODO 1、获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);

        //TODO 2、从Kafka读取数据流
        Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "nwh120:9092");
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "lqs_test");
        properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");

        env.addSource(new FlinkKafkaConsumer<String>("test_kafka_source", new SimpleStringSchema(), properties)).print();

        env.execute("SourceKafkaOld");

    }

}

5、从自定义Source获取数据

package com.lqs.five.part1_source;

import com.lqs.bean.WaterSensor;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;

import java.util.Random;

/**
 * @Author lqs
 * @Date 2022年03月28日 09:38:19
 * @Version 1.0.0
 * @ClassName CustomizeSource
 * @Describe 自定义source
 */
public class Test05_CustomizeSource {

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

        //TODO 1、获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        //TODO 2、从自定义的数据源获取数据
        env.addSource(new MySource()).print();

        env.execute("CustomizeSource");

    }

    public static class MySource implements ParallelSourceFunction<WaterSensor>{

        private Boolean isRuning=true;

        /**
         * 自定义数据生成
         * @param ctx
         * @throws Exception
         */
        @Override
        public void run(SourceContext<WaterSensor> ctx) throws Exception {
            while (isRuning){
                ctx.collect(
                        new WaterSensor(
                                "test_kafka_source"+new Random().nextInt(100),
                                System.currentTimeMillis(),
                                new Random().nextInt(1000)
                        )
                );
                Thread.sleep(1000);
            }
        }

        /**
         * 取消数据生成
         * 一般在run方法中会有个while循环，通过此方法终止while循环
         */
        @Override
        public void cancel() {
            isRuning=false;
        }
    }

}
【Flink】The parallelism of non parallel operator must be 1
一杯咖啡半杯糖的博客
02-09 1760
flink学习过程中遇到The parallelism of non parallel operator must be 1问题 Exception in thread "main" java.lang.IllegalArgumentException: The parallelism of non parallel operator must be 1. at org.apache.flink.util.Preconditions.checkArgument(Preconditions.jav...
Flink流数据采集笔记(三) : Source读取数据编程
YyyZzzLllx的博客
07-26 1086
Flink各种source读取各项数据:从Java/文件/kafka/Socket/自定义数据源读取数据
flink 任务恢复后的kafka消费起始位置
最新发布
csdn问鼎
08-17 507
flink 在不同配置下，消费起始位置的不同
SparkSQL读取数据源
成就源于知识，知识在于积累。
07-14 2928
sparkSQL读取数据源
【1】flink-source读取数据
PacosonSWJTU的博客
04-15 1124
【README】 本文记录了flink读取不同数据源的编码方式，数据源包括； 集合（元素列表）； 文件 kafka； 自定义数据源； 本文使用的flink为 1.14.4 版本；maven依赖如下： <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-java</artifactId>
PYTHON_读取数据源
penny1218的博客
10-22 401
欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片
数据分析指北 - 基础(基础数据操作之二，读取数据源)
07-08 255
数据分析指北 - 基础(基础数据操作之二，读取数据源)如何读取文件数据（以CSV文件举例）和数据库数据。历史回看：数据分析指北 - 前言(02)方法论 之 你会问问题吗？...
【学习笔记】尚硅谷大数据项目之Flink实时数仓---数据采集
prague6695的博客
07-14 4296
【学习笔记】尚硅谷大数据项目之Flink实时数仓---数据采集
flink学习详细笔记
10-28
【描述】：这篇笔记涵盖了Flink的基础概念，包括数据源读取、数据处理算子，特别是时间窗口和CEP算子的讲解，旨在帮助初学者从零开始踏入数据分析领域。 【标签】：“cep 算子” 【正文】： Apache Flink是一个...
Flink学习笔记（4）——source and sink
anyitian的博客
05-10 626
文章目录前言从集合读取数据从文件读取数据从socket读取数据从kafka读取数据自定义Source 前言 flink中提供了很多种数据源，有基于本地集合的 source、基于文件的 source、基于网络套接字的 source、自定义的 source。自定义的 source 常见的有 Apache kafka、Amazon Kinesis Streams、RabbitMQ、Twitter Streaming API、Apache NiFi 等，当然你也可以定义自己的 source。 Flink 常见的
Flink 尚硅谷学习笔记
狗剩的专栏
08-05 1715
尚硅谷Flink（Scala版）教程丨清华硕士-武晟然老师主讲 https://www.bilibili.com/video/BV1Qp4y1Y7YN P01.尚硅谷_Flink-Flink简介------------ 07:56 P02.尚硅谷_Flink-Flink应用场景---------- 19:46 P03.尚硅谷_Flink-流式处理的提出---------------- 11:05 P04.尚硅谷_Flink-流式处理的演变--...
flink(java)笔记
01-08
Flink通过`addSource()`方法从各种数据源读取数据，例如Socket、Kafka、HDFS等。Java API提供了预定义的source连接器，也可以自定义SourceFunction。 ### 5. 转换操作（Transformation） 转换是Flink作业的核心，...
bootstrap sql 城市选择_Flink 1.9—SQL 创建 Kafka 数据源
weixin_42347522的博客
12-31 201
前言目前 Flink 1.9 SQL 支持用户直接使用 SQL 语句创建 Kafka 数据源，这极大的方便了用户开发 Flink 实时任务，你可以像 Hive 一样，使用 Create Table 语句来创建 Kafka Source，同时在也可以使用 Select 语句，从这个表中读取数据，进行窗口、ETL等操作。本文主要讲解 Flink 1.9 SQL 创建 Kafka 的 SQL 语法使用，...
Flink 流处理 API
song_quan_的博客
11-03 175
Flink 流处理 API Environment getExecutionEnvironment 创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则 此方法返回本地执行环境；如果从命令行客户端调用程序以提交到集群，则此方法 返回此集群的执行环境，也就是说，getExecutionEnvironment 会根据查询运行的方 式决定返回什么样的运行环境，是最常用的一种创建执行环境的方式。 如果没有设置并行度，会以 flink-conf.yaml 中的配..
Flink流式读取Csv文件&&Doris Routine
呼吸困难的鱼的博客
08-18 1891
文章内容 大数据环境之下，各种数据来源参差不齐，本次数据来源于 kochava，kochava 译为 快出海，是全球领先的移动广告归因分析与优化及全球最大的DMP，有兴趣的伙伴可以了解一下这款产品 https://www.kchuhai.com/company/view-60.html，本次的任务就是从该产品中获取数据来源并通过 flink 写入到 Kafka ,最后写入到 Doris中。下面是简单的 数据采集demo内容 数据采集（demo） 1，通过 https://query.api.kochava.
《十堂课学习 Flink》第六章：Flink 流计算数据源 env.fromSource（以 Kafka作为数据源为例）
Smileyan's blog
04-11 5749
flink 基于 Kafka 进行通讯的案例介绍，包括序列化、条件判定等。
Flink 入门实战之三Source读取文件
xiaoc100200的博客
11-21 2056
Flink从文件中读取用户数据，并转化成样例类 用户数据user.csv 1,男,张三,20,1605970941 2,女,莉莉,30,1605970922 3,女,红红,30,1605970913 4,男,李四,24,1605970904 5,男,王五,25,1605970965 6,男,小明,20,1605970946 源码 package com.day import org.apache.flink.streaming.api.scala._ //用户信息样例类 case class U
Java版Flink（五）source源
qq_41311979的博客
03-14 393
一、source from collection 1.1、数据源类 public class SensorReading { // 传感器 id private String id; // 传感器时间戳 private Long timestamp; // 传感器温度 private Double temperature; public SensorReading() { } public SensorReading(String
【FLINK】实时流读取维表(一)Broadcast State Pattern
Zsigner的博客
01-17 2049
1、什么是广播状态 What is Broadcast State? TheBroadcast Statecan be used to combine and jointly process two streams of events in a specific way. The events of the first stream are broadcasted to all parallel instances of an operator, which maintains them as s..
"学习Flink-流批一体API和流处理概念
项目3-Flink-流批一体API是一个强大的数据处理工具，它提供了丰富的API和功能，可以支持流处理和批处理的需求。在学习Flink-流批一体API的过程中，我们需要掌握一系列的概念和操作符，比如数据流的来源、转换和输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小雏菊的成长

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

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

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

打赏作者

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

抵扣说明：

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

余额充值