练习 ： Flink TimeWindow 滑动 滚动 窗口 增量 全量 统计

import org.apache.commons.collections.IteratorUtils;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple4;
import org.apache.flink.streaming.api.TimeCharacteristic;
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.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;


public class TimeWindow1 {
    public static void main(String[] args) throws Exception {
        //Flink环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置并行度
        env.setParallelism(1);
        //时间语义：处理时间
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
        //加载套接字数据源
        DataStreamSource<String> source = env.socketTextStream("hadoop106", 9999);
        //将数据流切割，封装成传感器对象
        SingleOutputStreamOperator<Sensor> map = source.map(new MapFunction<String, Sensor>() {
            @Override
            public Sensor map(String s) throws Exception {
                String[] split = s.split(",");
                return new Sensor(split[0], Long.valueOf(split[1]), Double.valueOf(split[2]));
            }
        });

        //10s内最低温度
        map.keyBy(new KeySelector<Sensor, String>() {
            @Override
            public String getKey(Sensor sensor) throws Exception {
                return sensor.getSensor_id();
            }
        }).timeWindow(Time.seconds(10)).minBy("sensor_Temp").print();

        //增量统计 10s内 传感器消息次数
        map.keyBy("sensor_id").timeWindow(Time.seconds(10)).aggregate(new AggregateFunction<Sensor, Tuple2<Sensor,Integer>, String>() {
            @Override
            public Tuple2<Sensor, Integer> createAccumulator() {
                return new Tuple2<>(new Sensor(),0);
            }
            @Override
            public Tuple2<Sensor, Integer> add(Sensor sensor, Tuple2<Sensor, Integer> t) {
                return new Tuple2<>(sensor,t.f1+1);
            }
            @Override
            public String getResult(Tuple2<Sensor, Integer> t) {
                return t.f0.getSensor_id()+":"+t.f1;
            }
            @Override
            public Tuple2<Sensor, Integer> merge(Tuple2<Sensor, Integer> acc, Tuple2<Sensor, Integer> acc1) {
                return new Tuple2<>(acc.f0,acc1.f1+acc.f1);
            }
        }).print();

        //全量统计 各个温度计 开始 结束 时间 总温度
        map.keyBy("sensor_id").timeWindow(Time.seconds(10)).apply(new WindowFunction<Sensor, Tuple4<String,Long,Long,Integer>, Tuple, TimeWindow>() {
            @Override
            public void apply(Tuple tuple, TimeWindow window, Iterable<Sensor> iterable, Collector<Tuple4<String, Long, Long, Integer>> collector) throws Exception {
                String field = tuple.getField(0);
                long start = window.getStart();
                long end = window.getEnd();
                int total = IteratorUtils.toList(iterable.iterator()).size();
                collector.collect(new Tuple4<>(field,start,end,total));
            }
        }).print();

        env.execute();
    }
}

import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.TimeCharacteristic;
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.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.time.Time;

public class TimeWindow2 {
    public static void main(String[] args) throws Exception {
        //环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
        //数据源
        DataStreamSource<String> hadoop106 = env.socketTextStream("hadoop106", 9999);
        SingleOutputStreamOperator<Sensor> map = hadoop106.map(new MapFunction<String, Sensor>() {
            @Override
            public Sensor map(String s) throws Exception {
                String[] split = s.split(",");
                return new Sensor(split[0], Long.valueOf(split[1]), Double.valueOf(split[2]));
            }
        });
        //水位线 3s
        SingleOutputStreamOperator<Sensor> ope = map.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Sensor>(Time.seconds(3)) {
            @Override
            public long extractTimestamp(Sensor sensor) {
                return sensor.getSensor_timeStamp();
            }
        });
        //使用滑动窗口，10s步长，5s滑动一次，每10秒的统计温度最大值
        ope.keyBy("sensor_id").timeWindow(Time.seconds(10),Time.seconds(5)).max("sensor_Temp").print();

        //使用滑动窗口，10s步长，5s滑动一次，增量统计平均温度
        SingleOutputStreamOperator<Tuple2<String, Double>> avg = map.keyBy("sensor_id").timeWindow(Time.seconds(10)).aggregate(new AggregateFunction<Sensor, Tuple3<Sensor, Integer, Double>, Tuple2<String, Double>>() {
            @Override
            public Tuple3<Sensor, Integer, Double> createAccumulator() {
                return new Tuple3<>(new Sensor(), 0, 0.0);
            }
            @Override
            public Tuple3<Sensor, Integer, Double> add(Sensor sensor, Tuple3<Sensor, Integer, Double> t) {
                return new Tuple3<>(sensor, t.f1 + 1, t.f2+sensor.getSensor_Temp());
            }
            @Override
            public Tuple2<String, Double> getResult(Tuple3<Sensor, Integer, Double> t) {
                return new Tuple2<>( t.f0.getSensor_id(), t.f2*1.0 / t.f1);
            }
            @Override
            public Tuple3<Sensor, Integer, Double> merge(Tuple3<Sensor, Integer, Double> acc, Tuple3<Sensor, Integer, Double> acc1) {
                return new Tuple3<>(acc.f0, acc.f1 + acc1.f1, acc.f2 + acc1.f2);
            }
        });
        avg.print();
        env.execute();

    }
}