Flink实现连续数据异常预警-定时器

通过一个小需求的开发来简明Flink定时器的应用。

一、需求说明：

对水库的数据进行实时监测，如果10秒内水位线没有下降，则做预警输出。

数据使用socket进行模拟，数据包含 传感器编号/时间戳/水位 三个字段。

实现逻辑说明如下图：

数据1实时进来，第一条数据水位线为1米，建立定时器，第四条数据在10秒内进来，并且水位降低，则删除定时器，随即后续无任何再操作。

数据2实时进来，第一条数据水位线为1米，建立定时器，第四条数据在第10秒进来，10秒内水位无下降，出发定时器的规则，在侧输出流输出预警提示。

二、实现过程：

1. 结果展示
   
   
2. 建立bean实体类，用来对应数据：

package bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
 * 水位传感器：用于接收水位数据
 *
 * id:传感器编号
 * ts:时间戳
 * vc:水位
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class WaterSensor {
    private String id;
    private Long ts;
    private Integer vc;
}

3. 主类实现对数据的接收及处理

package com.test.timer;

import bean.WaterSensor;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
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.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
import java.time.Duration;
/**
 * @author: Rango
 * @create: 2021-05-07 10:14
 * @description: Flink定时器处理10秒内连续下降数据
 **/
public class TimeStateApp {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        DataStreamSource<String> hadoop102 = env.socketTextStream("hadoop102", 9999);
        SingleOutputStreamOperator<WaterSensor> streamOperator = hadoop102.map(new MapFunction<String, WaterSensor>() {
            @Override
            public WaterSensor map(String value) throws Exception {
                String[] split = value.split(",");
                return new WaterSensor(split[0], Long.parseLong(split[1]), Integer.parseInt(split[2]));
            }
        });
        //定义时间语义
        WatermarkStrategy<WaterSensor> wms = WatermarkStrategy
                .<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                .withTimestampAssigner(
                        new SerializableTimestampAssigner<WaterSensor>() {
                            @Override
                            public long extractTimestamp(WaterSensor element, long recordTimestamp) {
                                return element.getTs() * 1000L;
                            }
                        }
                );
        //指定策略、分组、处理
        SingleOutputStreamOperator<WaterSensor> outputStreamOperator = streamOperator
                .assignTimestampsAndWatermarks(wms)
                .keyBy(WaterSensor::getId)
                .process(new KeyedProcessFunction<String, WaterSensor, WaterSensor>() {

                    //定义状态
                    private ValueState<Long> tsState;
                    private ValueState<Integer> vcState;

                    //状态在open方法实现初始化
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        tsState = getRuntimeContext().getState(new ValueStateDescriptor<Long>("state-ts", Long.class));
                        vcState = getRuntimeContext().getState(new ValueStateDescriptor<Integer>("state-vc", Integer.class));
                    }

                    @Override
                    public void processElement(WaterSensor value, Context ctx, Collector<WaterSensor> out) throws Exception {
                        //ValueStateDescriptor方法已经弃用使用默认值，故在此判断
                        if (vcState.value() == null) {
                            vcState.update(Integer.MIN_VALUE);
                        }
                        //获取值
                        Long TimerTS = tsState.value();
                        Integer lastVC = vcState.value();
                        Integer currVC = value.getVc();

                        //对水位进行判断，注意删除定时器使用的时间
                        if (currVC > lastVC && TimerTS == null) {
                            System.out.println(value.getId() + "：注册定时器！");
                            Long ts = ctx.timerService().currentProcessingTime() + 10000L;
                            ctx.timerService().registerProcessingTimeTimer(ts);
                            tsState.update(ts);
                        } else if (value.getVc() <= lastVC && TimerTS != null) {
                            System.out.println(value.getId() +"：删除定时器！");
                            ctx.timerService().deleteProcessingTimeTimer(TimerTS);
                            tsState.clear();
                        }
                        vcState.update(currVC);
                        out.collect(value);
                    }
                    //定时器触发后的操作
                    @Override
                    public void onTimer(long timestamp, OnTimerContext ctx, Collector<WaterSensor> out) throws Exception {
                        ctx.output(new OutputTag<String>("outsideput") {}
                                , ctx.getCurrentKey() + "水位连续10秒没有下降！！！");
                    }});

        outputStreamOperator.print("主流>>>>>");
        outputStreamOperator.getSideOutput(new OutputTag<String>("outsideput"){}).print("侧输出流>>>>>");

        env.execute();
    }
}

4. 依赖说明
   Flink及lombok相关依赖即可。

---

学习交流，有任何问题还请随时评论指出交流。