Flink-常用转换算子、自定义函数以及分区策略

已于 2022-11-18 13:16:09 修改
阅读量636 收藏 4
点赞数
文章标签： flink java 大数据
于 2022-11-17 23:43:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46507516/article/details/127914313
版权

5.4 转换算子

5.4.1 map(映射)

  1. 静态内部类实现接口
public class TransfromMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //从元素读取数据
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice","./prod?id=100",3000L));
        //进行转换计算，提取user字段
        SingleOutputStreamOperator<String> result = stream.map(new MyMapper());
        result.print();
​
        env.execute();
    }
    //自定义MapFunction接口
    //1.使用自定义静态内部类实现接口
    public static class MyMapper implements MapFunction<Event,String>{
​
        @Override
        public String map(Event value) throws Exception {
            return value.user;
        }
    }
}
​
  1. 匿名类实现
        //2.使用匿名类实现MapFunction接口
        SingleOutputStreamOperator<String> result2 = stream.map(new MapFunction<Event, String>() {
            @Override
            public String map(Event value) throws Exception {
                return value.user;
            }
        });
  1. lambda表达式

一步到位

        //3.传入lambda表达式
        SingleOutputStreamOperator<String> result3 = stream.map(data -> data.user);

5.4.2 过滤filter

  1. 静态内部类实现接口
public class TransformFilterTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //从元素读取数据
        //1.使用自定义静态内部类实现接口
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice","./prod?id=100",3000L));
​
​
        SingleOutputStreamOperator<Event> result1 = stream.filter(new MyFilter());
​
​
        });
​
        result1.print();
        env.execute();
    }
​
    public static class MyFilter implements FilterFunction<Event>{
​
        @Override
        public boolean filter(Event value) throws Exception {
            return value.user.equals("Mary");
        }
    }
}
  1. 匿名类实现
​
        SingleOutputStreamOperator<Event> result2 = stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event value) throws Exception {
                return value.user.equals("Mary");
            }
  1. lambda表达式
        SingleOutputStreamOperator<Event> result3 = stream.filter(data -> data.user.equals("Mary"));

5.4.3 flatmap(扁平映射)

一对多

  1. 静态内部类实现接口
public class TransformFlatMapTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        //从元素读取数据
        //1.使用自定义静态内部类实现接口
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice","./prod?id=100",3000L));
​
        stream.flatMap(new MyFlatMap()).print();
        env.execute();
​
    }
​
    public static class MyFlatMap implements FlatMapFunction<Event,String>{
​
        @Override
        //返回是用户collector收集器的collect方法收集
        //如果不掉输出的，也可以实现filter的功能
        public void flatMap(Event value, Collector<String> out) throws Exception {
            out.collect(value.user);
            out.collect(value.url);
            out.collect(value.timestamp.toString());
​
        }
    }
}
  1. 匿名类实现

略

  1. lambda表达式
        stream.flatMap((Event value,Collector<String> out) -> {
            if(value.user.equals("Mary")){
                out.collect(value.url);
            }else if(value.user.equals("Bob")){
                out.collect(value.user);
                out.collect(value.url);
                out.collect(value.timestamp.toString());
            }
        }).returns(new TypeHint<String>() {})//需要泛型返回
            .print();
        env.execute();

5.4.4 keyby逻辑分区

  1. 分析
    在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

严格来说不是算子，没有返回SingleOutputStreamOperator类(继承DataStream)，而是仅仅追加了key的逻辑分区，返回的是keyedstream键控流，只有keyedstream类才有sum，max,reduce方法在进行聚合操作

  1. 简单聚合算子使用
public class TransformSingleAggTest {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
​
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice","./prod?id=100",3000L),
                new Event("Bob","./prod?id=1",3300L),
                new Event("Bob", "./home", 3500L),
                new Event("Alice","./prod?id=200",3000L),
                new Event("Bob","./prod?id=2",3800L),
                new Event("Bob","./prod?id=3",4200L));
​
        //按键分组之后进行聚合，提取当前用户最近一次访问数据
        stream.keyBy(new KeySelector<Event, String>() {
            @Override
            public String getKey(Event value) throws Exception {
                return value.user;
            }
        }).max("timestamp")
                .print("max:");
​
        //maxby
        stream.keyBy(data->data.user)
                .maxBy("timestamp")
                .print("maxBy:");
​
        env.execute();
    }
}

max和maxby的区别，max仅仅针对我们定义的字段去截取最大值，其他的字段采用第一条，maxby是全部字段跟着最大值字段更改

在这里插入图片描述

  1. 归约聚合reduce

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

把集合每一个数据拿出来，然后按照一定的规则不停的规约，最终得到一个唯一规约聚合后的结果

  • 访问量最多的用户
public class TransformReduceTest{
    public static void main(String[] args) throws Exception  {
​
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
​
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Bob", "./prod?id=1", 3300L),
                new Event("Alice", "./prod?id=200", 3000L),
                new Event("Bob", "./home", 3500L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L));
​
        //计算访问量最大的数据，先计算访问量，后求max
        //1.统计每个用户的访问频次
        SingleOutputStreamOperator<Tuple2<String, Long>> clicksByUser = stream.map(new MapFunction<Event, Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> map(Event value) throws Exception {
                        return Tuple2.of(value.user, 1L);
                    }
                }).keyBy(data -> data.f0)
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    //values是累计的数据，values2是1
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> values1, Tuple2<String, Long> values2) throws Exception {
                        return Tuple2.of(values1.f0, values1.f1 + values2.f1);
                    }
                });
​
        //2.选取当前最活跃的用户
        //所有数据都分配到相同的一个key，也就会分配到一个分区
        SingleOutputStreamOperator<Tuple2<String, Long>> result = clicksByUser.keyBy(data -> "key")
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        return value1.f1 > value2.f1 ? value1 : value2;
                    }
                });
        result.print();
        env.execute();
    }
}
  • 结果
(Mary,1)
(Bob,1)
(Alice,1)
(Bob,2)
(Alice,2)
(Bob,3)
(Bob,4)
(Bob,5)

5.4.5 用户自定义函数

  1. 富函数类

在这里插入图片描述

RichMapFunction是一个抽象类，继承自AbstractRichFunction抽象富函数类，同时实现了MapFunction接口

并且有抽象的map方法

  1. 代码
public class TransformRichFunctionTest {
    public static void main(String[] args) throws Exception{
​
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
​
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Bob", "./prod?id=1", 3300L),
                new Event("Alice", "./prod?id=200", 3000L),
                new Event("Bob", "./home", 3500L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L));
​
        stream.map(new MyRichMapper()).setParallelism(2).print();
        env.execute();
​
    }
​
    //实现一个自定义的富函数类
    //RichMapFunction是抽象类
    public static class MyRichMapper extends RichMapFunction<Event,Integer>{
​
        //继承AbstractRichFunction抽象富函数类的声明周期方法
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            //可以自定义状态，使得可以进行聚合功能的使用
            //这边获取子任务的索引号
            System.out.println("open声明周期被调用"+getRuntimeContext().getIndexOfThisSubtask()+"号任务启动");
        }
​
        //RichMapFunction抽象类的map
        @Override
        public Integer map(Event value) throws Exception {
            return value.url.length();
        }
​
        @Override
        public void close() throws Exception {
            super.close();
            System.out.println("close声明周期被调用"+getRuntimeContext().getIndexOfThisSubtask()+"号任务启动");
        }
    }
}
  1. 结果
open声明周期被调用0号任务启动
open声明周期被调用1号任务启动
close声明周期被调用0号任务启动
close声明周期被调用1号任务启动
6
13
13
11

5.4.6 物理分区

与keyby不同的是，可以制定分区策略

  1. shuffle随机分区
  • 代码
public class TransformPartitionTest {
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
​
        DataStreamSource<Event> stream = env.fromElements(new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Bob", "./prod?id=1", 3300L),
                new Event("Alice", "./prod?id=200", 3000L),
                new Event("Bob", "./home", 3500L),
                new Event("Bob", "./prod?id=2", 3800L),
                new Event("Bob", "./prod?id=3", 4200L));
​
        stream.shuffle().print().setParallelism(4);
        env.execute();
    }
}
  • 结果
1> Event{user='Alice', url='./prod?id=100', timestamp=1970-01-01 08:00:03.0}
4> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
2> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
3> Event{user='Bob', url='./prod?id=1', timestamp=1970-01-01 08:00:03.3}
2> Event{user='Bob', url='./home', timestamp=1970-01-01 08:00:03.5}
4> Event{user='Bob', url='./prod?id=3', timestamp=1970-01-01 08:00:04.2}
1> Event{user='Alice', url='./prod?id=200', timestamp=1970-01-01 08:00:03.0}
2> Event{user='Bob', url='./prod?id=2', timestamp=1970-01-01 08:00:03.8}
​
Process finished with exit code 0
​
  1. 轮询分区
        //2.轮询分区
        stream.rebalance().print().setParallelism(4);
        env.execute();
  • 结果
2> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
1> Event{user='Bob', url='./prod?id=1', timestamp=1970-01-01 08:00:03.3}
3> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
1> Event{user='Bob', url='./prod?id=3', timestamp=1970-01-01 08:00:04.2}
4> Event{user='Alice', url='./prod?id=100', timestamp=1970-01-01 08:00:03.0}
3> Event{user='Bob', url='./home', timestamp=1970-01-01 08:00:03.5}
2> Event{user='Alice', url='./prod?id=200', timestamp=1970-01-01 08:00:03.0}
4> Event{user='Bob', url='./prod?id=2', timestamp=1970-01-01 08:00:03.8}
  1. rescale重缩放分区

跟rebalance区别是按照自己小组分区

目的是为了减少网络传输损耗，减少资源

  • 代码
    //3.rescale重缩放分区
        //DataSource并行度为1，因此重新创建自定义Source,运行上下文富函数类,可以获取运行时的上下文
        env.addSource(new RichParallelSourceFunction<Integer>() {
​
            @Override
            public void run(SourceContext<Integer> ctx) throws Exception {
                for(int i =1 ;i<=8;i++){
                    //将奇数偶数发送到0号和1号并行分区
                    if(i%2== getRuntimeContext().getIndexOfThisSubtask()){
                        ctx.collect(i);
                    }
                }
            }
​
            @Override
            public void cancel() {
​
            }
        }).setParallelism(2)
                .rescale()
                .print()
                .setParallelism(4);
        env.execute();
  • 结果
2> 4
1> 2
3> 1
3> 5
4> 3
1> 6
2> 8
4> 7
​
Process finished with exit code 0
1,3,5,7对应输出的是3，4的分区
2，4，6，8对应输出的是1，2分区
  • 如果是rebalance的话，就是1，3，5，7是1，2，3，4完全轮询分区
        env.addSource(new RichParallelSourceFunction<Integer>() {
​
            @Override
            public void run(SourceContext<Integer> ctx) throws Exception {
                for(int i =1 ;i<=8;i++){
                    //将奇数偶数发送到0号和1号并行分区
                    if(i%2== getRuntimeContext().getIndexOfThisSubtask()){
                        ctx.collect(i);
                    }
                }
            }
​
            @Override
            public void cancel() {
​
            }
        }).setParallelism(2)
                .rebalance()
                .print()
                .setParallelism(4);
        env.execute();
    }
}
  • 结果
3> 6
1> 2
2> 4
4> 8
3> 5
4> 7
2> 3
1> 1
  1. 广播分区
  • 概念

一个数据分发到所有并行子任务上

  • 代码
        stream.broadcast().print().setParallelism(4);
  • 结果
1> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
4> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
3> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
2> Event{user='Mary', url='./home', timestamp=1970-01-01 08:00:01.0}
3> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
4> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
1> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
2> Event{user='Bob', url='./cart', timestamp=1970-01-01 08:00:02.0}
​
一条数据四个分区全部并行输出
  1. 全局分区
  • 概念

把所有数据分配到一个子任务上

  • 代码
        //5.全局分区
        stream.global().print().setParallelism(4);
  • 注意

会造成系统压力

  1. 自定义重分区
  • 代码
//6.自定义重分区
        env.fromElements(1,2,3,4,5,6,7,8)
                        //传入分区器Partitioner和keyselector(类比keyby了)
                        .partitionCustom(new Partitioner<Integer>() {
                            @Override
                            //返回的int0或者1就表示了物理分区的索引号
                            //指定当前分区策略，只有第一个和第二个分区会输出信息 
                            public int partition(Integer key, int numPartitions) {
                                return key%2;
                            }
​
                            //Integer输入，Integer输出
                        }, new KeySelector<Integer, Integer>() {
​
                            @Override
                            public Integer getKey(Integer value) throws Exception {
                                //按照value数字分组
                                return value;
                            }
                        })
                        .print().setParallelism(4);
​
​
        env.execute();
  • 结果
1> 2
1> 4
2> 1
1> 6
2> 3
1> 8
2> 5
2> 7
​
Process finished with exit code 0
 //指定当前分区策略，只有第一个和第二个分区会输出信息
:Concerto
关注
flink 自定义Partition分区
weixin_39150719的博客
09-19 6886
自己定义一个分区类，需要自己实现一个Partitione接口 ！（泛型最好写上） import org.apache.flink.api.common.functions.Partitioner public class MyPartition implements Partitioner<Long> { public int partition(Long key, int n...
三、Flink常用的转换算子
weixin_43857464的博客
12-04 1081
Flink常用转换算子常用转换算子类型一、基本转换算子1、map2、filter3、flatMap二、键控流转换算子1、keyBy：分组聚合，类似spark的groupByKey算子，将相同的key存到同一个分区中。2、 滚动聚合算子：由KeyedStream对象来调用，也就是需要用在keyBy之后。三、多流转换算子1、union：将多条流数据合并到一条流中2、connect：将两条流数据合并到一条流中三、分布式转换算子1、随机将数据打散到不同的分区（Random）2、轮询的将数据分配到不同的分区（Roun
Flink 1.17教程：自定义分区（Custom）
学亮编程手记
09-07 665
当Flink提供的所有分区策略都不能满足用户的需求时，我们可以通过使用partitionCustom()方法来自定义分区策略。1）自定义分区器@Override2）使用自定义分区。
Flink中如何实现自定义的分区策略？
qq_33240556的博客
10-29 366
在 Apache Flink 中，可以通过自定义分区策略来控制数据是如何在各个算子实例之间分布的。这对于优化性能和实现特定的业务逻辑非常重要。
Flink 自定义源算子
GX_0824的博客
10-04 643
/若想要并行处理，需要实现一个ParallelSourceFunction（自定义源算子继承ParallelSourceFunction），算子并行度才可以设置多个。//ParallelSourceFunction[Event] 算子可以设置并行度。//SourceFunction[Event] 并行度必须是 1。//用标志位作为循环判断条件，不停的发送数据。//调用ctx的方法向下游发送数据。//随机生成一个event。//每隔1秒发送一条数据。//读取自定义数据源。
【Flink】Flink的分区策略及源码分析
追赶者的博客
11-30 1084
一：Flink的分区策略 在Flink的应用中，每个算子都可以设置并行度，比如上游的Map算子的并行度为3，而下游filter的算子并行度为4，那当上下游算子并行度不一致的情况下， flink怎么传递数据呢，这就涉及到Flink的分区策略 二：Flink的分区关键类源码分析 Flink 中分区策略中有一个抽象类StreamPartitioner，源码如下： public abstract class StreamPartitioner<T> implements Chan...
Flink常用转换算子和自定义函数
Cxw1994的博客
08-26 1059
  本篇文章主要介绍Flink中的常见转换算子、自定义函数和窗口函数 一、转换算子 1.单流输入 val env = StreamExecutionEnvironment.getExecutionEnvironment 1.1.map、filter：对流中的每个元素进行操作 env.fromElements(1,2,3,4,5,6) .map(_*10) .print() env.fromElements(1,2,3,4,5,6) .filter(_&
flink:自定义数据分区
amadeus_liu2的博客
03-05 1000
rebalance用round robbin模式将数据分配到下游的子任务。partitionCustom: 自定义数据分区。shuffle随机地将数据分配到下游的子任务。global把所有的数据都分配到一个分区。
【Flink】基本转换算子使用之fliter、flatMap，键控流转换算子和分布式转换算子
weixin_43923463的博客
11-25 1706
针对每一个输入事件，算子将会更新保存的聚合结果，并发送一个带有更新后的值的事件到下游算子。那么使用递归又带来了一个问题，递归的栈会超过内存，造成内存溢出Stack Overflow，那么伪递归用新来的栈去覆盖原有的栈，栈的深度不变，所以可以使用伪递归来模拟循环，伪递归当中有累加器的存在。总结：滚动聚合的要点在于每一个Key都有自己的累加器（状态变量），一条数据来到处理完成之后就丢弃了，向下游发送的数据是累加器中的数据，这样就不需要将所有的数据都保存下来，节省内存空间，性能高于批处理。
flink-10 DataSet算子
a3125504x的博客
09-21 412
dataset转换算子常见的DataSet转换算子算子mapPartitiondistinct链接操作joinleftOuterJoin、rightOuterJoincrossfirst-N和sortPartitionpartition官网地址 常见的DataSet转换算子算子 Map 输入一个元素，然后返回一个元素，中间可以做一些清洗转换等操作 FlatMap 输入一个元素，可以返回零个，一个或者多个元素 MapPartition 类似map，一次处理一个分区的数据【如果在进行map
Flink源算子、转换算子和输出算子（DataSet）
roi666的博客
01-23 1554
但是，压缩文件可能不会并行读取，可能是顺序读取的，这样可能会影响作业的可伸缩性。Flink是一种一站式处理的框架，既可以进行批处理（DataSet），也可以进行流处理（DataStream）rightOuterJoin：右外连接,左边的Dataset中的每一个元素，去连接左边的元素。交叉操作，通过形成这个数据集和其他数据集的笛卡尔积，创建一个新的数据集。对一个文件目录内的所有文件，包括所有子目录中的所有文件的遍历访问方式。左外连接,左边的Dataset中的每一个元素，去连接右边的元素。
Flink的自定义函数与有状态函数的实现
weixin_41062002的博客
05-28 1630
概述
Flink DataStream 八大分区策略与自定义分区器
热门推荐
王佩的CSDN博客
09-08 1万+
分区策略决定了一条数据如何发送给下游。Flink中默认提供了八大分区策略(也叫分区器)。 本文基于Flink 1.9.0总结Flink DataStream中的八大分区策略以及手动实现一个自定义分区器。 八大分区策略继承关系图 ChannelSelector: 接口，决定将记录写入哪个Channel。有3个方法: void setup(int numberOfChannels): 初始化输...
Flink学习6-自定义分区器介绍
qq_40342691的博客
11-17 1991
自定义分区器介绍
学习flink-1.14 自定义分区
weixin_41247759的博客
04-23 2243
flink-1.14自定义分区前言
Flink 动态加载 Jar 包，实现自定义算子加载执行
zx711166的博客
12-30 2477
Flink 动态加载 Jar 包，实现自定义算子加载执行动态加载Jar动态Jar调用方式 动态加载Jar 对应的参数： path：Jar 的存放路径。 env：Flink 的环境实例。 classPath：动态Jar的类路径。 import java.lang.reflect.Field; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; import java.util.Array
Flink基础概念及算子
m0_57697768的博客
06-08 3761
无界数据流例如从Kafka这样的消息组件中读取的数据一般，没有数据流结束的定义，即使没有数据也在进行消费。有界数据流有界数据流能够等到所有数据都提取之后再进行处理。有状态流处理将数据的中间状态进行存储，能够重复使用该状态进行处理。Flink的特点Flink计算模型流计算微批处理时间语义事件时间、处理时间处理时间窗口多、灵活少、不灵活（窗口必须是批次的整数倍）状态有没有流式SQL有没有Flink分层API//todo Watersensor Pojo对象。
Apache Flink 零基础入门（八）Flink中指定算子的方式
chikoucha6215的博客
08-29 398
我们之前在使用flatMap时，传了一个new FlatMapFunction匿名内部类。而这仅仅是其中的一种方式。 方式一：实现MapFunction接口 最简单的方式就是实现一个MapFunction接口，例如： text.flatMap(new MyFlatMapFunction...
flink算子使用
qq_45255036的博客
04-07 429
一.flink读取数据的几种方式 1.1读取本地文件 // 创建批处理的执行环境 val env: ExecutionEnvironment = ExecutionEnvironment.getExecutionEnvironment // 从文件读取数据 val inputDataSet: DataSet[String] = env.readTextFile("inp...
利用flink来写源算子自定义算子clicksource的案例代码
最新发布
11-19
Apache Flink是一个用于处理无界和有界数据流的开源分布式计算框架。要编写一个自定义源算子（Source Operator），比如`ClickSource`，你需要创建一个新的`SourceFunction`。这里是一个简单的例子，假设我们有一个模拟点击流的数据源： ```java import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; public class ClickSourceExample { public static void main(String[] args) throws Exception { // 创建流处理环境 final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); // 模拟点击流数据源 DataStream<String> clickStream = env.addSource(new ClickSource()); // 对点击流进行处理（例如：分词、统计等） DataStream<Tuple2<String, Integer>> wordCount = clickStream .flatMap(new WordSplitter()) .keyBy(0) .sum(1); // 打印结果 wordCount.print(); // 开始执行任务 env.execute("Click Source Example"); } // 自定义源函数 - ClickSource private static class ClickSource extends RichParallelSourceFunction<String> { private boolean isRunning = true; @Override public void run(SourceContext<String> ctx) throws Exception { while (isRunning) { String clickEvent = generateClickEvent(); // 这里需要替换为实际生成点击事件的逻辑 ctx.collect(clickEvent); Thread.sleep(1000); // 假设每秒产生一次点击 } } @Override public void cancel() { isRunning = false; } // 你可以添加更多的辅助方法，如生成点击事件的逻辑 private String generateClickEvent() { // 这里只是一个示例，真实情况可能从文件、网络或其他地方读取 return "User " + UUID.randomUUID().toString() + " clicked on item 'item1'"; } } // 分词算子 private static class WordSplitter implements FlatMapFunction<String, Tuple2<String, Integer>> { @Override public void flatMap(String value, Collector<Tuple2<String, Integer>> out) { // 这里对字符串进行分词并统计每个单词出现的次数 for (String word : value.split("\\s+")) { out.collect(new Tuple2<>(word, 1)); } } } } ``` 在这个例子中，`ClickSource`模拟了一个点击事件流，并通过`WordSplitter`将每个点击事件拆分成单词并计数。记得根据实际需求修改数据生成逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值