devbox
爱喝兽奶帝天荒
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Flink动态开窗——根据缓存的规则信息动态设置窗口size_flink动态窗口

作者：爱喝兽奶帝天荒 | 2024-08-23 03:24:29

赞

踩

flink动态窗口

背景

        这里做法参考了Flink动态窗口(二)_dynamictumbling-CSDN博客

        业务场景是需要根据用户配置规则对日志数据流动态地进行开窗计算，但是flink sql和datastream目前都不支持传入动态参数的开窗方法。

        这里仅仅是测通了测试数据，先简单记录下的方法，应用到实际场景中可能还有较多需要测试、调整和优化的地方，比如缓存管理、自定义类缺乏通用性、类型安全以及资源消耗等等潜在问题。

解决思路

维表信息缓存

        首先，数据流中的size字段可以根据规则配置表的更新频率选择flink table api中合适的join策略，或者自行设计维表状态的管理。本文是测试，主数据和维表数据量均不大，因此先采用guava cache缓存维表的方式，连接外部数据源（示例为mysql），自定义一个RichMapFunction类使数据通过一个map和filter获取到维表中记录的规则（所需窗口size）信息。自定义GetRuleMapFunction如下：

  1. import java.io.*;
  2. import com.alibaba.druid.pool.DruidDataSource;
  3. import com.google.common.cache.CacheBuilder;
  4. import com.google.common.cache.CacheLoader;
  5. import com.google.common.cache.LoadingCache;
  6. import org.apache.flink.api.common.functions.RichMapFunction;
  7. import org.apache.flink.api.java.tuple.*;
  8. import org.apache.flink.configuration.Configuration;
  9. import java.sql.Connection;
  10. import java.sql.PreparedStatement;
  11. import java.sql.ResultSet;
  12. import java.sql.SQLException;
  13. import java.util.Properties;
  14. import java.util.concurrent.TimeUnit;
  15.  
  16. public class GetRuleMapFunction extends RichMapFunction<Tuple3<String, String, Integer>,Tuple4<String, String, String, Integer>> {
  17.     private LoadingCache<String, String> cache;
  18.     private DruidDataSource dbsource;
  19.     private Properties properties;
  20.  
  21.     @Override
  22.     public void open(Configuration parameters) throws Exception {
  23.         super.open(parameters);
  24.         //创建连接池
  25.         File file = new File("./src/main/resources/mysql_config.properties");
  26.         properties = new Properties();
  27.         properties.load(new FileInputStream(file));
  28.         dbsource=new DruidDataSource();
  29.         dbsource.configFromPropety(properties);
  30.         //创建缓存
  31.         cache = CacheBuilder.newBuilder()
  32.                 .concurrencyLevel(3)
  33.                 .initialCapacity(3)
  34.                 .maximumSize(20)
  35.                 .expireAfterWrite(1, TimeUnit.HOURS)
  36.                 .build(new CacheLoader<String, String>() {
  37.                     @Override
  38.                     public String load(String key) throws Exception {
  39.                         //设置数据库查询，放入缓存中
  40.                         String sql = "select rule from rule_table_for_flink_test where name='" + key + "'";
  41.                         PreparedStatement statement = null;
  42.                         ResultSet resultset = null;
  43.                         Connection conn = null;
  44.                         String res = "0";
  45.                         try {
  46.                             conn = dbsource.getConnection();
  47.                             statement = conn.prepareStatement(sql);
  48.                             resultset = statement.executeQuery();
  49.                             while (resultset.next()) {
  50.                                 res = resultset.getString("rule");
  51.                             }
  52.                         } catch (SQLException e) {e.printStackTrace();}
  53.                         finally { try
  54.                             { if (resultset != null) resultset.close();
  55.                                 if (statement != null) statement.close();
  56.                                 if (conn != null) conn.close();
  57.                             } catch (SQLException e) {e.printStackTrace();}
  58.                             return res;}
  59.                     }
  60.                 });
  61.     }
  62.  
  63.     @Override
  64.     public Tuple4<String, String, String, Integer> map(Tuple3<String, String, Integer> event) throws Exception {
  65.         String eventkey= event.f0;
  66.         String res=cache.get(eventkey);
  67.         return Tuple4.of(event.f0,res,event.f1,event.f2);
  68.     }
  69.     public void close() throws Exception {
  70.         super.close();
  71.         dbsource.close();
  72.         cache.cleanUp();
  73.     }
  74. }

根据记录中指定字段动态开窗

        在解决维表信息的缓存（为每笔数据记录打上所适用的开窗size属性）之后，我们将问题简述为在同一个数据流中，针对数据的某固定字段判断该数据属于哪个对象、配置规则并以此为依据开窗。那么我们需要有一定理解基础的是：

        1.如果要响应以上场景需求，不难想明白，我们必然是要根据“业务对象”、“规则配置”这两个属性（字段）来进行keyby的，因为配置规则实际上是在业务对象的维度上再开一个新维度；

        2.需要明白datastream的窗口分配器（WindowAssigner）是如何运作的，给每笔数据记录分配窗口的，了解之后会发现关键步骤在assignWindows方法中。

        在了解上述两点后，实际上改动最小的解决思路就比较清楚了，就是可以模仿flink原生的窗口分配器（比如SlidingEventTimeWindows，本文将以滑动窗口为例），稍作修，构造一个可以动态传参的自定义窗口分配器类，核心部分在于修改assignWindows，维护好该窗口的可用性即可。需要注意的是泛型问题，需要处理好Trigger方法的泛型，因此需要再造一个EventTimeTrigger（直接抄就可以），并维护好该类中的泛型。

细节记录

        1.窗口起点公式：（last）Start=timestamp-(timestamp-offset+windowSize)%windowSize

        上述公式中的windowSize，在滚动窗口中是size；在滑动窗口中可能分发给多个窗口，因此windowSize设为slide，计算得到的Start根据分发情况向前移动slide的距离，直到窗口不再包含当前记录的timestamp，因此滑动窗口的第一笔起始时间容易表现为Start再向前偏移一个slide，思考窗口逻辑或者观察测试结果其实是比较好理解其中原由的。
        2.窗口是前闭后开的（End是Start+size-1毫秒）。
        3.print后发现WindowedStream中（除了聚合值）记录的是每个窗口的第一个元素的值。

具体示例

数据准备

        这里做个简单的实例，我们准备一个本地文本./src/main/resources/test_data0做数据输入流，数据内容大致下：

ailurus,2023-11-10 12:12:31
beaver,2023-11-10 12:12:31
civet,2023-11-10 12:12:31
ailurus,2023-11-10 12:12:32
beaver,2023-11-10 12:12:32
...
ailurus,2023-11-10 12:12:49
ailurus,2023-11-10 12:12:50
ailurus,2023-11-10 12:12:51
elephent,2023-11-10 12:12:55

       size维表存于mysql，注意记得给关联键加索引，大概格式如下：

两个抄出来并自定义的类

        DySlidingEventTimeWindows(大部分是抄源码，理解本文上面提到的点就很容易清楚哪些地方需要修改和如何修改了)：

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.List;
  4. import org.apache.flink.annotation.PublicEvolving;
  5. import org.apache.flink.api.common.ExecutionConfig;
  6. import org.apache.flink.api.common.typeutils.TypeSerializer;
  7. import org.apache.flink.api.java.tuple.Tuple;
  8. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
  9. import org.apache.flink.streaming.api.windowing.assigners.WindowAssigner;
  10. import org.apache.flink.streaming.api.windowing.time.Time;
  11. import org.apache.flink.streaming.api.windowing.triggers.Trigger;
  12. import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
  13.  
  14. @PublicEvolving
  15. public class DySlidingEventTimeWindows extends WindowAssigner<Tuple, TimeWindow> {
  16.     private static final long serialVersionUID = 1L;
  17.     private final int index;
  18.     private long size;
  19.     private final long slide;
  20.     private final long offset;
  21.  
  22.     protected DySlidingEventTimeWindows(int index, long slide, long offset) {
  23.         if (Math.abs(offset) < slide) {
  24.             this.index = index;
  25.             this.slide = slide;
  26.             this.offset = offset;
  27.         } else {
  28.             throw new IllegalArgumentException("SlidingEventTimeWindows parameters must satisfy abs(offset) < slide and size > 0");
  29.         }
  30.     }
  31.  
  32.     //重点就在此方法上，其中element是记录，timestamp是数据时间（处理时间或事件时间），context为上下文
  33.     public Collection<TimeWindow> assignWindows(Tuple element, long timestamp, WindowAssignerContext context) {
  34.         this.size=Time.seconds(Long.parseLong(element.getField(this.index).toString())).toMilliseconds();
  35.         if (timestamp <= -9223372036854775808L) {
  36.             throw new RuntimeException("Record has Long.MIN_VALUE timestamp (= no timestamp marker). Is the time characteristic set to 'ProcessingTime', or did you forget to call 'DataStream.assignTimestampsAndWatermarks(...)'?");
  37.         } else {
  38.             List<TimeWindow> windows = new ArrayList((int)(this.size / this.slide));
  39.             long lastStart = TimeWindow.getWindowStartWithOffset(timestamp, this.offset, this.slide);
  40.  
  41.             for(long start = lastStart; start > timestamp - this.size; start -= this.slide) {
  42.                 windows.add(new TimeWindow(start, start + this.size));
  43.             }
  44.  
  45.             return windows;
  46.         }
  47.     }
  48.  
  49.     public long getSize() {
  50.         return this.size;
  51.     }
  52.  
  53.     public long getSlide() {
  54.         return this.slide;
  55.     }
  56.  
  57.     public Trigger<Tuple, TimeWindow> getDefaultTrigger(StreamExecutionEnvironment env) {
  58.         return RowEventTimeTrigger.create();
  59.     }
  60.  
  61.     public String toString() {
  62.         return "SlidingEventTimeWindows(" + this.size + ", " + this.slide + ")";
  63.     }
  64.  
  65.     public static DySlidingEventTimeWindows of(int index , Time slide) {
  66.         return new org.example.util.DySlidingEventTimeWindows(index , slide.toMilliseconds(), 0L);
  67.     }
  68.  
  69.     public static DySlidingEventTimeWindows of(int index, Time slide, Time offset) {
  70.         return new org.example.util.DySlidingEventTimeWindows(index , slide.toMilliseconds(), offset.toMilliseconds());
  71.     }
  72.  
  73.     public TypeSerializer<TimeWindow> getWindowSerializer(ExecutionConfig executionConfig) {
  74.         return new TimeWindow.Serializer();
  75.     }
  76.  
  77.     public boolean isEventTime() {
  78.         return true;
  79.     }
  80. }

        RowEventTimeTrigger就不贴了，纯粹是抄了来改下泛型就用的。

Flink运行代码

         运行作业。

  1. import org.apache.flink.api.common.typeinfo.Types;
  2. import org.apache.flink.api.java.functions.KeySelector;
  3. import org.apache.flink.api.java.tuple.*;
  4. import org.apache.flink.api.common.eventtime.WatermarkStrategy;
  5. import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
  6. import org.apache.flink.streaming.api.windowing.time.Time;
  7. import org.apache.flink.streaming.api.datastream.*;
  8. import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
  9. import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
  10. import org.apache.flink.connector.jdbc.JdbcSink;
  11. import java.text.ParseException;
  12. import java.text.SimpleDateFormat;
  13. import java.time.Duration;
  14. import org.example.util.DySlidingEventTimeWindows;
  15. import org.example.util.GetRuleMapFunction;
  16.  
  17. public class TestZyc {
  18.     public static void main(String[] args) throws Exception {
  19.         StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
  20.         env.setParallelism(1);
  21.         //创建数源（读取TextFile）
  22.         DataStreamSource<String> datasource = env.readTextFile("./src/main/resources/test_data0");
  23.         // 转换数据格式，这里转成常见结构化数据tuple类型
  24.         SingleOutputStreamOperator<Tuple3<String,String,Integer>> dataStream = datasource
  25.                 .map((String line) -> {
  26.                     String[] fields = line.split(",");
  27.                     return Tuple3.of(fields[0],fields[1],1);
  28.                 }).returns(Types.TUPLE(Types.STRING, Types.STRING,Types.INT))
  29.                 //设置事件时间、水位线
  30.                 //实际上本例中水位线并不会按预期工作，因为数源是静态文件，会被flink视为批处理
  31.                 .assignTimestampsAndWatermarks(
  32.                         WatermarkStrategy.<Tuple3<String,String,Integer>>forBoundedOutOfOrderness(Duration.ofMillis(10)).withTimestampAssigner(
  33.                                 new SerializableTimestampAssigner<Tuple3<String,String,Integer>>() {
  34.                                     final SimpleDateFormat srtformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  35.                                     @Override
  36.                                     public long extractTimestamp(Tuple3<String,String,Integer>element, long recordTimestamp){
  37.                                         try {
  38.                                             return srtformat.parse(element.f1).getTime();
  39.                                         } catch (ParseException e) {
  40.                                             e.printStackTrace();
  41. //                                            System.out.println("日期无法解析，使用recordTimestamp");
  42.                                         } return recordTimestamp;
  43.                                     }
  44.                                 })
  45.                         );
  46.         //map配置信息并过滤
  47.         DataStream<Tuple4<String, String, String, Integer>> mapedStream=dataStream
  48.         .map(new GetRuleMapFunction()).filter(event -> event.f1!="0");
  49.         //keyby操作
  50.         SingleOutputStreamOperator<Tuple4<String,String,String,Integer>> finalStream=mapedStream.keyBy(
  51.                 new KeySelector<Tuple4<String,String,String,Integer>,Tuple2<String,String>>() {
  52.                     @Override
  53.                     public Tuple2<String, String> getKey(Tuple4<String, String, String, Integer> stringIntegerTuple4) throws Exception {
  54.                         return Tuple2.of(stringIntegerTuple4.f0, stringIntegerTuple4.f1);
  55.                     }
  56.                 }
  57.         )
  58.         //动态size开窗，传参为size属性下标、slide大小[、offset大小]
  59.         .window(DySlidingEventTimeWindows.of(1,Time.seconds(2)))
  60.         //聚合计算，传参为需要计算属性的下标
  61.         .sum(3);
  62.         //可以打印
  63.         finalStream.print();
  64.  
  65.         // //也可以添加SINK端，这里简单以myqsql为例
  66.         // String insert_sql = "INSERT INTO table_for_flink_sink (name,rule,eventtime,cnt) VALUE (?,?,?,?)";
  67.         // finalStream.addSink(JdbcSink.sink(
  68.         //         insert_sql,
  69.         //         ((statement, event) -> {
  70.         //             statement.setString(1, event.f0);
  71.         //             statement.setString(2, event.f1);
  72.         //             statement.setString(3, event.f2);
  73.         //             statement.setInt(4, event.f3);
  74.         //         }),
  75.         //         new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
  76.         //                 .withDriverName("com.mysql.cj.jdbc.Driver")
  77.         //                 .withUrl("jdbc:mysql://ServerIP:Port/Database")
  78.         //                 .withUsername("username")
  79.         //                 .withPassword("password")
  80.         //                 .build()
  81.         // ));
  82.  
  83.         //执行
  84.         env.execute();
  85.     }
  86. }

结尾

        测试结果是满足需求的（这里就不做展示了），其中还是有些细节的，可以检索校相关文章配合理解（作者也是边写边看了很多）。

        但是怎么看都感觉比较raw，这里建议可以结合Table API进行使用，更安全也更容易贴近实际的业务环境（尤其是join部分），虽然目前必须转datastream的地方可能还是得折腾下。另外动态开窗在维表数据量大且没有限制的情况下会引起可以想象到的灾难问题，所以建议在上游做好主数据和维表数据的控制和管理，事前避免潜在的异常情况。

        PS.相反的，如果考虑更灵活的解决方式，可以根据需要求实现一个KeyedProcessFunction类（只有KeyedProcessFunction可以注册定时器），在其open中创建并管理一个状态缓存（准备用来缓存窗口对象），接着在processElement中根据每笔数据记录的ctx.timestamp注册定时器（同时更新状态缓存里命中窗口的状态），最后在onTimer中进行状态的计算并进行输出（输出缓存中符合本次触发条件的窗口状态，并清理已结束的窗口缓存）。当然这种方式更加底层，将面临很多需要维护的问题。

        PSS.备忘下Table或SQL API中DataStream转Table的语法：

  1. import org.apache.flink.table.api.Table;
  2. import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
  3.  
  4. StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env, environmentSettings);
  5.  
  6. Table table = tableEnv.fromDataStream(dataStream,
  7.         Schema.newBuilder()
  8.             .column("f0", DataTypes.STRING().notNull())
  9.             .column("f1", DataTypes.STRING().notNull())
  10.             .column("f2", DataTypes.INT())
  11.             .primaryKey("f0","f1")
  12.              //指定处理时间
  13.             .columnByExpression("proctime","PROCTIME()")
  14. //           //指定事件时间
  15. //          .columnByExpression("rowtime","CAST(TO_TIMESTAMP(FROM_UNIXTIME(UNIX_TIMESTAMP(`f1`))) AS TIMESTAMP(3))")
  16. //          .watermark("rowtime","rowtime - interval '0' SECOND ")
  17.         .build()).as("id,time,cnt");
  18.  
  19. tableEnv.createTemporaryView("main_stream", table);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/爱喝兽奶帝天荒/article/detail/1019252
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号