大数据-玩转数据-Flink状态编程（中）

最新推荐文章于 2024-06-17 22:31:37 发布
最新推荐文章于 2024-06-17 22:31:37 发布
阅读量357 收藏
点赞数
分类专栏： 大数据-玩转数据-FLINK 文章标签： 大数据 flink servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_unbo/article/details/132713819
版权

一、键控状态

键控状态是根据输入数据流中定义的键（key）来维护和访问的。
Flink为每个键值维护一个状态实例，并将具有相同键的所有数据，都分区到同一个算子任务中，这个任务会维护和处理这个key对应的状态。当任务处理一条数据时，它会自动将状态的访问范围限定为当前数据的key。因此，具有相同key的所有数据都会访问相同的状态。
Keyed State很类似于一个分布式的key-value map数据结构，只能用于KeyedStream（keyBy算子处理之后）。

二、ValueState

保存单个值. 每个key有一个状态值. 设置使用 update(T), 获取使用 T value()

案例：
检测传感器的水位值，如果连续的两个水位值超过10，就输出报警

package com.lyh.flink09;

import com.lyh.bean.WaterSensor;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class key_Value {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.socketTextStream("hadoop100",9999)
                .map(line -> {
                    String[] datas = line.split(",");
                    return  new WaterSensor(
                            datas[0],
                            Long.valueOf(datas[1]),
                            Integer.valueOf(datas[2]));

                })
                .keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, String>() {

                    private ValueState<Integer> lastValueState;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        lastValueState = getRuntimeContext().getState(new ValueStateDescriptor<Integer>("ValueState",Integer.class));
                    }

                    @Override
                    public void processElement(WaterSensor value,
                                               Context ctx,
                                               Collector<String> out) throws Exception {
                        Integer lastVc = lastValueState.value();
                        if (lastVc != null) {
                            if (lastVc > 10 && value.getVc()>10) {
                                out.collect(ctx.getCurrentKey() + "连续两次超越告警值。。。。");

                            }

                        }
                        lastValueState.update(value.getVc());
                    }

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

    }
}

三、ListState

针对每个传感器输出最高的3个水位值

package com.lyh.flink09;

import com.lyh.bean.WaterSensor;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

import java.util.ArrayList;
import java.util.List;

public class key_List {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        env.socketTextStream("hadoop100",9999)
                .map(line ->{
                    String[] datas = line.split(",");
                    return new WaterSensor(
                            datas[0],
                            Long.valueOf(datas[1]),
                            Integer.valueOf(datas[2])
                    );
                }).keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, List<Integer>>() {
                    private ListState<Integer> top3Vc;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        top3Vc = getRuntimeContext().getListState(new ListStateDescriptor<Integer>("top3Vc", Integer.class));
                    }
                    @Override
                    public void processElement(WaterSensor value,
                                               Context ctx,
                                               Collector<List<Integer>> out) throws Exception {
                       top3Vc.add(value.getVc());
                        Iterable<Integer> it = top3Vc.get();
                        List<Integer> vcs = new ArrayList<>();
                        for (Integer vc : top3Vc.get()) {
                            vcs.add(vc);
                        }
                        vcs.sort((o1,o2)->o2-o1);
                        if (vcs.size()>3) {
                            vcs.remove(3);
                        }
                        top3Vc.update(vcs);
                        out.collect(vcs);
                    }
                }).print();
        env.execute();
    }

}

运行结果：

2> [11]
2> [11, 1]
2> [11, 1, 1]
2> [100, 11, 1]
2> [1000, 100, 11]
2> [1000, 100, 99]
2> [1000, 100, 99]

四、ReducingState

计算每个传感器的水位和

package com.lyh.flink09;

import com.lyh.bean.WaterSensor;
import org.apache.flink.api.common.state.ReducingState;
import org.apache.flink.api.common.state.ReducingStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class key_Reduce {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        env.socketTextStream("hadoop100",9999)
                .map(line -> {
                    String[] datas = line.split(",");
                    return new WaterSensor(
                    datas[0],
                    Long.valueOf(datas[1]),
                    Integer.valueOf(datas[2]));
                }).keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, Integer>() {
                    private ReducingState<Integer> vcstate;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        super.open(parameters);
                         vcstate = getRuntimeContext().getReducingState(new ReducingStateDescriptor<Integer>(
                                "vcstate",
                                Integer::sum,
                                Integer.class));
                    }
                    @Override
                    public void processElement(WaterSensor value,
                                               Context ctx,
                                               Collector<Integer> out) throws Exception {
                              vcstate.add(value.getVc());
                              out.collect(vcstate.get());

                    }


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

运行：
在这里插入图片描述
运行结果：
在这里插入图片描述

五、AggregatingState

计算每个传感器的平均水位

package com.lyh.flink09;

import com.lyh.bean.WaterSensor;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.state.AggregatingState;
import org.apache.flink.api.common.state.AggregatingStateDescriptor;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class key_Agg {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        env.socketTextStream("hadoop100",9999)
                .map(line ->{
                    String[] datas = line.split(",");
                    return new WaterSensor(
                            datas[0],
                            Long.valueOf(datas[1]),
                            Integer.valueOf(datas[2])
                    );
                }).keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, Double>() {
                    private AggregatingState<Integer, Double> avgState;
                    @Override
                    public void open(Configuration parameters) throws Exception {

                        AggregatingStateDescriptor<Integer, Tuple2<Integer, Integer>, Double>
                         Avg = new AggregatingStateDescriptor<>(
                                "Avg",
                                new AggregateFunction<Integer,
                                        Tuple2<Integer, Integer>,
                                        Double>() {
                            @Override
                            public Tuple2<Integer, Integer> createAccumulator() {
                                return Tuple2.of(0,0);
                            }

                            @Override
                            public Tuple2<Integer, Integer> add(Integer value, Tuple2<Integer, Integer> integerTuple2) {
                                return Tuple2.of(integerTuple2.f0 + value,integerTuple2.f1 + 1);
                            }

                            @Override
                            public Double getResult(Tuple2<Integer, Integer> integerTuple2) {
                                return integerTuple2.f0*1D/integerTuple2.f1;
                            }

                            @Override
                            public Tuple2<Integer, Integer> merge(Tuple2<Integer, Integer> a, Tuple2<Integer, Integer> b) {
                                return Tuple2.of(a.f0 + b.f0 , a.f1 + b.f1);
                            }
                        }, Types.TUPLE(Types.INT,Types.INT));
                        avgState = getRuntimeContext().getAggregatingState(Avg);
                    }

                    @Override
                    public void processElement(WaterSensor value,
                                               Context ctx,
                                               Collector<Double> out) throws Exception {
                        avgState.add(value.getVc());
                        out.collect(avgState.get());

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

运行：
在这里插入图片描述
结果：
在这里插入图片描述

六、MapState

去重: 去掉重复的水位值. 思路: 把水位值作为MapState的key来实现去重, value随意

package com.lyh.flink09;

import com.lyh.bean.WaterSensor;
import org.apache.flink.api.common.state.MapState;
import org.apache.flink.api.common.state.MapStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;

public class key_Map {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(2);
        env.socketTextStream("hadoop100",9999)
                .map(line ->{
                    String[] datas = line.split(",");
                    return new WaterSensor (
                        datas[0],
                        Long.valueOf(datas[1]),
                        Integer.valueOf(datas[2]));
                }).keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, WaterSensor>() {

                    private MapState<Integer, String> mapState;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                         mapState = this.getRuntimeContext().getMapState(new MapStateDescriptor<Integer, String>("mapState", Integer.class, String.class));

                    }

                    @Override
                    public void processElement(WaterSensor values,
                                               Context ctx,
                                               Collector<WaterSensor> out) throws Exception {
                        if (!mapState.contains(values.getVc())) {
                            out.collect(values);
                            mapState.put(values.getVc(),"随意");

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

运行：
在这里插入图片描述
结果：
在这里插入图片描述

人猿宇宙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink之状态编程
qq_41924766的博客
05-24 298
Flink中的状态编程
大数据-flink-mysql-connector:用于flinkcdc实时同步
02-04
flinkc-sql-connector-mysql,用于mysql数据实时同步
最新 大数据-Flink实时旅游平台（精华版）
04-10
课程主要讲解项目环境篇：项目依赖环境的安装部署，项目数据准备篇：项目中所使用的数据介绍和准备，项目分析篇：项目中涉及的模块及指标介绍和研发，项目数据服务篇：项目中分析出来的数据提供服务，项目展示篇：项目中的结果数据的展示及应用。 ├─视频 │    01 环境篇之项目计划.mp4 │    05 环境篇之项目架构.mp4 │    06 环境篇之项目软件版本.mp4 │    07 环境篇之jdk的安装.mp4 │    09 环境篇之hadoop安装配置.mp4 │    11 环境篇之kafka的安装部署.mp4 │    15 环境篇ES集群的测试.mp4 │    16 环境篇之ES的head插件安装准备.mp4 │    20 环境篇之redis的linux和window测试.mp4 │    21 环境篇之redis的主从部署及测试.mp4 │    22 环境篇之flink简介.mp4 │    23 环境篇之flink的HA部署.mp4 │    24 环境篇之flink的集群测试.mp4 │    26 环境篇之flink的his
Flink1.12-2021黑马 6-7Table&SQL +实战
紫蝶侠的博客
03-16 1350
7.Flink-Action综合练习 课程目标 掌握使用Flink实现模拟双十一实时大屏统计 掌握使用Flink实现订单自动好评 1. Flink模拟双十一实时大屏统计 1.1 需求 在大数据的实时处理中，实时的大屏展示已经成了一个很重要的展示项，比如最有名的双十一大屏实时销售总价展示。除了这个，还有一些其他场景的应用，比如我们在我们的后台系统实时的展示我们网站当前的pv、uv等等，其实做法都是类似的。 今天我们就做一个最简单的模拟电商统计大屏的小例子， 需求如下： 1.实时计算出当天零点截止到当前时
flink状态编程
weixin_52542476的博客
04-28 114
flink状态管理是在流处理的整个过程中保持状态的一种能力，它让我们能够在复杂的事件处理和流转换中保留重要的状态信息.
Flink SQL DDL 和 窗口函数实战（含代码练习）
Brave_heart4pzj的博客
12-13 5947
一、Flink SQL DDL 2019 年 8 月 22 日，Flink 发布了 1.9 版本，社区版本的 Flink 新增 了一个 SQL DDL 的新特性，但是暂时还不支持流式的一些概念的定义，比如说水位。 二、定义 create table 语句 从 kafka 中读取数据 可以体验一下，如果使用 ddl 的方式直接定义一个表从 kafka 中读取数据，并定义成一个表 CREATE TAB...
Flink学习——状态编程
Helen_1997_1997的博客
05-19 524
Flink学习——状态编程 valueState、listValue、mapState、ReducingState
Flink_状态编程_2
959
04-02 469
文章目录1.算子状态概述1.1 算子状态分类1.2 状态分析1.3 CheckpointedFunction 接口2.算子状态 编程案例2.1 列表状态案例2.2 广播机制 案例3.状态持久化和状态后端3.1 检查点（Checkpoint）3.2 状态后端 state Backends4.状态编程总结 1.算子状态概述 1.1 算子状态分类 算子状态: 列表状态, 联合列表状态, 广播状态 ListState, UnionListState, BroadcastState 1.2 状态分析 列表状态
大数据-flink和streamx部署
02-08
包含flink安装包、streamx安装包、streamx 部署流程
剑指大数据-Flink学习精要（Java版）
03-18
剑指大数据——Flink学习精要（Java版） 7M大文件，全方位讲述Flink
Generator做为状态机与普通状态机的区别及实现
weixin_46816740的博客
09-07 1671
状态机(有限状态交替变化)有限状态自动机，每运行一次 改变一次状态 什么是状态机？ 以操作系统中的任务调度为例来说明什么是状态机。在操作系统的任务调度中经常见到状态机，其作用是根据任务的状态和当前资源条件来改变任务的状态。任务的状态和资源的条件就构成了一个状态机，参见下图： 普通状态机：要依赖于外部的变量，所以导致状态不安全 代码实现： var flag=true; function clock(){ if(flag){ console.log("开",flag)
Flink状态之 ListState 用法
cbb
01-08 3065
1.flink的基本状态 Flink有两种基本的状态：算子状态(Operator State)和键控状态(Keyed State)，他们的主要区别就是作用范围不一样，算子状态的作用范围就是限定为算子任务（也就是当前一个分区执行的时候，所有数据来了都能访问到状态）。键控状态中并不是当前分区所有的数据都能访问所有的状态，而是按照keyby之后的key做划分，当前key只能访问自己的状态。 1.1 Operator State算子状态 顾名思义，状态是和算子进行绑定的，一个算子的状态不能被其他算子所访问到。状态由
Flink 1. 13（五）状态编程
ks_1998的博客
07-09 1121
Flink状态编程
大数据开发：Flink的状态编程、状态机制
zjjcchina的博客
05-18 201
算子状态功能不如按键分区状态丰富，应用场景较少，经常被用在Source或Sink等算子上，用来保存流入数据的偏移量或对输出数据做缓存，Kafka consumer 每个并行实例维护了 topic partitions 和偏移量的map作为它的算子状态，以保证Flink应用的Exactly-Once语义。在 Flink 中，状态的存储、访问以及维护，都是由一个可插拔的组件决定的，这个组件就叫作状态后端（state backend）。在传统的事务型处理架构中，这种额外的状态数据是保存在数据库中的。
苏州辰安塑业携塑料托盘、塑料物流箱解决方案亮相2024杭州快递物流展
最新发布
zhoubin2019的博客
06-17 600
2024长三角快递物流供应链与技术装备展览会（杭州），于2024年7月8-10日在杭州国际博览中心召开，本届展会致力于全面展示快递物流上下游领域的创新解决方案，涵盖快递物流供应链、智能装备、AGV机器人与无人搬运、自动识别、智慧仓储、智慧物流、无人配送、新能源物流车及商用车、绿色包装、冷链物流等各个环节，为促进行业合作共融，整合升级提升服务价值搭建展示交流的行业平台。苏州辰安塑业携塑料托盘、吹塑托盘、塑料卡板箱、塑料周转箱、塑料物流箱、塑料垃圾桶解决方案盛装亮相2024杭州快递物流展！
数据资产入表-数据分级分类标准-数据分类
weixin_43198581的博客
06-17 725
2.盘点组织内部的贴源层（STG）的数据来源，一般数据来源包含外部获取（公共数据授权、爬虫归集、外部采购三类）、系统沉淀的数据等维度，按照不同的数据来源区分数据权属，一般贴源层的数据可拥有的权属为数据持有权和数据加工使用权两类；2021年9月1日，《中华人民共和国数据安全法》正式施行，明确规定“国家建立数据分类分级保护制度”，数据分级分类是数据安全管理的重要措施，它涉及到对数据资产的识别、分类和定级，是保障数据合规的前提。c)业务属性分类：选择合适的业务属性，对关键业务的数据进行细化分类。
java技术专家面试指南80问【java学习+面试宝典】（七）
fengbeely的博客
06-15 1240
索引是一种数据结构,可以帮助我们快速的进行数据的查找。在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是 内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。1）计算机体系结构是指那些能够被程序员看到的计算机的属性。如指令集、数据类型等；2）计算机组成是指如何实现计算机体系结构所体现出来的属性；3）以乘法指令为例，计算机是否有乘法指令，属于体系结构的问题。乘法指令是采用专用的乘法器，还是使用加法器和移位器构成，属于计算机组成的问题。1.mycat的全局id方案。
flink 状态编程
07-27
Flink状态编程是指在Apache Flink流处理框架中使用状态来处理有状态操作的一种编程模式。在流处理中，我们经常需要跟踪和维护一些数据的状态，例如计数器、累加器等。Flink为此提供了不同类型的状态，包括键控状态和操作符状态。 键控状态是与特定键相关联的状态，可以通过键值对的方式进行访问和修改。它适用于按键分组的操作，例如窗口操作或基于键的聚合。键控状态可以在算子的函数中进行访问和更新，并且Flink会自动处理状态的分区和并发问题。 操作符状态是与算子相关联的状态，用于存储算子执行过程中的中间结果。操作符状态可以通过算子函数中的状态管理器进行访问和更新。它适用于需要在算子函数之间共享数据的情况，例如迭代计算或自定义的窗口操作。 Flink提供了不同的状态后端来存储和管理状态数据，例如内存状态后端、RocksDB状态后端等。开发者可以根据实际需求选择适合的状态后端。 使用Flink状态编程，开发者可以轻松地处理有状态操作，并且Flink会自动处理并发和容错。这使得开发者能够更好地处理实时流处理应用程序中的复杂逻辑和状态管理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值