【Flink】Flink的transform转换算子

最新推荐文章于 2024-05-06 10:42:57 发布
最新推荐文章于 2024-05-06 10:42:57 发布
阅读量555 收藏 2
点赞数
分类专栏： # Flink_Java 文章标签： flink 大数据 big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heiren_a/article/details/122862257
版权

Flink的transform转换算子

数据准备

  • 下面所使用的数据全都是以下数据
sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547728199,25.8
sensor_6,1547712201,35.4
sensor_7,1547718102,16.7
sensor_10,1547712205,28.1

基本转换算子（Map、FlatMap、Filter）

Map

  • map是将数据从一种形式转换成另一个形式
    在这里插入图片描述
  • 将字符串类型转换成输出他的字符串长度
        SingleOutputStreamOperator<Integer> mapStream = inputStream.map(new MapFunction<String, Integer>() {
            @Override
            public Integer map(String s) throws Exception {
                return s.length();
            }
        });
  • 上面的是完整的写法，还有一个简单的写法
SingleOutputStreamOperator<Integer> map = inputStream.map(str -> str.length());
  • 结果展示
    在这里插入图片描述

跳转顶部

flatMap

  • flatMap是将一个数组拆分成多个组
  • 将数据按照逗号进行分割
        SingleOutputStreamOperator<String> flatMapStream = inputStream.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String s, Collector<String> collector) throws Exception {
                String[] fields = s.split(",");
                for (String field : fields) {
                    collector.collect(field);
                }
            }
        });
  • 结果展示
    在这里插入图片描述

跳转顶部

Filter

  • 过滤出自己所需要的数据
    在这里插入图片描述
  • 筛选sensor_1开头的数据
        SingleOutputStreamOperator<String> filterStream = inputStream.filter(new FilterFunction<String>() {
            @Override
            public boolean filter(String s) throws Exception {
                return s.equ("sensor_1");
            }
        });
  • 结果展示
    在这里插入图片描述

跳转顶部

KeyBy

  • DataStream → KeyedStream：逻辑地将一个流拆分成不相交的分区，每个分区包含具有相同 key 的元素，在内部以 hash 的形式实现的。
    在这里插入图片描述
  • 滚动聚合算子可以针对 KeyedStream 的每一个支流做聚合
  • 代码展示
package transform;

import beans.SenSorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple;
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;

public class KeyByAndRollAggregation {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //从文件中读取数据
        DataStreamSource<String> inputStream = env.readTextFile("src/main/resources/sensor.txt");

        //转换成自定义的类型
//        SingleOutputStreamOperator<SenSorReading> dataStream = inputStream.map(new MapFunction<String, SenSorReading>() {
//            @Override
//            public SenSorReading map(String s) throws Exception {
//                String[] fileds = s.split(",");
//                return new SenSorReading(fileds[0], new Long(fileds[1]), new Double(fileds[2]));
//            }
//        });
        SingleOutputStreamOperator<SenSorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SenSorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        /**
         * key的两种实现方式
         * 第一种：如果数据类型是元组（Tuple）的话，直接使用所分区的位置即可
         * 第二种：字段名称，也就是自定义类的分区属性名
         */
        KeyedStream<SenSorReading, Tuple> keyByStream = dataStream.keyBy("id");
//        KeyedStream<SenSorReading, String> keyByStream02 = dataStream.keyBy(data -> data.getId());

        //滚动聚合
        /**
         * 什么是滚动聚合？
         * 就是不同的在更新，来一条数据就会更新一条数据
         */
        SingleOutputStreamOperator<SenSorReading> resultStream = keyByStream.max("temperature");
        /**
         * maxBy和max的区别？
         * max的是取最大值，但是朱慧注意所要取的那个元素，最后输出的结果是索取元素的最大值，但是其他元素不一定是和其匹配的
         * maxBy记录的是整条元素
         */
        SingleOutputStreamOperator<SenSorReading> maxByresultStream = keyByStream.maxBy("temperature");
        maxByresultStream.print("maxBy");
        resultStream.print("max");
        env.execute();
    }
}

  • max和maxBy的区别是什么呢？

    max的是取最大值，但是朱慧注意所要取的那个元素，最后输出的结果是索取元素的最大值，但是其他元素不一定是和其匹配的

    maxBy记录的是整条元素

  • 原数据可见，最大那条的数据应该是sensor_10,1547718205,38.1,我们分别来看看max和maxBY所求出的数据有什么不同

在这里插入图片描述
跳转顶部

自定义reduce

  • KeyedStream → DataStream：一个分组数据流的聚合操作，合并当前的元素和上次聚合的结果，产生一个新的值，返回的流中包含每一次聚合的结果，而不是只返回最后一次聚合的最终结果。

  • 代码展示

package transform;

import beans.SenSorReading;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple;
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;

public class reduceTest01 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //从文件中读取数据
        DataStreamSource<String> inputStream = env.readTextFile("src/main/resources/sensor.txt");

        SingleOutputStreamOperator<SenSorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SenSorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        KeyedStream<SenSorReading, String> keyByStream = dataStream.keyBy(data -> data.getId());

        //reduce 取得是最大的温度值，和最新的时间戳
//        SingleOutputStreamOperator<SenSorReading> reduceStream = keyByStream.reduce(new ReduceFunction<SenSorReading>() {
//            /**
//             * 第一个是之前处理的结果数据
//             * 第二个是等等待处理的数据
//             * @param senSorReading
//             * @param t1
//             * @return
//             * @throws Exception
//             */
//            @Override
//            public SenSorReading reduce(SenSorReading senSorReading, SenSorReading t1) throws Exception {
//                return new SenSorReading(senSorReading.getId(), t1.getTimeStamp(), Math.max(senSorReading.getTemperature(), t1.getTemperature()));
//            }
//        });
        SingleOutputStreamOperator<SenSorReading> reduceStream =keyByStream.reduce((curr, newData) -> new SenSorReading(curr.getId(), newData.getTimeStamp(), Math.max(curr.getTemperature(), newData.getTemperature())));
        reduceStream.print();
        env.execute();
    }
}

  • 结果展示
    在这里插入图片描述

  • 可以看出时间戳是变换为最新的

跳转顶部

拆分和组合

Split 和 Select

  • Split：DataStream → SplitStream：根据某些特征把一个 DataStream 拆分成两个或者多个 DataStream。
    在这里插入图片描述
  • Select：SplitStream→DataStream：从一个 SplitStream 中获取一个或者多个DataStream。
    在这里插入图片描述
  • 将数据以温度30度划分
package transform;

import beans.SenSorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.*;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoMapFunction;

import java.util.Collections;

public class CollectAndColMap {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //从文件中读取数据
        DataStreamSource<String> inputStream = env.readTextFile("src/main/resources/sensor.txt");

        SingleOutputStreamOperator<SenSorReading> mapStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SenSorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //分流，将数据按照三十度来进行分流
        SplitStream<SenSorReading> splitStream = mapStream.split(new OutputSelector<SenSorReading>() {
            @Override
            public Iterable<String> select(SenSorReading senSorReading) {
                return (senSorReading.getTemperature() > 30 ? Collections.singletonList("high") : Collections.singletonList("low"));
            }
        });
        DataStream<SenSorReading> highStream = splitStream.select("high");
        DataStream<SenSorReading> lowStream = splitStream.select("low");
        DataStream<SenSorReading> allStream = splitStream.select("high", "low");

        highStream.print("high");
        lowStream.print("low");
        allStream.print("all");

        env.execute();
    }
}
  • 结果展示
    在这里插入图片描述

Connect 和 CoMap

  • Connect：DataStream,DataStream → ConnectedStreams：连接两个保持他们类型的数据流，两个数据流被 Connect 之后，只是被放在了一个同一个流中，内部依然保持各自的数据和形式不发生任何变化，两个流相互独立。
    在这里插入图片描述
  • CoMap：ConnectedStreams → DataStream：作用于 ConnectedStreams 上，功能与 map和 flatMap 一样，对 ConnectedStreams 中的每一个 Stream 分别进行 map 和 flatMap处理。
    在这里插入图片描述
  • Connect和CoMap是可以连接不同数据类型的数据的,下面我们代码示范将高低数据连接
package transform;

import beans.SenSorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.collector.selector.OutputSelector;
import org.apache.flink.streaming.api.datastream.*;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoMapFunction;

import java.util.Collections;

public class CollectAndColMap {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //从文件中读取数据
        DataStreamSource<String> inputStream = env.readTextFile("src/main/resources/sensor.txt");

        SingleOutputStreamOperator<SenSorReading> mapStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SenSorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        //分流，将数据按照三十度来进行分流
        SplitStream<SenSorReading> splitStream = mapStream.split(new OutputSelector<SenSorReading>() {
            @Override
            public Iterable<String> select(SenSorReading senSorReading) {
                return (senSorReading.getTemperature() > 30 ? Collections.singletonList("high") : Collections.singletonList("low"));
            }
        });
        DataStream<SenSorReading> highStream = splitStream.select("high");
        DataStream<SenSorReading> lowStream = splitStream.select("low");
        DataStream<SenSorReading> allStream = splitStream.select("high", "low");

        highStream.print("high");
        lowStream.print("low");
        allStream.print("all");

        /**
         * 合流
         * 将高温转换成二元组类型，于低温流连接之后，输出状态信息
         */
        SingleOutputStreamOperator<Tuple2<String, Double>> highMapStream = highStream.map(new MapFunction<SenSorReading, Tuple2<String, Double>>() {
            @Override
            public Tuple2<String, Double> map(SenSorReading senSorReading) throws Exception {
                return new Tuple2<>(senSorReading.getId(), senSorReading.getTemperature());
            }
        });

        //连接
        ConnectedStreams<Tuple2<String, Double>, SenSorReading> connectStream = highMapStream.connect(lowStream);
        /**
         * 三个参数的意义
         * 前两个分别是合并map的类型
         * 第三个是需要转换成的数据类型
         */
        SingleOutputStreamOperator<Object> map = connectStream.map(new CoMapFunction<Tuple2<String, Double>, SenSorReading, Object>() {
            @Override
            public Object map1(Tuple2<String, Double> stringDoubleTuple2) throws Exception {
                return new Tuple3<>(stringDoubleTuple2.f0,stringDoubleTuple2.f1,"high temp waring");
            }

            @Override
            public Object map2(SenSorReading senSorReading) throws Exception {
                return new Tuple2<>(senSorReading.getId(),"normal");
            }
        });

       map.print();

    }
}
  • 结果展示
    在这里插入图片描述

Union

  • 那有没有办法连接多个流呢？有的，union就可以，但是union只可以连接数据类型相同的流

在这里插入图片描述

DataStream<SenSorReading> union = highStream.union(lowStream, allStream);

跳转顶部

富函数（Rich Functions）

  • “富函数”是 DataStream API 提供的一个函数类的接口，所有 Flink 函数类都有其 Rich 版本。它与常规函数的不同在于，可以获取运行环境的上下文，并拥有一些生命周期方法，所以可以实现更复杂的功能。

    RichMapFunction

    RichFlatMapFunction

    RichFilterFunction

  • Rich Function 有一个生命周期的概念。典型的生命周期方法有：

    open()方法是 rich function 的初始化方法，当一个算子例如 map 或者 filter被调用之前 open()会被调用。

    close()方法是生命周期中的最后一个调用的方法，做一些清理工作。

    getRuntimeContext()方法提供了函数的 RuntimeContext 的一些信息，例如函数执行的并行度，任务的名字，以及 state 状态

  • 富函数的主要作用就是可以获取运行环境的信息，和在程序运行前做一些准备工作

package transform;

import beans.SenSorReading;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

public class RichFunctionTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //从文件中读取数据
        DataStreamSource<String> inputStream = env.readTextFile("src/main/resources/sensor.txt");

        SingleOutputStreamOperator<SenSorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SenSorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        DataStream<Tuple2<String, Integer>> res = dataStream.map(new MyMapper());

        res.print();
        env.execute();
    }

    public static class MyMapper01 implements MapFunction<SenSorReading, Tuple2<String, Integer>> {

        @Override
        public Tuple2<String, Integer> map(SenSorReading senSorReading) throws Exception {
            return new Tuple2<>(senSorReading.getId(), senSorReading.getId().length());
        }
    }

    /**
     * 主要的作用就是可以获取到当前的很多运行时信息
     */
    //实现自定义富函数类
    public static class MyMapper extends RichMapFunction<SenSorReading, Tuple2<String, Integer>> {

        @Override
        public Tuple2<String, Integer> map(SenSorReading senSorReading) throws Exception {
            return new Tuple2<>(senSorReading.getId(), getRuntimeContext().getIndexOfThisSubtask()+1);
        }

        @Override
        public void open(Configuration parameters) throws Exception {
            /**
             * 初始化的工作,一般是定义工作状态,或者建立数据库连接
             */
            System.out.println("open");
        }

        @Override
        public void close() throws Exception {
            /**
             * 释放缓存，关闭连接
             */
            System.out.println("close");
        }
    }
}
飝鱻.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink系列：自定义Transformation转换函数
NIO4444
06-07 792
目录 实现接口 匿名函数 JDK8Lambdas 继承 匿名函数 实现接口 class MyMapFunction implements MapFunction<String, Integer> { public Integer map(String value) { return Integer.parseInt(value); } }; data.map(new MyMapFunction()); 匿名函数 data.map(new MapFunction&..
Flink 常见 Transform
qq_29342297的博客
01-23 366
Flink Transform 以下是flink中常见的一些transform map // 创建执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); // 加载数据源 DataStream<String> datas = env.readTextFile("data/words.txt"); // map transform 转换
flink重温笔记（九）：Flink 高级 API 开发——flink 四大基石之WaterMark(1)
最新发布
2401_84167046的博客
05-06 641
数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718205, vc=15)数据>>>> MonotonousWaterMark.WaterSensor(id=sensor_6, ts=1547718201, vc=15)
flink-3
不爱吃鱼的馋猫
01-14 413
实时数仓 第1章 DWS层与DWM层的设计 1.1 设计思路 我们在之前通过分流等手段，把数据分拆成了独立的Kafka Topic。那么接下来如何处理数据，就要思考一下我们到底要通过实时计算出哪些指标项。 因为实时计算与离线不同，实时计算的开发和运维成本都是非常高的，要结合实际情况考虑是否有必要象离线数仓一样，建一个大而全的中间层。 如果没有必要大而全，这时候就需要大体规划一下要实时计算出的指标需求了。把这些指标以主题宽表的形式输出就是我们的DWS层。 1.2 需求梳理 统计主题.
flume-kafka-flink项目
qq_52563266的博客
06-13 414
项目
Flink（二）--DataStream的各类算子
u014468095的博客
11-27 4910
本文用java代码介绍flink的各类算子。采用上篇文章中对接的kafka数据源。 一、Map：对数据进行逐个遍历，常用作对数据集内数据的清洗和转换 input.print(); SingleOutputStreamOperator<Tuple2<String, Integer>> map = input.map(new MapFunction<Stri...
Flink使用lambda表达式报错：InvalidTypesException：could not be determined automatically, due to type erasure.
Aimo_哈撒的博客
11-26 3069
在写Flink程序的时候（以最简单的WordCount案例为例），有时会使用Lambda表达式来简化，如下边程序中的flatMap算子和Map算子处，都是用了Lambda表达式来简写： public static void main(String[] args) throws Exception { StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
Flink--Transform(简单转换算子)
MINGZHEFENG的博客
11-29 1128
简单转换算子 FLink中的简单转换算子 包含 map flatmap fiter 他们有一个共同的特点就是 1 to 1 类似于spark窄依赖 Map 输入一个 按照转换规则 输出一个 //创建执行环境 val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment //读取一个list并转换为datastream val intList = List(1,2
Flink常用算子Transformation（转换）
热门推荐
夏天小厨的博客
04-17 1万+
在之前的《Flink DataStream API》一文中，我们列举了一些Flink自带且常用的transformation算子，例如map、flatMap等。在Flink的编程体系中，我们获取到数据源之后，需要经过一系列的处理即transformation操作，再将最终结果输出到目的Sink（ES、mysql或者hdfs），使数据落地。因此，除了正确的继承重写RichSourceFunction...
Flink基础系列15-Tranform之基本转换算子(map/flatMap/filter)
只是甲的博客
10-21 1万+
文章目录一.转换算子1.1 map1.2 flatMap1.3 Filter二.代码参考: 一.转换算子 1.1 map 从如下图解可以看到，map是一对一的操作，对dataStream中的计算，一对一输出 DataStream<Integer> mapStram = dataStream.map(new MapFunction<String, Integer>() { public Integer map(String value) throws Exce
Flink 自定义算子 读取MySQL (scala源代码)
06-29
Flink 自定义算子 读取MySQL (scala源代码)
Flink-1.16.2 CDH6.3.2
09-26
CDH6.3.2集成安装Flink-1.16.2，所需的包都在文件里面了，不用再自己打包了 参考部署教程： https://blog.csdn.net/qq_31454379/article/details/110440037 https://www.cnblogs.com/lshan/p/16469294.html
flink-sql集成rabbitmq
06-29
flink-sql集成rabbitmq
Flink Phoenix connector依赖包
06-02
flink sql读写phoenix所使用到的连接器依赖包： flink-sql-connector-phoenix-1.14-1.0.jar 使用示例： create table tab2( ID STRING, NAME STRING, PRIMARY KEY (ID) NOT ENFORCED )WITH( 'connector' = '...
Flink入门系列03-多流操作API
边看边学
08-25 534
需求： 将行为事件流进行分流。A事件分到一个流，B事件分到另一个流，其他事件保留在主流。可实现两个流的数据进行窗口关联（包含inner ，left， right， outer）只能得到关联上的数据，即 inner join，其他类型join需要使用 coGroup。场景：事实表流数据 和 维度表流数据做关联，此时，一般把维度表流数据转换为广播流。参与 union 的流，必须数据类型一致。
Flink（十）【处理函数】
m0_64261982的博客
12-20 1301
Flink 处理函数
flink 1.10.1 java版本kafka sink写入处理结果到kafka
liaomingwu的专栏
02-07 1439
flink 1.10.1 java版本kafka sink写入处理结果到kafka
（十）Flink Datastream API 编程指南 算子-1 （转换算子、物理分区、任务链、资源组 、算子和作业）等基本介绍
京河小蚁的博客
06-01 433
概览 操作符将一个或多个DataStream转换为一个新的DataStream。程序可以将多个转换组合成复杂的数据流拓扑。 本节将描述基本的转换、应用这些转换后的有效物理分区以及对Flink的 operator chain（链）的深入了解。 DataStream 各种转换算子 Map DataStream → DataStream 获取一个元素并生成一个元素。将输入流的值加倍的map函数: DataStream<Integer> dataStream = //... dataStream.map
flink 算子如何结束
07-11
Flink 算子的结束可以通过以下几种方式来实现： 1. 数据源结束：当数据源没有更多的数据可供处理时，Flink 算子会自动结束。这通常发生在流式处理任务中，当数据源没有新的事件到达时。 2. 窗口操作：使用窗口操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值