Flink API - State

最新推荐文章于 2024-12-25 10:26:59 发布
最新推荐文章于 2024-12-25 10:26:59 发布
阅读量180 收藏
点赞数
分类专栏： flink 文章标签： flink java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44760145/article/details/129272408
版权

文章目录


Flink 有两种状态，键控状态（keyed state）和操作符状态（operator state）。我们重点来看一下键控状态。我们来看一下如何在 RuntimeContext 中定义键控状态。
自定义函数可以使用 keyed state 来存储和访问 key 对应的状态。对于每一个 key，Flink 将会维护一个状态实例。一个操作符的状态实例将会被分发到操作符的所有并行任务中去。这表明函数的每一个并行任务只为所有 key 的某一部分 key 保存 key 对应的状态实例。所以 keyed state 和分布式 key-value map 数据结构非常类似。
keyed state 仅可用于 KeyedStream。Flink 支持以下数据类型的状态变量：
● ValueState 保存单个的值，值的类型为 T。
○ get 操作: ValueState.value()
○ set 操作: ValueState.update(T value)
● ListState 保存一个列表，列表里的元素的数据类型为 T。基本操作如下：
○ ListState.add(T value)
○ ListState.addAll(List values)
○ ListState.get()返回Iterable
○ ListState.update(List values)
● MapState<K, V> 保存 Key-Value 对。
○ MapState.get(K key)
○ MapState.put(K key, V value)
○ MapState.contains(K key)
○ MapState.remove(K key)
● ReducingState
● AggregatingState<I, O>
不同key对应的keyed state是相互隔离的

ValueState

public class ValueStates {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);


        env
                .addSource(new ClickSource())
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy.<Event>forMonotonousTimestamps()
                                .withTimestampAssigner((Event element, long recordTimestamp) -> element.timestamp)
                )
                .keyBy(event -> event.user)
                .process(

                        // 每隔 10s 统计一下 pv
                        new KeyedProcessFunction<String, Event, String>() {

                            private ValueState<Long> pvState;
                            private ValueState<Long> timerTs;

                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);


                                StateTtlConfig ttlConfig = StateTtlConfig
                                        // ttl 10s
                                        .newBuilder(Time.seconds(10))
                                        // 仅在创建和写入时更新
                                        .setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite)
                                        // 不返回过期数据
                                        .setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired)
                                        .disableCleanupInBackground()
                                        .build();

                                ValueStateDescriptor<Long> pvStateDescriptor = new ValueStateDescriptor<>("pv", Types.LONG);
                                pvStateDescriptor.enableTimeToLive(ttlConfig);
                                pvState = getRuntimeContext().getState(pvStateDescriptor);




                                timerTs = getRuntimeContext().getState(new ValueStateDescriptor<Long>("timer-ts", Types.LONG));
                            }

                            @Override
                            public void processElement(Event value, Context ctx, Collector<String> out) throws Exception {

                                if (pvState.value() == null) {
                                    pvState.update(1L);
                                } else {
                                    pvState.update(pvState.value() + 1);
                                }

                                if (timerTs.value() == null) {
                                    timerTs.update(value.timestamp + 5 * 1000L);
                                    ctx.timerService().registerEventTimeTimer(value.timestamp + 5 * 1000L);
                                }

                            }

                            @Override
                            public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
                                super.onTimer(timestamp, ctx, out);
                                out.collect("key = " + ctx.getCurrentKey() + " 5s pv = " + pvState.value());
                                timerTs.clear();
                            }
                        })
                .print();


        env.execute();


    }

}

ListStates

public class ListStates {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);


        // 使用 ListState 实现 sliding countWindow

        env
                .addSource(new ClickSource())
                .assignTimestampsAndWatermarks(WatermarkStrategy.forMonotonousTimestamps())
                .keyBy(e -> true)
                .process(
                        new KeyedProcessFunction<Boolean, Event, String>() {

                            private ListState<Event> windowAllElement;

                            private final Integer COUNT = 50;
                            private final Integer SLIDE = 20;


                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);
                                windowAllElement = getRuntimeContext().getListState(new ListStateDescriptor<Event>("window-all-element", Types.POJO(Event.class)));
                            }

                            @Override
                            public void processElement(Event value, Context ctx, Collector<String> out) throws Exception {

                                windowAllElement.add(value);

                                long count = windowAllElement.get().spliterator().getExactSizeIfKnown();

                                if (count % SLIDE == 0) {
                                    ctx.timerService().registerProcessingTimeTimer(ctx.timerService().currentProcessingTime() + 1L);
                                }

                                if (count == COUNT) {

                                    ctx.timerService().registerProcessingTimeTimer(ctx.timerService().currentProcessingTime() + 1L);

                                }

                            }


                            @Override
                            public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
                                super.onTimer(timestamp, ctx, out);

                                long count = windowAllElement.get().spliterator().getExactSizeIfKnown();
                                if (count % SLIDE == 0) {


                                    // 20
                                    out.collect("20 - > 窗口中有 --> 1 " + count + " 条数据");

                                    if (count > COUNT) {

                                        // 移除多余的元素

                                        int evictorCount = 0;

                                        for (Iterator<Event> iterator = windowAllElement.get().iterator(); iterator.hasNext(); ) {

                                            Event next = iterator.next();
                                            evictorCount++;

                                            if (evictorCount > count - COUNT) {
                                                break;
                                            } else {
                                                System.out.println("remove: " + next);
                                                iterator.remove();
                                            }

                                        }


                                    }


                                    out.collect("20 - > 窗口中有 --> 1 " + windowAllElement.get().spliterator().getExactSizeIfKnown() + " 条数据");


                                } else {

                                    // 50
                                    out.collect("50 窗口中有 " + count + " 条数据");

                                }


                            }
                        }
                )
                .print();


        env.execute();


    }

}

MapStates

public class MapStates {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);


        env
                .addSource(new ClickSource())
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Event>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
                                .withTimestampAssigner(
                                        new SerializableTimestampAssigner<Event>() {
                                            @Override
                                            public long extractTimestamp(Event element, long recordTimestamp) {
                                                return element.timestamp;
                                            }
                                        }
                                )
                )
                .keyBy(event -> event.user)
                .process(

                        // 每 10s 统计一下 每个用户 每个 页面的点击 pv

                        new KeyedProcessFunction<String, Event, String>() {

                            private ValueState<Long> timerT;
                            private MapState<String, Long> avgPagePv;

                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);
                                timerT = getRuntimeContext().getState(new ValueStateDescriptor<Long>("timer-ts", Types.LONG));
                                avgPagePv = getRuntimeContext().getMapState(new MapStateDescriptor<String, Long>("avg-page-pv", Types.STRING, Types.LONG));
                            }

                            @Override
                            public void processElement(Event value, Context ctx, Collector<String> out) throws Exception {

                                if (!avgPagePv.contains(value.url)) {
                                    avgPagePv.put(value.url, 1L);
                                } else {
                                    avgPagePv.put(value.url, avgPagePv.get(value.url) + 1L);
                                }

                                if (timerT.value() == null) {
                                    long ts = value.timestamp + 10 * 1000L;
                                    ctx.timerService().registerEventTimeTimer(ts);
                                    timerT.update(ts);
                                }

                            }

                            @Override
                            public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
                                super.onTimer(timestamp, ctx, out);

                                Iterable<Map.Entry<String, Long>> entries = avgPagePv.entries();

                                String key = ctx.getCurrentKey();


                                entries.forEach(elem -> out.collect("key = " + key + "\turl：" + elem.getKey() + "\tpv：" + elem.getValue()));


                                timerT.clear();


                            }
                        })
                .print();


        env.execute();


    }

}

ReducingStates & AggregatingStates

public class AggregatingStates {

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


        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        /*
            AggregatingState<IN, OUT>
                This keeps a single value that represents the aggregation of all values added to the state.
                Contrary to ReducingState, the aggregate type may be different from the type of elements that are added to the state.
                The interface is the same as for ListState but elements added using add(IN) are aggregated using a specified AggregateFunction.
         */


        env
                .addSource(new SourceFunction<Tuple2<String, Integer>>() {

                    private List<Character> letters = new ArrayList<>(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'));

                    private Random random = new Random();

                    private boolean running = true;

                    @Override
                    public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {

                        while (running) {

                            ctx.collect(Tuple2.of(String.valueOf(letters.get(random.nextInt(26))), random.nextInt(30)));

                            Thread.sleep(10);

                        }

                    }

                    @Override
                    public void cancel() {
                        running = false;
                    }
                })
                .keyBy(e -> e.f0)
                .flatMap(
                        new RichFlatMapFunction<Tuple2<String, Integer>, String>() {

                            private int count = 0;

                            private transient AggregatingState<Tuple2<String, Integer>, Integer> aggState;

                            @Override
                            public void open(Configuration parameters) throws Exception {
                                super.open(parameters);

                                AggregatingStateDescriptor<Tuple2<String, Integer>, Integer, Integer> aggStateDescriptor
                                        = new AggregatingStateDescriptor<>(
                                        "agg-state",
                                        new AggregateFunction<Tuple2<String, Integer>, Integer, Integer>() {
                                            @Override
                                            public Integer createAccumulator() {
                                                return 0;
                                            }

                                            @Override
                                            public Integer add(Tuple2<String, Integer> value, Integer accumulator) {
                                                return accumulator + value.f1;
                                            }

                                            @Override
                                            public Integer getResult(Integer accumulator) {
                                                return accumulator;
                                            }

                                            @Override
                                            public Integer merge(Integer a, Integer b) {
                                                return a + b;
                                            }
                                        },
                                        Types.INT);

                                aggState = getRuntimeContext().getAggregatingState(aggStateDescriptor);


                            }

                            @Override
                            public void flatMap(Tuple2<String, Integer> value, Collector<String> out) throws Exception {

                                count++;

                                if (count % 50 == 0) {
                                    out.collect( "key = " + value.f0 + "\tcount = " + aggState.get());
                                    aggState.clear();
                                } else {
                                    // 增量更新 AggregatingState ，每来一条元素 acc + f1
                                    aggState.add(value);
                                }


                            }
                        }
                )
                .print();

        env.execute();

    }

}

BroadcastStates

public class BroadcastStates {

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

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


        DataStreamSource<Tuple2<String, Integer>> ruleStream = env
                .fromElements(
                        Tuple2.of("Mary", 100),
                        Tuple2.of("Bob", 98),
                        Tuple2.of("other", 0)

                );


        MapStateDescriptor<String, Tuple2<String, Integer>> ruleStateDescriptor = new MapStateDescriptor<>(
                "rule-state",
                BasicTypeInfo.STRING_TYPE_INFO,
                Types.TUPLE(Types.STRING, Types.INT)
        );

        BroadcastStream<Tuple2<String, Integer>> broadcastStream = ruleStream.broadcast(ruleStateDescriptor);


        /// ==========================


        /*
            非广播流的类型
                如果流是一个 keyed 流，那就是 KeyedBroadcastProcessFunction 类型
                如果流是一个 non-keyed 流，那就是 BroadcastProcessFunction 类型
         */


        KeyedStream<Event, String> clickKeyStream = env.addSource(new ClickSource()).keyBy(event -> event.user);

        SingleOutputStreamOperator<String> result = clickKeyStream
                .connect(broadcastStream)
                .process(new KeyedBroadcastProcessFunction<String, Event, Tuple2<String, Integer>, String>() {
                    @Override
                    public void processElement(Event event, ReadOnlyContext ctx, Collector<String> out) throws Exception {

                        Iterable<Map.Entry<String, Tuple2<String, Integer>>> entryIterable = ctx.getBroadcastState(ruleStateDescriptor).immutableEntries();

                        for (Map.Entry<String, Tuple2<String, Integer>> entry : entryIterable) {

                            String key = entry.getKey();
                            Tuple2<String, Integer> val = entry.getValue();


                            if (key.equals(event.user)) {
                                out.collect(event + " -> " + val);
                            } else {
                                out.collect(event + " -> -> " + val);
                            }

                        }

                    }

                    @Override
                    public void processBroadcastElement(Tuple2<String, Integer> value, Context ctx, Collector<String> out) throws Exception {

                        ctx.getBroadcastState(ruleStateDescriptor).put(value.f0, value);

                    }
                });


        result.print();


        env.execute();


    }

}

参考资料
https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/concepts/stateful-stream-processing/
https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/datastream/fault-tolerance/state/
https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/libs/state_processor_api/

Linux 使用 Docker 安装 memos 备忘录
lpyun@aliyun.com
03-13 981
一个轻量级的自我托管备忘录中心。开源，永远免费。备忘录提供了创新者在灵感时刻所需的隐私安全和可靠性。memos 官网。
内网穿透工具cpolar简介
wjCwl的博客
01-15 4949
文章目录一、需求描述二、安装和使用三、平时使用 一、需求描述 做后端，需要和前端联调，之前写的垃圾代码要修改的地方太多了，每次修改后需要保存到gitlab，打包，再部署到服务器上，前端才能访问，访问出毛病又要改重新走一遍上面的流程。太费事了。师兄告诉我们可以通过内网穿透来解决。自己找到了一个好用的内网穿透工具cpolar，小巧简单免费，介绍给大家。 二、安装和使用 Windows用户如何安装Cpolar工具 【官方介绍的就很好，不多讲，按流程来，没有遇到bug】 再贴一个官网
【开源项目分享】GitHub中文排行榜 - 帮助你发现高分优秀中文项目-Java
稻草人的技术小站
04-24 2916
榜单设立目的 ???????? GitHub中文排行榜，帮助你发现高分优秀中文项目； 各位开发者伙伴可以更高效地吸收国人的优秀经验、成果； 中文项目只能满足阶段性的需求，想要有进一步提升，还请多花时间学习高分神级英文项目； 榜单设立范围 设立1个总榜（所有语言项目汇总排名）、18个分榜（单个语言项目排名）； 榜单入选规则 一个小小的要求：项目的 Description 和 README.md 都要包含中文说明； 更新越持续越好：最近半年内有更新过的项目才有机会入选（拥抱活跃，远离僵尸）； Star
使用内网穿透工具进行支付宝沙箱环境支付的SDK接口远程测试
weixin_46151178的博客
10-31 391
点击左侧仪表盘的状态——在线隧道列表，可以看到刚刚创建的隧道已经有生成了相应的公网地址，一个http协议，一个https协议（免去配置ssl证书的繁琐步骤），将其复制想下来。以上调用sdk创建支付单的服务运行在本地,局限性在于只能本地的项目才能调用测试支付的接口,如果想要远程也可以调用,需要把服务暴露到公网。,登录cpolar web UI管理界面，点击左侧仪表盘的隧道管理——隧道列表，找到支付接口测试隧道，点击右侧的编辑。编写一个接口,为了方便演示,创建get请求,订单信息写死在代码中。
内网穿透工具Cpolar 食用指南
kft1314的博客
08-15 2902
运行此命令会将您帐户的authtoken添加到您的cpolar.yml文件中。这将为您提供更多功能，所有打开的隧道将在此处的仪表板中列出。./cpolar http 80 >nohup.out 2>&1 & #后台启动。缺点：免费有限 重启后会随机重新分配域名，收费版本可以选择域名。然后回到网页，查看自映射后的外网地址。我们首先访问cpolar官网。我们首先访问cpolar官网。其他的功能自行研究吧！
cpolar---亲测超级好用的永久免费内网穿透无需公网IP
最新发布
u013758456的专栏
12-25 1003
4、左侧仪表盘——状态——在线隧道列表，可以看到已经更新了的公网地址。，登录cpolar web-ui管理界面。3、左侧仪表盘——隧道管理——隧道列表。2、浏览器访问本地9200端口，1、选择“China VIP”5、使用固定TCP地址远程桌面。
2022年10月 cpolar软件实现内网穿透连接群晖NAS
热门推荐
微软MVP Eleven
10-15 3万+
cpolar是一款拥有远程控制和内网穿透功能的软件。而且还可以监控端口的HTTP请求，利用实时的cpolar Web UI开发者工具，让您调试代码更容易。您可以监听所有隧道上的HTTP消息包，分析消息包的结构内容，找出问题点。还可以单击重放（Replay）按钮，重新发送该HTTP信令请求。
cpolar的基础使用方法
2301_78420308的博客
08-10 1010
群晖作为大容量存储系统，既可以作为个人的私有存储设备，也可以放在小型企业中作为数据中心使用。其强大的数据存储和管理功能，让其还能够胜任更多任务。但由于群晖的应用场景所限，这些功能通常只能在局域网内实现，想要让群晖NAS存储的数据能在公网访问到，我们可以借助cpolar的辅助，轻松实现在公共互联网访问内网群晖NAS上的数据。在这之前，我们还是需要了解下cpolar的基本操作方式。
Hexo Moments JS: 轻量级朋友圈网页模板与爬虫部署
它通过JavaScript实现了一种轻量级的网页模板加载方式，能够动态地加载朋友圈内容，用户不需要刷新页面即可看到新内容。 ### 知识点二：爬虫配置与API地址修改 爬虫是一种自动获取网页内容的程序，可以模拟人类...
matlab.rar_matlab 矩量法_method of moments_、矩量法_矩量法matlab_网格划分matla
07-14
本资源主要关注的是在MATLAB环境中实现矩量法（Method of Moments, MoM）的一种方法，这是一种用于求解电磁问题的数值计算技术。 矩量法是基于边界条件的数值方法，它通过将复杂的物理系统离散化为一系列小的几何...
method_of_moments.rar_method_of_moments_moment_电磁场矩量法_电磁积分方程
09-22
矩量法（Method of Moments，MoM）是电磁场计算中的一个重要方法，它在解决复杂的电磁问题时，尤其是在处理开放区域或结构复杂的目标物体时，展现出显著的优势。该方法基于格林函数理论，通过将物体表面的电流分布...
fsort:文件内容的轻量级气泡排序器
03-07
它是文件内容的轻量级气泡排序器 它可以对文件中的内容进行排序 这么说吧，您有一个文件gamer-moments.txt ，文件内容为： 10 12 4 12 5 7 4 以及如何对它们进行排序？ 使用fsort非常容易！ 在Linux上 只需编译...
内网穿透工具（一） -- Cpolar 简介
dazhong2012的专栏
10-28 2938
cpolar是一种安全的内网穿透云服务，它将内网下的本地服务器通过安全隧道暴露至公网。使得公网用户可以正常访问内网服务。这意味着即使服务器位于防火墙或NAT之后，公网用户也能正常访问您的内网服务。cpolar提供了一种简单、快速且安全的方式来实现远程访问和数据传输。
远程办公并不难 cpolar轻松实现
10-10 2018
最后，我们在cpolar客户端左侧的“状态”项下，找到“在线隧道列表”，就能看到这条数据隧道的入口（即公网地址），我们只要将这个公网地址粘贴到其他地方的电脑远程桌面程序中（比如家里的电脑），就能实现在公司以外的电脑上，以远程桌面的方式，操作办公室的电脑，就像我们真的在办公室操作办公电脑一样，达到远程办公的目的。完成注册并升级至专业套餐后，我们在“仪表盘”界面左侧，找到“预留”按钮，设置一条空白的TCP-IP隧道，为我们建立远程办公数据隧道做好准备。首先在办公室的电脑上，安装一个cpolar软件。
使用cpolar实现内网穿透
weixin_68256171的博客
02-19 2870
使用cpolar可以实现免费的内网穿透，但缺点是每次启动HTTP隧道的网址都不固定，若需固定网址，需付费。使用xftp将安装压缩包传到Linux端的根目录（\）下。使用图片中的网站地址即可访问到zy下的网页文件。使用xftp将所需文件（zy）上传到根目录下。此时可用IP地址访问到zy下的网页文件。
内网穿透工具Cpolar使用方法
WuHao的博客
09-03 1045
内网穿透工具Cpolar免费使用方法
使用cpolar实现内网穿透，将Web项目部署到公网上
聂可以的博客
05-27 6513
使用cpolar实现内网穿透，将Web项目部署到公网上
在外地ssh远程连接家里ubuntu服务器（Coplar内网穿透）
Talk is cheap, show me the code!
08-01 1495
【代码】在外地ssh远程连接家里ubuntu服务器（Coplar内网穿透）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值