• Flink 实时数仓（七）【DWS 层搭建（一）流量域汇总表创建】

    前言

            今天开始 DWS 层的搭建，不知不觉又是周一，都忘了昨天是周末，近两年对我来说，周六日晚上八九点能打一小会篮球就算一周的休息了。不得不说自己真的是天生打工体质，每天不管多累，晚上十二点睡，第二天六点多七点准时自然醒，依然精神焕发，中午都不带困的；那既然老天给我这个特质让我像牛一样可以不知疲倦的工作，那我也希望是让我在热爱的领域发光发热；那既然这样，总得先让我找到个满意的工作吧哈哈哈 ...

    1、DWS 层搭建

    设计要点：

    • DWS层的设计参考指标体系（需求驱动）；（前面的 DIM 和 DWD 的设计都是参考建模理论，是业务驱动）
    • DWS层表名的命名规范为dws_数据域_统计粒度_业务过程_统计周期（window）

            离线数仓中的 DWS 层的统计周期我们当时做的是 1/7/30 ，那实时数仓的统计周期当然不能这么大；离线数仓中每一天就相当于一个窗口，而在实时数仓当中，窗口都是秒级别的，我们这里开窗的大小选择 10 s，因为我们的可视化平台只能 10s 刷新一次，开得太小没有意义；（生产环境中可以更小比如 1s ，甚至可以不开窗。开窗还是不开窗是性能和时效性的取舍）

    1.1、流量域来源关键词粒度页面浏览各窗口汇总表

    主要任务：

            从 Kafka 页面浏览明细（dwd_traffic_page_log）主题读取数据，过滤搜索行为，使用自定义 UDTF（一进多出）函数对搜索内容分词。统计各窗口各关键词出现频次，写入 ClickHouse。

    1.1.1、思路分析

    • 在 DWD 层，我们对日志根据日志类型进行了分流，写入到了 5 个不同的主题当中
    • 现在我们需要统计搜索内容中的关键词，所以需要消费页面浏览日志
    • 使用分词器将搜索内容分为多个关键词
    • 划分窗口，词频统计后存储进 clickhouse

    思考：既然用到分词，为啥不直接用 ES 存呢？

    答：确实是要分词，但是我们这里是要做词频统计，ES 是对关键词做索引，相当于用 key（关键词）去获得 value（文档），而我们这里是要对 key 进行统计，所以不合适；

    1.1.2、代码实现

    1）IK 分词器工具类
    1. public class KeywordUtil {
    2.     public static List analyze(String text){
    3.         // 创建集合用于存放切分或的数据
    4.         List keywordList = new ArrayList<>();
    5.         // 封装待分词内容
    6.         StringReader reader = new StringReader(text);
    7.         // 创建 IK 分词器(ik_smart 智能分词,ik_max_word: 尽可能分最多的词)
    8.         IKSegmenter ikSegmenter = new IKSegmenter(reader,true);
    9.         try {
    10.             // 取出切分好的词
    11.             Lexeme lexeme = null;
    12.             while((lexeme = ikSegmenter.next())!=null){
    13.                 String keyword = lexeme.getLexemeText();
    14.                 keywordList.add(keyword);
    15.             }
    16.         } catch (IOException e) {
    17.             e.printStackTrace();
    18.         }
    19.         return keywordList;
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         List list = analyze("Apple iPhoneXSMax (A2104) 256GB 深空灰色 移动联通电信4G手机 双卡双待");
    24.         System.out.println(list);
    25.     }
    26. }
    2）自定义 UDTF
    1. @FunctionHint(output = @DataTypeHint("ROW"))
    2. public class IkUDTF extends TableFunction {
    3.     public void eval(String str){
    4.         for (String word : KeywordUtil.analyze(str)) {
    5.             collect(Row.of(word));
    6.         }
    7.     }
    8. }
    3） 消费页面浏览日志主题

    我们相当于一个消费者去消费页面浏览主题，那么就需要先创建该表，也就需要先确定我们要的字段。在事件时间语义下使用窗口函数的时候我们需要指定事件时间的字段；

    前面我们为了 join lookup 表的时候那样（要想 join lookup 表，必须要有一个处理时间字段）：

     只不过我们现在需要指定一个事件时间，我们同样可以通过 DDL 中来指定：

    对于这里的关键词需求而言，我们不需要保留 common 字段，所以建表如下： 

    1. ​
    2. // TODO 3. 消费 Kafka dwd_traffic_page_log 主题
    3.         String groupId = "dws_traffic_source_keyword_page_view_window";
    4.         tableEnv.executeSql(
    5.                 "CREATE TABLE dwd_traffic_page_log " +
    6.                         "       page map, " +
    7.                         "       ts bigint , " +
    8.                         "       time_ltz AS TO_TIMESTAMP(FROM_UNIXTIME(ts/1000)), " +
    9.                         "       WATERMARK FOR time_ltz AS time_ltz - INTERVAL '2' SECOND " +
    10.                         MyKafkaUtil.getKafkaDDL("dwd_traffic_page_log", groupId));
    11.  
    12. ​

    这里我们指定了 time_ltz 为事件时间字段以及乱序延迟时间最大为 2s，这里为什么不直接使用 ts 字段呢？这是因为 json 默认把数值类型都当做 bigint 来处理，而 Flink SQL 中，表的事件时间必须为 timestamp 类型，所以我们需要进行转换；

    注意：建表语句中尽量加 AS ，尤其字段涉及函数！

    4）过滤出搜索数据
    1. // TODO 4. 过滤出搜索数据
    2. Table searchLog = tableEnv.sqlQuery("SELECT " +
    3.         "page['item'] item, " +
    4.         "time_ltz " +
    5.         "FROM dwd_traffic_page_log " +
    6.         "WHERE page['last_page_id' = 'search'] " +
    7.         "AND page['item_type'] = 'keyword' " +
    8.         "AND page['item'] is not null "
    9. );
    10. tableEnv.createTemporaryView("search_log_table",searchLog);
    5）注册 udtf 函数并进行分词
    1. // TODO 5. 注册 udtf & 分词
    2. tableEnv.createTemporaryFunction("ik", IkUDTF.class);
    3. Table splitTable = tableEnv.sqlQuery("SELECT " +
    4.         "word, " +
    5.         "time_ltz " +
    6.         "FROM search_log_table " +
    7.         "LATERAL TABLE(ik(item))"
    8. );
    9. tableEnv.createTemporaryView("split_table",splitTable);
    6）分组、开窗、聚合

    之前离线数仓写过窗口函数，但是都是没有边界的窗口。这里我们学习一下 Flink 中的三种窗口怎么用 Flink SQL 去写：

    上面三种窗口分别对应：滚动，滑动和会话，下面是使用案例：

    现在我们需要考虑将来写入到 ck 时，ck 应该采用什么引擎？

    • 选择 SummingMergeTree
      • 优点：自动预聚合，存储的内容少了，查询效率高
      • 缺点：只能做求和指标，比如峰值指标就做不了。再有假如数据消费后挂了（Flink 读取后数据写入到 ck 了，但是这时候挂了，Flink 恢复后会重新消费，ck 就会重复处理。如果是别的引擎还好，因为数据不是聚合的状态，而是一条一条存储的，我们可以对数据根据 uuid 进行区分是否已经处理过）
    • 选择ReplacingMergeTree
      • 它有去重的功能，但是是在任务挂掉的时候我们才用得到（保证一致性）
      • 可以做更多的指标
      • 缺点就是会存储更多的数据

    那么，我们当然选择 ReplacingMergeTree ，现在我们需要考虑去重字段（在 ck 中去重字段比主键都重要）：

    • 去重（order by 字段）：
      • 根据 窗口时间（起始+终止）+关键词 进行去重（这里会添加一个 source 字段区分日志的来源，比如 search、cart、order）

    窗口的起始和终止时间同样有特定的函数来获取：

    最终，我们的代码：

    1.         // TODO 6. 分组、开窗、聚合
    2.         Table resultTable = tableEnv.sqlQuery("SELECT " +
    3.                 "    date_format(tumble_start(time_ltz,interval '10' second),'yyyy-MM-dd HH:mm:ss') stt," +
    4.                 "    date_format(tumble_end(time_ltz,interval '10' second),'yyyy-MM-dd HH:mm:ss') edt," +
    5.                 "    'search' source," +
    6.                 "    word keyword," +
    7.                 "    count(*) keyword_count," +
    8.                 "    unix_timestamp() ts" +
    9.                 "FROM split_table" +
    10.                 "GROUP BY word,tumble(time_ltz,interval '10' second)");
    7）创建 ck 表格
    1. create table if not exists dws_traffic_source_keyword_page_view_window
    2. (
    3.     stt           DateTime,
    4.     edt           DateTime,
    5.     source        String,
    6.     keyword       String,
    7.     keyword_count UInt64,
    8.     ts            UInt64
    9. ) engine = ReplacingMergeTree(ts)
    10.       partition by toYYYYMMDD(stt)
    11.       order by (stt, edt, source, keyword);
    8）ck 工具类

    上面第 6 步之后，我们得到了开窗聚合后的一个结果，要写入 ck 我们需要先将动态表转为流：

    1. // TODO 7. 将动态表转换为流
    2.         DataStream dataStream = tableEnv.toAppendStream(resultTable, KeywordBean.class);

    接着我们需要通过 JdbcSink 写出到 ck 集群中，因为之后每个聚合结果都是存在 DWS 层的，所以都会用到该 JdbcSink，所以我们统一封装成一个工具类：

    1. public class ClickHouseUtil {
    2.  
    3.     // 泛型方法需要再返回值类型前面放一个泛型
    4.     public static  SinkFunction getSinkFunction(String sql) {
    5.         return JdbcSink.sink(
    6.                 sql,
    7.                 new JdbcStatementBuilder() {
    8.                     @SneakyThrows
    9.                     @Override
    10.                     public void accept(PreparedStatement preparedStatement, T t) throws SQLException {
    11.                         // 利用反射获得 t 对象的属性
    12.                         Class tClz = t.getClass();
    13.                         int index = 1;
    14.                         for (Field field : tClz.getDeclaredFields()) {
    15.                             field.setAccessible(true); // 防止访问呢 private 属性失败
    16.                             // 尝试获得字段上的注解
    17.                             TransientSink transientSink = field.getAnnotation(TransientSink.class);
    18.                             if (transientSink != null){
    19.                                 continue;
    20.                             }
    21.                             // 获得字段值
    22.                             Object value = field.get(t);
    23.                             // 给占位符赋值
    24.                             preparedStatement.setObject(index++,value);
    25.                         }
    26.                     }
    27.                 }, new JdbcExecutionOptions.Builder()
    28.                         .withBatchSize(5)
    29.                         .withBatchIntervalMs(1000L)
    30.                         .build()
    31.                 , new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
    32.                         .withDriverName(GmallConfig.CLICKHOUSE_DRIVER)
    33.                         .withUrl(GmallConfig.CLICKHOUSE_URL)
    34.                         .build()
    35.         );
    36.     }
    37. }

    在代码中我们有一个获取注解的操作，是为了防止 JavaBean 中的字段（可能是辅助字段）在 ck 表中并没有能对应上的，所以我们通过注解来甄别：

    1. @Retention(RetentionPolicy.RUNTIME) // 生效时机: 运行时
    2. @Target(ElementType.FIELD) // 该注解的作用域: 属性上
    3. public @interface TransientSink {
    4.  
    5. }

    补全主程序： 

    1.         // TODO 8. 写入 clickhouse
    2.         // 插入字段顺序尽量和ck库的表保持一致
    3.         dataStream.addSink(ClickHouseUtil.getSinkFunction(
    4.                 "insert into dws_traffic_source_keyword_page_view_window " +
    5.                         "values(?,?,?,?,?,?)"
    6.         ));
    7.  
    8.         // TODO 9. 启动任务
    9.         env.execute("DwsTrafficSourceKeywordPageViewWindow");

    注意：因为我们是通过反射获取 Bean 对象字段来向 ck 表插入数据的，所以一定要保证 Bean 对象的顺序要和 ck 表对应上；

    1.2、流量域版本-渠道-地区-访客类别粒度页面浏览各窗口汇总表

    上面 DWS 的第一个需求我们是用 Flink SQL 来实现的，从这个需求开始，我们将使用 DataStream API 来实现；

    1.2.1、需求分析

    • 维度有 4 个：版本，渠道，地区和访客类别；
    • 度量值有 5 个：会话数、页面浏览数、浏览总时长、独立访客数、跳出会话数等；

            关于独立访客数和跳出会话数我们之前在 DWD 层已经实现并分别写入到了 dwd_traffic_unique_visitor_detail（状态编程保存 lastVisitDate 实现） 和 dwd_traffic_user_jump_detail（Flink CEP 实现） 主题了；所以这里只需要分析前 2 个度量值怎么计算：

    • 会话数
      • 我们的数据中没有 session_id，但是要求也很简单：last_page_id 为 null 即代表一个新会话的开始
    • 页面浏览数（PV）
      • 页面浏览记录中每一行数据就是一个浏览记录（count(1) ）
    • 浏览总时长
      • 还是从页面浏览记录中获取浏览时间（during_time）

    思考：这三个度量值都可以从 dwd_traffic_page_log 中一次计算出来，但是怎么和另外两个来自不同主题的度量值聚合呢？

    答：使用 join，根据 dws 表的粒度进行 join，但是在 SQL 中使用 join 的话也许好一点，可是我们使用 API 就比较复杂；所以其实我们还可以使用另一种方式实现——使用 union + 分组聚合也可以实现；

    那么最终写入到 ck 中的字段其实一共有 12 个：4个维度字段 + 5 个度量值 + ts + 窗口起始、终止时间字段；

    1.2.2、代码实现

    1）建表语句
    1. create table if not exists dws_traffic_vc_ch_ar_is_new_page_view_window
    2. (
    3.     stt     DateTime,
    4.     edt     DateTime,
    5.     vc      String,
    6.     ch      String,
    7.     ar      String,
    8.     is_new  String,
    9.     uv_ct   UInt64,
    10.     sv_ct   UInt64,
    11.     pv_ct   UInt64,
    12.     dur_sum UInt64,
    13.     uj_ct   UInt64,
    14.     ts      UInt64
    15. ) engine = ReplacingMergeTree(ts)
    16.       partition by toYYYYMMDD(stt)
    17.       order by (stt, edt, vc, ch, ar, is_new);
    2）创建 ck 表对应的 Bean
    1. import lombok.AllArgsConstructor;
    2. import lombok.Data;
    3.  
    4. @Data
    5. @AllArgsConstructor
    6. public class TrafficPageViewBean {
    7.     // 窗口起始时间
    8.     String stt;
    9.     // 窗口结束时间
    10.     String edt;
    11.     // app 版本号
    12.     String vc;
    13.     // 渠道
    14.     String ch;
    15.     // 地区
    16.     String ar;
    17.     // 新老访客状态标记
    18.     String isNew ;
    19.     // 独立访客数
    20.     Long uvCt;
    21.     // 会话数
    22.     Long svCt;
    23.     // 页面浏览数
    24.     Long pvCt;
    25.     // 累计访问时长
    26.     Long durSum;
    27.     // 跳出会话数
    28.     Long ujCt;
    29.     // 时间戳
    30.     Long ts;
    31. }
    3）读取三个主题的数据
    1.         // TODO 3. 读取三个主题的数据
    2.         String uvTopic = "dwd_traffic_unique_visitor_detail";
    3.         String ujdTopic = "dwd_traffic_user_jump_detail";
    4.         String topic = "dwd_traffic_page_log";
    5.         String groupId = "dws_traffic_channel_page_view_window";
    6.         DataStreamSource uvDS = env.addSource(MyKafkaUtil.getFlinkKafkaConsumer(uvTopic, groupId));
    7.         DataStreamSource ujdDS = env.addSource(MyKafkaUtil.getFlinkKafkaConsumer(ujdTopic, groupId));
    8.         DataStreamSource pageDS = env.addSource(MyKafkaUtil.getFlinkKafkaConsumer(topic, groupId));
    4）统一数据格式

    将 3 个主题的数据进行格式统一，方便后面 union + 聚合

    1.         // TODO 4. 统一数据格式
    2.         SingleOutputStreamOperator trafficWithUvDS = uvDS.map(line -> {
    3.             JSONObject jsonObject = JSONObject.parseObject(line);
    4.  
    5.             JSONObject common = jsonObject.getJSONObject("common");
    6.  
    7.             return new TrafficPageViewBean("", "",
    8.                     common.getString("vc"),
    9.                     common.getString("ch"),
    10.                     common.getString("ar"),
    11.                     common.getString("is_new"),
    12.                     1L, 0L, 0L, 0L, 0L,
    13.                     common.getLong("ts")
    14.             );
    15.         });
    16.         SingleOutputStreamOperator trafficWithUJ = ujdDS.map(line -> {
    17.             JSONObject jsonObject = JSONObject.parseObject(line);
    18.  
    19.             JSONObject common = jsonObject.getJSONObject("common");
    20.  
    21.             return new TrafficPageViewBean("", "",
    22.                     common.getString("vc"),
    23.                     common.getString("ch"),
    24.                     common.getString("ar"),
    25.                     common.getString("is_new"),
    26.                     0L, 0L, 0L, 0L, 1L,
    27.                     common.getLong("ts")
    28.             );
    29.         });
    30.         SingleOutputStreamOperator trafficWithSvPvDurSumDS = pageDS.map(line -> {
    31.             JSONObject jsonObject = JSONObject.parseObject(line);
    32.  
    33.             JSONObject common = jsonObject.getJSONObject("common");
    34.             JSONObject page = jsonObject.getJSONObject("page");
    35.  
    36.             return new TrafficPageViewBean("", "",
    37.                     common.getString("vc"),
    38.                     common.getString("ch"),
    39.                     common.getString("ar"),
    40.                     common.getString("is_new"),
    41.                     0L,
    42.                     page.getString("last_page_id") == null ? 1L : 0L,
    43.                     1L,
    44.                     page.getLong("during_time"),
    45.                     0L,
    46.                     common.getLong("ts")
    47.             );
    48.         });

    注意： trafficWithUJ 这条流本就存在延时，所以很可能下面在 union 的时候，窗口都关闭了它还没来，所以我们只能给水位线的最大乱序等待时间 + 判定为用户跳出的最大时间（也就是超时时间）；

    5）三流 union

    对三条流进行 union 然后提取出事件时间生成水位线，之后就需要开窗聚合了，而开窗聚合我们一般都会指定 keyby 再开窗，全窗口几乎不用；而 keyby 的字段我们选择 4 个维度（可以用 String  拼接也可以用一个四元组 Tuple4）

    窗口分类：

    • OpWindow：windowAll()
    • KeyedWindow：window()
      • 时间：滚动、滑动、会话
      • 计数：滚动、滑动
    1. // TODO 5. 三条流进行 union
    2.         DataStream unionDS = trafficWithUvDS.union(trafficWithUJDS, trafficWithSvPvDurSumDS);
    3.  
    4.         // TODO 6. 提取事件时间(去 ts 字段生成水位线)
    5.         SingleOutputStreamOperator trafficPageViewWithWaterMarkDS = unionDS.assignTimestampsAndWatermarks(WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(14))
    6.                 .withTimestampAssigner(new SerializableTimestampAssigner() {
    7.                     @Override
    8.                     public long extractTimestamp(TrafficPageViewBean element, long recordTimestamp) {
    9.                         return element.getTs();
    10.                     }
    11.                 })
    12.         );
    13.  
    14.         // TODO 7. 分组开窗聚合(按照维度做keyby)
    15.         WindowedStream, TimeWindow> windowedStream = trafficPageViewWithWaterMarkDS.keyBy(new KeySelector>() {
    16.             @Override
    17.             public Tuple4 getKey(TrafficPageViewBean value) throws Exception {
    18.                 return Tuple4.of(value.getAr(),
    19.                         value.getCh(),
    20.                         value.getIsNew(),
    21.                         value.getVc());
    22.             }
    23.         }).window(TumblingEventTimeWindows.of(Time.seconds(10)));

    注意：这里在设置水位线延迟时间时，我们设置为 14，因为需求中包含用户跳出会话数，而跳出这个需求本就存在延迟（我们在 DWD 层设置了两种判断跳出策略（前提是按照 mid 分区）：1. last_page_id = null & 下一条数据的 last_page_id 也为 null  2. last_page_id = null & 超时时间达到 10s 视作跳出）

    6） 聚合

    回顾一下窗口聚合函数：

    • 增量聚合函数：来一条计算一条（效率高，存储数据量小）
    • 全量聚合函数：可以求平均值和百分比，可以获取窗口信息

    与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。很明显，这就是典型的批处理思路了——先攒数据，等一批都到齐了再正式启动处理流程。

            但是把计算放到窗口关闭才去计算无疑是低效的，毕竟如果数据量比较大的时候，这种方式肯定没有增量聚合函数计算的快。那为什么还要使用这种方式呢？这是因为有些场景下，我们要做的计算必须基于全部的数据才有效（比如求平均值），这时做增量聚合就没什么意义了；

    那么，现在我们应该对 keyby 后的数据流进行聚合，把相同 key 的度量值进行累加，那么我们应该选用哪种聚合函数呢？

    选用增量聚合函数其实可以实现度量值的累加，但是由于我们的 ck 表中还有两个窗口字段需要补充（窗口起始和终止时间），所以我们需要获取窗口信息，那这就只能使用全量聚合函数了，毕竟全量窗口函数才能获得窗口信息；但是全窗口函数的计算往往是放到最后才执行的，这就很难受，那能不能结合二者的优点呢？

    其实是可以的，我们在之前学习Flink 窗口的时候是讲过的：

    增量聚合函数处理计算会更高效。举一个最简单的例子，对一组数据求和。大量的数据连续不断到来，全窗口函数只是把它们收集缓存起来，并没有处理；到了窗口要关闭、输出结果的时候，再遍历所有数据依次叠加，得到最终结果。而如果我们采用增量聚合的方式，那么只需要保存一个当前和的状态，每个数据到来时就会做一次加法，更新状态；到了要输出结果的时候，只要将当前状态直接拿出来就可以了。增量聚合相当于把计算量“均摊”到了窗口收集数据的过程中，自然就会比全窗口聚合更加高效、输出更加实时。
            而全窗口函数的优势在于提供了更多的信息，可以认为是更加“通用”的窗口操作。它只负责收集数据、提供上下文相关信息，把所有的原材料都准备好，至于拿来做什么我们完全可以任意发挥。这就使得窗口计算更加灵活，功能更加强大。
    所以在实际应用中，我们往往希望兼具这两者的优点，把它们结合在一起使用。Flink 的Window API 就给我们实现了这样的用法。

    1. SingleOutputStreamOperator resultDS = windowedStream.reduce(new ReduceFunction() {
    2.             @Override
    3.             public TrafficPageViewBean reduce(TrafficPageViewBean value1, TrafficPageViewBean value2) throws Exception {
    4.                 value1.setSvCt(value1.getSvCt() + value2.getSvCt());
    5.                 value1.setUvCt(value1.getUvCt() + value2.getUvCt());
    6.                 value1.setUvCt(value1.getUjCt() + value2.getUjCt());
    7.                 value1.setPvCt(value1.getPvCt() + value2.getPvCt());
    8.                 value1.setDurSum(value1.getDurSum() + value2.getDurSum());
    9.                 return value1;
    10.             }
    11.         }, new WindowFunction, TimeWindow>() {
    12.             @Override
    13.             public void apply(Tuple4 stringStringStringStringTuple4, TimeWindow window, Iterable input, Collector out) throws Exception {
    14.                 // 获取数据
    15.                 TrafficPageViewBean next = input.iterator().next();
    16.  
    17.                 // 补充信息
    18.                 next.setStt(DateFormatUtil.toYmdHms(window.getStart()));
    19.                 next.setEdt(DateFormatUtil.toYmdHms(window.getEnd()));
    20.  
    21.                 // 修改 ts
    22.                 next.setTs(System.currentTimeMillis());
    23.  
    24.                 // 输出数据
    25.                 out.collect(next);
    26.             }
    27.         });

    这样，我们既高效地完成了窗口聚合（增量聚合），也拿到了窗口信息（全量聚合获得起止时间）； 

    7）写出到 clickhouse
    1.         // TODO 8. 写入 clickhouse
    2.         resultDS.addSink(ClickHouseUtil.getSinkFunction("insert into dws_traffic_channel_page_view_window " +
    3.                 "values(?,?,?,?,?,?,?,?,?,?,?,?)"));
    4.         // TODO 9. 启动任务
    5.         env.execute("DwsTrafficVcChArIsNewPageViewWindow");

    总结

            至此，流量域两张汇总表创建完毕，关于流量域就剩一张表明天完成，先去吃饭；

  • 相关阅读:
    【Flutter】 包管理（16）Flutter 流处理 深入理解和应用 Stream Transform 包实时处理数据
    20231009-学习笔记
    js-函数式编程-monad-chain-mcompose-自动解嵌套
    提升，方法比努力重要！不懂这几点再多的努力也白费！
    MONGODB 的基础 NOSQL注入基础
    密码正确无法登陆Linux系统
    go语言与c语言调用的方法
    基于二维小波变换的散斑相位奇异构造算法matlab仿真
    Nginx的安装
    使用过邮箱服务，你对`SMTP`、`POP3`、`IMAP`三大协议有过了解吗？
  • 原文地址：https://blog.csdn.net/m0_64261982/article/details/140917916