• Flink（java版）

    watermark

    时间语义和 watermark 

    1. 注意:数据进入flink的时间：如果用这个作为时间语义就不存在问题，但是开发中往往会用处理时间
    2. 作为时间语义这里就需要考虑延时的问题。
    3. 如上图，数据从kafka中获取出来，从多个分区中获取，这时候时间肯定有乱序,这时候就需要使用事
    4. 件时间。

    1. 场景：游戏连续过五关，给予奖励
    2. 地铁里面玩游戏，连过三关断网了，二分钟过了八关。这时候是用处理时间还是事件时间呢？
    3. 处理时间的优势：牺牲一定的数据准确性，没有延迟

    1. package com.atguigu.apitest.window;/**
    2.  
    3. import com.atguigu.apitest.beans.SensorReading;
    4. import org.apache.flink.streaming.api.TimeCharacteristic;
    5. import org.apache.flink.streaming.api.datastream.DataStream;
    6. import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    7. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    8. import org.apache.flink.streaming.api.functions.timestamps.AscendingTimestampExtractor;
    9. import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
    10. import org.apache.flink.streaming.api.windowing.time.Time;
    11. import org.apache.flink.util.OutputTag;
    12.  
    13. public class WindowTest3_EventTimeWindow {
    14.     public static void main(String[] args) throws Exception {
    15.         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    16.         //默认为当前机器的cpu的最大核数
    17.         //env.setParallelism(1);
    18.         env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
    19.         env.getConfig().setAutoWatermarkInterval(100);
    20.  
    21.         // socket文本流
    22.         DataStream inputStream = env.socketTextStream("localhost", 7777);
    23.  
    24.         // 转换成SensorReading类型，分配时间戳和watermark
    25.         DataStream dataStream = inputStream.map(line -> {
    26.             String[] fields = line.split(",");
    27.             return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    28.         })
    29.                 // 乱序数据设置时间戳和watermark
    30.                 .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor(Time.seconds(2)) {
    31.                     @Override
    32.                     public long extractTimestamp(SensorReading element) {
    33.                         return element.getTimestamp() * 1000L;
    34.                     }
    35.                 });
    36.  
    37.         OutputTag outputTag = new OutputTag("late") {
    38.         };
    39.  
    40.         // 基于事件时间的开窗聚合，统计15秒内温度的最小值
    41.         SingleOutputStreamOperator minTempStream = dataStream.keyBy("id")
    42.                 .timeWindow(Time.seconds(15))
    43.                 .allowedLateness(Time.minutes(1))
    44.                 .sideOutputLateData(outputTag)
    45.                 .minBy("temperature");
    46.  
    47.         minTempStream.print("minTemp");
    48.         minTempStream.getSideOutput(outputTag).print("late");
    49.  
    50.         env.execute();
    51.     }
    52. }
    1. sensor_1,1547718199,35.8
    2. sensor_6,1547718201,15.4
    3. sensor_7,1547718202,6.7
    4. sensor_10,1547718205,38.1
    5. sensor_1,1547718207,36.3
    6. sensor_1,1547718211,32.8
    7. sensor_1,1547718212,37.1
    8.  
    9. 注意：第一个窗口是[1547718195,1547718210);

    1. sensor_1,1547718213,33
    2. sensor_1,1547718224,32.1
    3. sensor_1,1547718225,31.6
    4. sensor_1,1547718226,21.2
    5. sensor_1,1547718227,33.6
    6.  
    7. 第二个窗口大小：第一个窗口是[1547718210,1547718225);

    1. 1.理想状态：
    2.      来一条数据处理一条，每条数据代表对时间推进；如图到5之后就将【0，5）的窗口关闭并输出；
    3.  
    4. 2.乱序状态：
    5.      原因：网络延迟、分布式、分区导致乱序数据产生；
    6.      网络延迟和分布式处理造成的乱序都是几十毫秒和几百毫秒的范围的差距；这将回造成大多数延迟
    7.   数据集中在几十毫秒和几百毫秒的范围内；
    8.  
    9. 3.解决方案：将时间事件放慢

    1. flink的三重保证：
    2.  1.设置watermaker将几百毫秒的数据全部输出；
    3.  2.先输出一个近似的结果，但是不要关闭窗口后面延迟的时间还需要更新；
    4.  3.当延时时间到了，窗口就关闭了；兜底方案使用侧输出流保证数据不丢失；
    5.  
    6. 注意：数据流中的 Watermark 用于表示 timestamp 小于 Watermark 的数据都已经到
    7. 达了，因此，window 的执行也是由 Watermark 触发的。
    8. 6 3 2 5 4 1 
    9. 比如设置3秒的watermaker：
    10. 到达5：说明2秒之前的数据都到齐了，后面2，3都可以输出
    11. 到达6：说明3秒之前的数据都到齐了，大于等于3秒的数据才能输出
    12.  
    13. 意义：watermark 用来让程序自己平衡延迟和结果正确性：如果设置太大延迟太高，设置太
    14. 小数据就不准确，需要通过具体的业务场景去平衡这个值;

    1. watermark 用来让程序自己平衡延迟和结果正确性：如果设置太大延迟太高，设置太小,乱序数据
    2. 没有搞定,数据就不准确，需要通过具体的业务场景去平衡这个值;
    3.  
    4. 如何找到watermaker：首先要了解乱序程度;
    5. 解决方案：通过机器学习构建一个模型，构建当前业务模型中的延迟状态的分布情况;

    1. 如图：大部分的延时数据都20ms和80ms之间的范围中,这时候设置80ms就搞定大部分乱序数据;
    2. 这时候还有很少的数据，如果对数据准确性要求比较高，这时候就需要设置窗口迟到机制去保证
    3. 数据的准备性;最后还有网络延迟的数据还是没有输出这时候就需要添加侧输出流作为兜底方案。

     watermark 生成问题

    1. 默认：来一条生产一条watermaker，如果短时间数据量比较大，会造成watermaker都一样造成资
    2. 源浪费；周期性添加watermaker:每隔一段时间更新一下watermaker 
    3. 周期性时间缺点：实时性不好；数据过于分散会造成资源浪费；
    4.  
    5. 如何选择：看数据的分布，过于集中使用周期性生成模式,数据稀疏，使用默认的模型；

    状态编程 

    需求：我们可以利用 Keyed state，实现这样一个需求: 检测传感器的温度值，如果连续的两个温度差值超过 10 度，就输出报警

    1. package com.atguigu.apitest.state;/**
    2.  * Copyright (c) 2018-2028 尚硅谷 All Rights Reserved
    3.  * 
    4.  * Project: FlinkTutorial
    5.  * Package: com.atguigu.apitest.state
    6.  * Version: 1.0
    7.  * 
    8.  * Created by wushengran on 2020/11/10 16:33
    9.  */
    10.  
    11. import com.atguigu.apitest.beans.SensorReading;
    12. import org.apache.flink.api.common.functions.FlatMapFunction;
    13. import org.apache.flink.api.common.functions.RichFlatMapFunction;
    14. import org.apache.flink.api.common.functions.RichMapFunction;
    15. import org.apache.flink.api.common.state.ValueState;
    16. import org.apache.flink.api.common.state.ValueStateDescriptor;
    17. import org.apache.flink.api.java.tuple.Tuple3;
    18. import org.apache.flink.configuration.Configuration;
    19. import org.apache.flink.streaming.api.datastream.DataStream;
    20. import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    21. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    22. import org.apache.flink.util.Collector;
    23.  
    24. /**
    25.  * @ClassName: StateTest3_KeyedStateApplicationCase
    26.  * @Description:
    27.  * @Author: wushengran on 2020/11/10 16:33
    28.  * @Version: 1.0
    29.  */
    30. public class StateTest3_KeyedStateApplicationCase {
    31.     public static void main(String[] args) throws Exception{
    32.         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    33.         env.setParallelism(1);
    34.  
    35.         // socket文本流
    36.         DataStream inputStream = env.socketTextStream("localhost", 7777);
    37.  
    38.         // 转换成SensorReading类型
    39.         DataStream dataStream = inputStream.map(line -> {
    40.             String[] fields = line.split(",");
    41.             return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    42.         });
    43.  
    44.         // 定义一个flatmap操作，检测温度跳变，输出报警
    45.         SingleOutputStreamOperator> resultStream = dataStream.keyBy("id")
    46.                 .flatMap(new TempChangeWarning(10.0));
    47.  
    48.         resultStream.print();
    49.  
    50.         env.execute();
    51.     }
    52.  
    53.     // 实现自定义函数类
    54.     public static class TempChangeWarning extends RichFlatMapFunction>{
    55.         // 私有属性，温度跳变阈值
    56.         private Double threshold;
    57.  
    58.         public TempChangeWarning(Double threshold) {
    59.             this.threshold = threshold;
    60.         }
    61.  
    62.         // 定义状态，保存上一次的温度值
    63.         private ValueState lastTempState;
    64.  
    65.         @Override
    66.         public void open(Configuration parameters) throws Exception {
    67.             lastTempState = getRuntimeContext().getState(new ValueStateDescriptor("last-temp", Double.class));
    68.         }
    69.  
    70.         @Override
    71.         public void flatMap(SensorReading value, Collector> out) throws Exception {
    72.             // 获取状态
    73.             Double lastTemp = lastTempState.value();
    74.  
    75.             // 如果状态不为null，那么就判断两次温度差值
    76.             if( lastTemp != null ){
    77.                 Double diff = Math.abs( value.getTemperature() - lastTemp );
    78.                 if( diff >= threshold )
    79.                     out.collect(new Tuple3<>(value.getId(), lastTemp, value.getTemperature()));
    80.             }
    81.  
    82.             // 更新状态
    83.             lastTempState.update(value.getTemperature());
    84.         }
    85.  
    86.         @Override
    87.         public void close() throws Exception {
    88.             lastTempState.clear();
    89.         }
    90.     }
    91. }
    1. sensor_1,1547718206,36.3
    2. sensor_1,1547718206,37.9
    3. sensor_1,1547718206,48
    4. sensor_6,1547718201,15.4
    5. sensor_6,1547718201,35
    6. sensor_1,1547718226,36

     状态后端

    1. 状态后端： 1.本地的状态管理(如何存，上下文配置，怎么存，怎么写)  
    2.          2.做快照容错，如何恢复数据

    1. 1. 测试环境：MemoryStateBackend
    2. 2. 生产环境：FsStateBackend 
    3. 3. 数据非常大时候：RocksDBStateBackend
    1. state.backend: filesystem //默认使用FsStateBackend 
    2. tate.checkpoints.dir: hdfs://namenode-host:port/flink-checkpoints 
    3. //配置一个checkpoint的hdfs的存储路径
    4.  
    5. jobmanager.execution.failover-strategy: region //区域化重启
    6.  
    7. state.backend.incremental: false  //增量添加checkpoint

  • 相关阅读:
    python学习27
    java-net-php-python-springboot宿舍管理计算机毕业设计程序
    再谈谷歌GMS认证之Android 13
    全力助推徐工集团转型升级，迅镭激光智能装备展现硬核实力！
    CASIO4800线路坐标计算程序(1)
    uniapp上传头像并裁剪图片
    矩阵秩的定义和相关结论汇总
    MySQL基本语句操作
    git push 错误
    若依微服务特殊字符串被过滤的解决办法
  • 原文地址：https://blog.csdn.net/wanglvip/article/details/132664217