flink-认识各种算子及使用

最新推荐文章于 2024-04-23 12:24:08 发布
最新推荐文章于 2024-04-23 12:24:08 发布
阅读量436 收藏
点赞数 2
分类专栏： flink 大数据 笔记 文章标签： flink big data 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Er_fengV/article/details/120078757
版权
笔记 同时被 3 个专栏收录
33 篇文章 0 订阅
订阅专栏
大数据
13 篇文章 0 订阅
订阅专栏
flink
9 篇文章 1 订阅
订阅专栏

前言

用户通过算子能将一个或多个 DataStream 转换成新的 DataStream，在应用程序中可以将多个数据转换算子合并成一个复杂的数据流拓扑。

接下来介绍部分算子的使用方法，大家直接复制粘贴就好，简单粗暴

搭建IDEA的开发环境

记得下载一个Lombok插件

pom文件如下：

	<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <flink.version>1.9.2</flink.version>
        <scala.binary.version>2.11</scala.binary.version>
    </properties>
    <dependencies>
    <!-- Apache Flink dependencies -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-core</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-table-planner-blink_2.11</artifactId>
        <version>${flink.version}</version>
    </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

UserBean类如下：

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * Created with IntelliJ IDEA
 *
 * @Auther: erfeng
 * @Date：2021/09/02/9:50
 * @Description: 
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserBean {
    private String userID;
    private long eventTime;
    private String eventType;
    private String productID;
    private int productPrice;
}

做好上述准备后，接下来让我一起来认识一下各种算子及使用吧

各种算子介绍及使用

Aggregate


/**
 * aggregate filter flatmap fold keyby map reduce
 * Summary:
 *     Aggregate: min()、minBy()、max()、maxBy() 滚动聚合并输出每次滚动聚合后的结果
 */
public class DataStreamAggregateOperator {
    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        ArrayList<UserBean> userBeans = new ArrayList<>();
        UserBean userbeanlog1 = new UserBean();
        userbeanlog1.setUserID("userID1");
        userbeanlog1.setProductID("productID3");
        userbeanlog1.setProductPrice(10);
        userBeans.add(userbeanlog1);

        UserBean userbeanlog2 = new UserBean();
        userbeanlog2.setUserID("userID2");
        userbeanlog2.setProductPrice(10);
        userBeans.add(userbeanlog2);

        UserBean userbeanlog3 = new UserBean();
        userbeanlog3.setUserID("userID1");
        userbeanlog3.setProductID("productID5");
        userbeanlog3.setProductPrice(30);
        userBeans.add(userbeanlog3);

        DataStreamSource<UserBean> source = env.fromCollection(userBeans);

        // 转换: KeyBy对数据重分区
        // 这里, UserActionLog是POJO类型,也可通过keyBy("userID")进行分区
        KeyedStream<UserBean, String> keyedStream = source.keyBy(new KeySelector<UserBean, String>() {
            @Override
            public String getKey(UserBean value) throws Exception {
                return value.getUserID();
            }
        });
        //userid1 10 30 userid2 10
        // 转换: Aggregate并输出
        // 滚动求和并输出
        //keyedStream.sum("productPrice").print();
        // 滚动求最大值并输出
     //   keyedStream.max("productPrice").print();
        // 滚动求最大值并输出
      //  keyedStream.maxBy("productPrice").print();
        // 滚动求最小值并输出
        //keyedStream.min("productPrice").print();
        // 滚动求最小值并输出
        //keyedStream.minBy("productPrice").print();

        env.execute("flink aggregate operator");
    }
}

Union


/**
 * Summary:
 *     union: 将多个流合并到一个流中，以便对合并的流进行统一处理，
 *     有点类似于Storm中的将上一级的两个Bolt数据汇聚到这一级同一个Bolt中。注意，合并的流类型需要一致
 */
public class DataStreamUnionOperator {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        DataStream dataStream1=env.fromElements(
                Tuple1.of("flink"),
                Tuple1.of("spark"),
                Tuple1.of("hadoop")
        );
        DataStream dataStream2=env.fromElements(
                Tuple1.of("oracle"),
                Tuple1.of("mysql"),
                Tuple1.of("sqlserver")
        );

        dataStream1.union(dataStream2).print();
        env.execute("flink union operator ");
    }
}
// 输出到控制台
// 3> (flink)
// 4> (spark)
// 4> (mysql)
// 1> (hadoop)
// 1> (sqlserver)
// 3> (oracle)

Split


/**
 * Summary:
 *      split: 根据规则把一个数据流切分成多个流。
 *      split分流，只能一次分流，分流后的流不能继续分流。
 *      （Flink 1.9以前可以输出，但是第二次split将会失效；
 *      Flink 1.9 如果二次split，直接报错并提示使用side-outputs）
 */
public class DataStreamSplitOperator {

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        DataStream<Integer> dataStream=env.fromElements(
                1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
        );
        //定义拆分逻辑
        SplitStream<Integer> split=dataStream.split(new OutputSelector<Integer>() {
            @Override
            public Iterable<String> select(Integer integer) {
                List<String> output=new ArrayList<>();
                if(integer%2==0){
                    //偶数
                    output.add("even");
                }else {
                    //奇数
                    output.add("odd");
                }
                return output;
            }
        });

        //选择一个或多个切分后的流
        DataStream<Integer> evenStream=split.select("even");

//        DataStream<Integer> oddStream=split.select("odd");
//        DataStream<Integer> moreStream =split.select("odd","even");
        evenStream.print().setParallelism(1);
        env.execute("flink split operator");
    }

}
//输出结果
//2
//4
//6
//8
//10
//12
//14
//16
//注意：
//Split...Select...中Split只是对流中的数据打上标记,并没有将流真正拆分。可通过Select算子将流真正拆分出来。
//Split...Select...不能连续分流。即不能Split...Select...Split，但可以如Split...Select...Filter...Split。

Side-Output


/**
 * Summary:
 *     Side-Output: Split...Select...已经过时，推荐使用更灵活的侧路输出(Side-Output)，如下。
 *     Side-Output是从Flink 1.3.0开始提供的功能，支持了更灵活的多路输出，包括使用RichProcessFunction。
 *     Side-Output可以以侧流的形式，以不同于主流的数据类型，向下游输出指定条件的数据、异常数据、迟到数据等等
 */
public class DataStreamSideOperator {

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment();
        DataStream<UserBean> dataStream=env.fromElements(
                new UserBean("userID1", 1293984000, "click",  "productID1", 10),
                new UserBean("userID1", 1293984000, "browse", "productID1", 10),
                new UserBean("userID2", 1292952000, "browse", "productID2", 20),
                new UserBean("userID2", 1243983000, "click",  "productID2", 15),
                new UserBean("userID3", 1293184000, "click",  "productID1", 30)
        );
        //定义OutputTag
        final OutputTag<UserBean> clickTag=new OutputTag<UserBean>("click-Tag", TypeInformation.of(UserBean.class));
        final OutputTag<UserBean> browseTag=new OutputTag<UserBean>("browse-Tag",TypeInformation.of(UserBean.class));

        //在ProcessFunction中处理主流和分流
        SingleOutputStreamOperator<UserBean> processedStream=
                dataStream.process(new ProcessFunction<UserBean, UserBean>() {
                    @Override
                    public void processElement(UserBean userAction, Context context, Collector<UserBean> collector) throws Exception {
                        //测流-只输出特定的数据
                        if(userAction.getEventType().equals("click")){
                            context.output(clickTag,userAction);
                            //主流
                        }else {
                            collector.collect(userAction);
                        }
                    }
                });
        //获取主流
        processedStream.print("主流输出B：");
        //获取测流
        processedStream.getSideOutput(clickTag).print("分流输出A：");

        env.execute("flink Side-Output operator");

    }
}

Reduce


/**
 * Summary:
 *     Reduce: 基于ReduceFunction进行滚动聚合，并向下游算子输出每次滚动聚合后的结果。
 */
public class DataStreamReduceOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserBean> source = env.fromCollection(Arrays.asList(
                new UserBean("userID1", 1293984000, "click", "productID1", 10),
                new UserBean("userID2", 1293984001, "browse", "productID2", 8),
                new UserBean("userID2", 1293984002, "browse", "productID2", 8),
                new UserBean("userID2", 1293984003, "browse", "productID2", 8),
                new UserBean("userID1", 1293984002, "click", "productID1", 10),
                new UserBean("userID1", 1293984003, "click", "productID3", 10),
                new UserBean("userID1", 1293984004, "click", "productID1", 10)
        ));

        // 转换: KeyBy对数据重分区
        KeyedStream<UserBean, String> keyedStream = source.keyBy(new KeySelector<UserBean, String>() {
            @Override
            public String getKey(UserBean value) throws Exception {
                return value.getUserID();
            }
        });

        // 转换: Reduce滚动聚合。这里,滚动聚合每个用户对应的商品总价格。
        SingleOutputStreamOperator<UserBean> result = keyedStream.reduce(new ReduceFunction<UserBean>() {
            @Override
            public UserBean reduce(UserBean value1, UserBean value2) throws Exception {
                int newProductPrice = value1.getProductPrice() + value2.getProductPrice();
                return new UserBean(value1.getUserID(), -1, "", "", newProductPrice);
            }
        });


        result.print();

        env.execute("flink reduce operator");
    }
}
// 输出: 将每次滚动聚合后的结果输出到控制台。
//3> UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=8)
//3> UserAction(userID=userID2, eventTime=-1, eventType=, productID=, productPrice=16)
//3> UserAction(userID=userID2, eventTime=-1, eventType=, productID=, productPrice=24)
//4> UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)
//4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=20)
//4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=30)
//4> UserAction(userID=userID1, eventTime=-1, eventType=, productID=, productPrice=40)

Map


/**
 * Summary:
 *      Map: 一对一转换
 */
public class DataStreamMapOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserBean> source = env.fromCollection(Arrays.asList(
                new UserBean("userID1", 1293984000, "click", "productID1", 10),
                new UserBean("userID2", 1293984001, "browse", "productID2", 8),
                new UserBean("userID1", 1293984002, "click", "productID1", 10)
        ));

        // 转换: 商品的价格乘以8
        SingleOutputStreamOperator<UserBean> result = source.map(new MapFunction<UserBean, UserBean>() {
            @Override
            public UserBean map(UserBean value) throws Exception {

                int newPrice = value.getProductPrice() * 8;
                return new UserBean(value.getUserID(), value.getEventTime(), value.getEventType(), value.getProductID(), newPrice);
            }
        });
        result.print();
        env.execute("flink map operator");
    }
}

// 输出: 输出到控制台
// UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=80)
// UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=80)
// UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=64)

Keyby


/**
 * Summary:
 *      KeyBy: 按指定的Key对数据重分区。将同一Key的数据放到同一个分区。
 */
public class DataStreamKeyByOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserBean> source = env.fromCollection(Arrays.asList(
                new UserBean("userID1", 1293984000, "click", "productID1", 10),
                new UserBean("userID2", 1293984001, "browse", "productID2", 8),
                new UserBean("userID1", 1293984002, "click", "productID1", 10),
                new UserBean("userID3", 1293984002, "click", "productID1", 10),
                new UserBean("userID1", 1293984002, "click", "productID1", 10),
                new UserBean("userID2", 1293984002, "click", "productID1", 10)
        ));

        // 转换: 按指定的Key(这里,用户ID)对数据重分区，将相同Key(用户ID)的数据分到同一个分区
        KeyedStream<UserBean, String> result = source.keyBy(new KeySelector<UserBean, String>() {
            @Override
            public String getKey(UserBean value) throws Exception {
                return value.getUserID();
            }
        });


        result.print().setParallelism(4);
        env.execute("flink keyby operator");
    }
}
// 输出: 输出到控制台
//3> UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)
//3> UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=10)
//2> UserAction(userID=userID2, eventTime=1293984001, eventType=browse, productID=productID2, productPrice=8)

Join


/**
 * Summary:
 *      join: 根据指定的Key将两个流进行关联。
 */
public class DataStreamJoinOperator {
    public static void main(String[] args) throws Exception {
        //1.获取执行环境配置信息
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        //2.定义加载或创建数据源（source）,监听9000端口的socket消息
        DataStream<UserBean> textStream1 = env.fromElements(
                new UserBean("userID1", 1293914003, "browse", "productID2", 8),
                new UserBean("userID1", 1292984002, "click", "productID1", 10),
                new UserBean("userID3", 1293384003, "click", "productID3", 10)
        );
        DataStream<UserBean> textStream2 = env.fromElements(
                new UserBean("userID1", 1293984003, "browse", "productID2", 8),
                new UserBean("userID1", 1293924002, "click", "productID1", 10),
                new UserBean("userID3", 1293914103, "click", "productID1", 10)
        );
        //将输入处理一下，变为tuple2
        DataStream<UserBean> mapStream1=textStream1
                .map(new MapFunction<UserBean, UserBean>() {
                    @Override
                    public UserBean map(UserBean userAction) throws Exception {
                            //userAction.setProductID("mapStream1");
                            return userAction;
                    }
                });

        DataStream<UserBean> mapStream2=textStream2
                .map(new MapFunction<UserBean, UserBean>() {
                    @Override
                    public UserBean map(UserBean userAction) throws Exception {
                        //userAction.setProductID("mapStream2");
                        return userAction;
                    }
                });

        //3.两个流进行join操作，是inner join，关联上的才能保留下来
        DataStream<String> result =  mapStream1.join(mapStream2)
                //关联条件，以第0列关联（两个source输入的字符串）
                .where(t1->t1.getUserID()).equalTo(t2->t2.getUserID())
                //以处理时间，每10秒一个滚动窗口
                .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
                //关联后输出
                .apply((t1,t2)->t1+"|"+t2)
                ;

        //4.打印输出sink
        result.print();
        //5.开始执行
        env.execute();
    }

}

Fold


/**
 * Summary:
 *      Fold: 基于初始值和自定义的FoldFunction滚动折叠后发出新值
 */
public class DataStreamFoldOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserBean> source = env.fromCollection(Arrays.asList(
                new UserBean("userID1", 1293984000, "click", "productID1", 10),
                new UserBean("userID2", 1293984001, "browse", "productID2", 8),
                new UserBean("userID2", 1293984002, "browse", "productID2", 8),
                new UserBean("userID2", 1293984003, "browse", "productID2", 8),
                new UserBean("userID1", 1293984002, "click", "productID1", 10),
                new UserBean("userID1", 1293984003, "click", "productID3", 10),
                new UserBean("userID1", 1293984004, "click", "productID1", 10)
        ));

        // 转换: KeyBy对数据重分区
        KeyedStream<UserBean, String> keyedStream = source.keyBy(new KeySelector<UserBean, String>() {
            @Override
            public String getKey(UserBean value) throws Exception {
                return value.getUserID();
            }
        });

        // 转换: Fold 基于初始值和FoldFunction滚动折叠
        SingleOutputStreamOperator<String> result = keyedStream.fold("浏览的商品及价格:", new FoldFunction<UserBean, String>() {
            @Override
            public String fold(String accumulator, UserBean value) throws Exception {
                if(accumulator.startsWith("userID")){
                    return accumulator + " -> " + value.getProductID()+":"+value.getProductPrice();
                }else {
                    return value.getUserID()+" " +accumulator + " -> " + value.getProductID()+":"+value.getProductPrice();
                }
            }
        });


        result.print();

        env.execute("flink fold operator");

    }
}
// 输出: 输出到控制台
// 每一条数据都会触发计算并输出
// userID1 浏览的商品及价格: -> productID1:10
// userID1 浏览的商品及价格: -> productID1:10 -> productID1:10
// userID1 浏览的商品及价格: -> productID1:10 -> productID1:10 -> productID3:10
// userID1 浏览的商品及价格: -> productID1:10 -> productID1:10 -> productID3:10 -> productID1:10
// userID2 浏览的商品及价格: -> productID2:8
// userID2 浏览的商品及价格: -> productID2:8 -> productID2:8
// userID2 浏览的商品及价格: -> productID2:8 -> productID2:8 -> productID2:8

FlatMap

/**
 * Summary:
 *      FlatMap: 一行变任意行(0~多行)
 */
public class DataStreamFlatMapOperator {
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 英文电影台词
        DataStreamSource<String> source = env
                .fromElements(
                        "You jump I jump",
                        "Life was like a box of chocolates"
                );

        // 转换: 将包含chocolates的句子转换为每行一个单词
        SingleOutputStreamOperator<String> result = source.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                if(value.contains("chocolates")){
                    String[] words = value.split(" ");
                    for (String word : words) {
                        out.collect(word);
                    }
                }
            }
        });
        result.print();
        env.execute("flink flatmap operator");
    }
}
// 输出: 输出到控制台
// Life
// was
// like
// a
// box
// of
// chocolates

Fliter


/**
 * Summary:
 *      Fliter: 过滤出需要的数据
 */
public class DataStreamFilterOperator {
    public static void main(String[] args) throws Exception{

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 输入: 用户行为。某个用户在某个时刻点击或浏览了某个商品，以及商品的价格。
        DataStreamSource<UserBean> source = env.fromCollection(Arrays.asList(
                new UserBean("userID1", 1293984000, "click", "productID1", 10),
                new UserBean("userID2", 1293984001, "browse", "productID2", 8),
                new UserBean("userID1", 1293984002, "click", "productID1", 10)
        ));

        // 过滤: 过滤出用户ID为userID1的用户行为
        SingleOutputStreamOperator<UserBean> result = source.filter(new FilterFunction<UserBean>() {
            @Override
            public boolean filter(UserBean value) throws Exception {
                return value.getUserID().equals("userID1");
            }
        });
        result.print();
        env.execute("flink filter operator");

    }
}
// 输出: 输出到控制台
// UserAction(userID=userID1, eventTime=1293984002, eventType=click, productID=productID1, productPrice=10)
// UserAction(userID=userID1, eventTime=1293984000, eventType=click, productID=productID1, productPrice=10)

心得

更多算子请关注flink官网

二峰✔
关注
专栏目录
flink中split与select操作
congge_study的博客
01-13 3114
flink中split与select操作
【大数据】Flink CDC 实时同步mysql数据
最新发布
congge
10-07 8438
Flink CDC 实时同步mysql数据
Flink转换算子之分流(Split/Side)
lixinkuan的博客
06-07 3559
一、分流(Split/Side) 分流可以将一个流拆分成多个流。基于Split...Select... package com.lxk.test; import org.apache.flink.api.java.tuple.Tuple3; import org.apache.flink.streaming.api.collector.selector.OutputSelector; import org.apache.flink.streaming.api.datastream.DataStrea
Flink 系例 之 Split
不会飞的小龙人的博客
11-22 989
Split算子：将数据流切分成多个数据流（已过时，并且不能二次切分，不建议使用） 示例环境 java.version: 1.8.x flink.version: 1.11.1 示例数据源（项目码云下载） Flink 系例 之 搭建开发环境与数据 Split.java package com.flink.examples.functions; import com.flink.examples.DataSource; import org.apache.flink.api.common..
Flink入门第五课：Flink的分流合流算子&重分区算子
曹利荣的博客
08-12 580
package com.atguigu.Adatastream_api.transformations; import com.atguigu.Fbeans.SensorReading; import org.apache.flink.api.common.functions.RichMapFunction; import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.api.java.tuple.Tuple3; impo.
硬核！一文学完Flink流计算常用算子（Flink算子大全）
wangxi06的专栏
03-12 3298
Flink和Spark类似，也是一种一站式处理的框架；既可以进行批处理（DataSet），也可以进行实时处理（DataStream）。 所以下面将Flink的算子分为两大类：一类是DataSet，一类是DataStream。 DataSet 一、Source算子 1. fromCollection fromCollection：从本地集合读取数据 例： valenv=ExecutionEnvironment.getExecutionEnvironment valtextDataSet...
Apache-Flink-Computations-over-Data-Streams.pdf
03-11
并行度在Flink中指的是任务或者算子链在集群中的执行副本数量。通过设置合理的并行度，可以优化资源的使用和任务的负载均衡。Flink提供了灵活的并行度设置机制，使得开发者可以根据作业的特性和集群的规模来调整并行...
Flink处理函数实战之一：深入了解ProcessFunction的状态(Flink-1
2401_83916355的博客
04-23 623
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
深度探索 Flink SQL
hhhhhhfq的博客
04-26 2554
文章将从用户的角度来讲解 Flink 1.9 版本中 SQL 相关原理及部分功能变更，希望加深大家对 Flink 1.9 新功能的理解，在使用上能够有所帮助。 新 TableEnvironment FLIP-32 中提出，将 Blink 完全开源，合并到 Flink 主分支中。合并后在 Flink 1.9 中会存在两个 Planner：Flink Planner 和 Blink Planner。 在之前的版本中，Flink Table 在整个 Flink 中是一个二等公民。而 Flink SQL 具备的易用
flink实战--StreamGraph，JobGraph，ExecutionGraph生成流程解析
阿华田的博客
03-26 803
简介 Flink在执行用户的任务时，会涉及到StreamGraph，JobGraph，ExecutionGraph，物理执行图。其中StreamGraph和JobGraph是在client端生成的，ExecutionGraph是在JobMaster中执行的，本文将详细介绍这些Graph的生成流程，方便大家对Flink内部执行流程有一个清晰的认识。 StreamGraph是根据用户代码生成的最原始执行图，也就是直接翻译用户逻辑得到的图 JobGraph是对StreamGraph进行优化.....
Flink代码之数据源，算子，分流，富函数(一)
YellowXiuHui的博客
06-18 557
1.wordCout
flink之split算子分流过期及替代方法（案例）——使用flink读取数组，并将数组中的数字按照奇数偶数分流
alisa_Ge的博客
04-05 1107
1.新建一个maven工程——myflink. 2.导入pom.xml相关依赖。 <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</m
Flink Chain任务链分隔
jast
07-06 1311
由于共享slot的存在，当一个任务链的计算量特别庞大时，且只在一个slot上执行，对于slot的压力过大，需要拆开。1）disableChaining：如果对一个算子使用了disableChaining（取消任务链），那么该算子就会与前后算子隔离开，不参与任务链的组合，独用一个slot。2）startNewChain：如果一个任务链只是过于庞大，但是算子之间的操作简单，仅想拆开为2个任务链，并且参与任务链组合，就需要对算子使用startNewChain(开启一个新的任务链)，意思就是之前该怎么合并就怎么合并
Flink 从0到1学习—— Flink 不可以连续 Split(分流)？
http://www.54tianzhisheng.cn/
06-13 2206
前言 今天上午被 Flink 的一个算子困惑了下，具体问题是什么呢？ 我有这么个需求：有不同种类型的告警数据流(包含恢复数据)，然后我要将这些数据流做一个拆分，拆分后的话，每种告警里面的数据又想将告警数据和恢复数据拆分出来。 结果，这个需求用 Flink 的 Split 运算符出现了问题。 分析 需求如下图所示： 我是期望如上这样将数据流进行拆分的，最后将每种告警和恢复用不同的消息模版做一个渲染...
Flink---分流
shall潇の菜园
07-06 518
Flink中将一个流拆分成多个流的方法有两个：split(已过时)，process（推荐） 文章目录splitprocess split package Flink.transform; import Flink.beans.SensorReading; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.common.functions.RichMapFunction; impor.
flink当中的打标签过滤函数split
weixin_45896475的博客
03-03 1485
flink当中的打标签过滤函数splik 当我们在运行flink的时候经常会遇到数据的过滤,在flink当中我们经常遇到过滤出某中数据类型或者将数据打好标签分类,实时运算,今天我们就聊聊flink当中的split select算子函数 public class SplitDemo { public static void main(String[] args) throws Excepti...
Flink--Split和select
05-22 730
Split就是将一个DataStream分成两个或者多个DataStream Select就是获取分流后对应的数据 val env = StreamExecutionEnvironment.getExecutionEnvironment env.setParallelism(1) val elements: DataStream[Int] = env.fromElemen...
Flink 算子map、split、union、select
qq_15009447的博客
06-29 211
package _20210628 import java.util.{Collections, Properties} import org.apache.flink.api.common.serialization.SimpleStringSchema import org.apache.flink.streaming.api.scala.{ConnectedStreams, DataStream, KeyedStream, StreamExecutionEnvironment} import org
flink学习笔记-split & select(拆分流)
weixin_30732825的博客
03-29 990
说明：本文为《Flink大数据项目实战》学习笔记，想通过视频系统学习Flink这个最火爆的大数据计算框架的同学，推荐学习课程： Flink大数据项目实战：http://t.cn/EJtKhaz split 1.DataStream → SplitStream 2.按照指定标准将指定的DataStream拆分成多个流用SplitStream来表示 ...
flink-sql-connector 和flink-connector 区别
05-17
Flink-SQL-Connector 和 Flink-Connector 都是 Apache Flink 的连接器，但它们的主要区别在于用途和功能。 Flink-SQL-Connector 是为了支持 Flink SQL 而开发的一组连接器，它们包括 JDBC、Elasticsearch、Kafka、HBase、JMS、Cassandra、Hive 和 MySQL 等。这些连接器可以将 Flink SQL 的查询结果发送到特定的数据源中，或从特定的数据源中读取数据并用于 Flink SQL 查询。因此，Flink-SQL-Connector 的主要用途是支持 Flink SQL 查询操作。 Flink-Connector 则是一个更通用的连接器框架，它提供了一种通用的方式来与外部系统进行交互，例如读写文件、消息队列、数据库、NoSQL 数据库、流处理引擎等。Flink-Connector 提供了一组接口和类来支持开发者编写自定义的连接器，以便与其他系统集成。因此，Flink-Connector 的主要用途是支持 Flink 与其他系统的交互操作，而不仅仅是支持 Flink SQL 查询操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值