基于Flink实时数仓——DWS 层-商品主题宽表的计算（7）

已于 2022-01-22 23:11:58 修改
阅读量972 收藏 2
点赞数 1
分类专栏： 尚硅谷实时数仓 文章标签： flink hdfs hadoop
于 2022-01-21 22:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46045632/article/details/122629530
版权

在这里插入图片描述

代码实现：

public class ProductStatsApp {

    public static void main(String[] args) throws Exception {

        //TODO 1.获取执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //1.1 设置CK&状态后端
        //env.setStateBackend(new FsStateBackend("hdfs://hadoop102:8020/gmall-flink-210325/ck"));
        //env.enableCheckpointing(5000L);
        //env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        //env.getCheckpointConfig().setCheckpointTimeout(10000L);
        //env.getCheckpointConfig().setMaxConcurrentCheckpoints(2);
        //env.getCheckpointConfig().setMinPauseBetweenCheckpoints(3000);

        //env.setRestartStrategy(RestartStrategies.fixedDelayRestart());

        //TODO 2.读取Kafka 7个主题的 数据创建流
        String groupId = "product_stats_app";

        String pageViewSourceTopic = "dwd_page_log";
        String orderWideSourceTopic = "dwm_order_wide";
        String paymentWideSourceTopic = "dwm_payment_wide";
        String cartInfoSourceTopic = "dwd_cart_info";
        String favorInfoSourceTopic = "dwd_favor_info";
        String refundInfoSourceTopic = "dwd_order_refund_info";
        String commentInfoSourceTopic = "dwd_comment_info";
        DataStreamSource<String> pvDS = env.addSource(MyKafkaUtil.getKafkaConsumer(pageViewSourceTopic, groupId));
        DataStreamSource<String> favorDS = env.addSource(MyKafkaUtil.getKafkaConsumer(favorInfoSourceTopic, groupId));
        DataStreamSource<String> cartDS = env.addSource(MyKafkaUtil.getKafkaConsumer(cartInfoSourceTopic, groupId));
        DataStreamSource<String> orderDS = env.addSource(MyKafkaUtil.getKafkaConsumer(orderWideSourceTopic, groupId));
        DataStreamSource<String> payDS = env.addSource(MyKafkaUtil.getKafkaConsumer(paymentWideSourceTopic, groupId));
        DataStreamSource<String> refundDS = env.addSource(MyKafkaUtil.getKafkaConsumer(refundInfoSourceTopic, groupId));
        DataStreamSource<String> commentDS = env.addSource(MyKafkaUtil.getKafkaConsumer(commentInfoSourceTopic, groupId));

        //TODO 3.将7个流统一数据格式
        SingleOutputStreamOperator<ProductStats> productStatsWithClickAndDisplayDS = pvDS.flatMap(new FlatMapFunction<String, ProductStats>() {
            @Override
            public void flatMap(String value, Collector<ProductStats> out) throws Exception {

                //将数据转换为JSON对象
                JSONObject jsonObject = JSON.parseObject(value);

                //取出page信息
                JSONObject page = jsonObject.getJSONObject("page");
                String pageId = page.getString("page_id");

                Long ts = jsonObject.getLong("ts");

                if ("good_detail".equals(pageId) && "sku_id".equals(page.getString("item_type"))) {
                    out.collect(ProductStats.builder()
                            .sku_id(page.getLong("item"))
                            .click_ct(1L)
                            .ts(ts)
                            .build());
                }

                //尝试取出曝光数据
                JSONArray displays = jsonObject.getJSONArray("displays");
                if (displays != null && displays.size() > 0) {
                    for (int i = 0; i < displays.size(); i++) {

                        //取出单条曝光数据
                        JSONObject display = displays.getJSONObject(i);

                        if ("sku_id".equals(display.getString("item_type"))) {
                            out.collect(ProductStats.builder()
                                    .sku_id(display.getLong("item"))
                                    .display_ct(1L)
                                    .ts(ts)
                                    .build());
                        }
                    }
                }
            }
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithFavorDS = favorDS.map(line -> {
            JSONObject jsonObject = JSON.parseObject(line);
            return ProductStats.builder()
                    .sku_id(jsonObject.getLong("sku_id"))
                    .favor_ct(1L)
                    .ts(DateTimeUtil.toTs(jsonObject.getString("create_time")))
                    .build();
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithCartDS = cartDS.map(line -> {
            JSONObject jsonObject = JSON.parseObject(line);
            return ProductStats.builder()
                    .sku_id(jsonObject.getLong("sku_id"))
                    .cart_ct(1L)
                    .ts(DateTimeUtil.toTs(jsonObject.getString("create_time")))
                    .build();
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithOrderDS = orderDS.map(line -> {

            OrderWide orderWide = JSON.parseObject(line, OrderWide.class);

            HashSet<Long> orderIds = new HashSet<>();
            orderIds.add(orderWide.getOrder_id());

            return ProductStats.builder()
                    .sku_id(orderWide.getSku_id())
                    .order_sku_num(orderWide.getSku_num())
                    .order_amount(orderWide.getSplit_total_amount())
                    .orderIdSet(orderIds)
                    .ts(DateTimeUtil.toTs(orderWide.getCreate_time()))
                    .build();
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithPaymentDS = payDS.map(line -> {

            PaymentWide paymentWide = JSON.parseObject(line, PaymentWide.class);

            HashSet<Long> orderIds = new HashSet<>();
            orderIds.add(paymentWide.getOrder_id());

            return ProductStats.builder()
                    .sku_id(paymentWide.getSku_id())
                    .payment_amount(paymentWide.getSplit_total_amount())
                    .paidOrderIdSet(orderIds)
                    .ts(DateTimeUtil.toTs(paymentWide.getPayment_create_time()))
                    .build();
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithRefundDS = refundDS.map(line -> {
            JSONObject jsonObject = JSON.parseObject(line);

            HashSet<Long> orderIds = new HashSet<>();
            orderIds.add(jsonObject.getLong("order_id"));

            return ProductStats.builder()
                    .sku_id(jsonObject.getLong("sku_id"))
                    .refund_amount(jsonObject.getBigDecimal("refund_amount"))
                    .refundOrderIdSet(orderIds)
                    .ts(DateTimeUtil.toTs(jsonObject.getString("create_time")))
                    .build();
        });

        SingleOutputStreamOperator<ProductStats> productStatsWithCommentDS = commentDS.map(line -> {

            JSONObject jsonObject = JSON.parseObject(line);

            String appraise = jsonObject.getString("appraise");
            long goodCt = 0L;
            if (GmallConstant.APPRAISE_GOOD.equals(appraise)) {
                goodCt = 1L;
            }

            return ProductStats.builder()
                    .sku_id(jsonObject.getLong("sku_id"))
                    .comment_ct(1L)
                    .good_comment_ct(goodCt)
                    .ts(DateTimeUtil.toTs(jsonObject.getString("create_time")))
                    .build();
        });

        //TODO 4.Union  7个流
        DataStream<ProductStats> unionDS = productStatsWithClickAndDisplayDS.union(
                productStatsWithFavorDS,
                productStatsWithCartDS,
                productStatsWithOrderDS,
                productStatsWithPaymentDS,
                productStatsWithRefundDS,
                productStatsWithCommentDS);

        //TODO 5.提取时间戳生成WaterMark
        SingleOutputStreamOperator<ProductStats> productStatsWithWMDS = unionDS.assignTimestampsAndWatermarks(WatermarkStrategy.<ProductStats>forBoundedOutOfOrderness(Duration.ofSeconds(2)).withTimestampAssigner(new SerializableTimestampAssigner<ProductStats>() {
            @Override
            public long extractTimestamp(ProductStats element, long recordTimestamp) {
                return element.getTs();
            }
        }));

        //TODO 6.分组、开窗、聚合   按照sku_id分组,10秒的滚动窗口,结合增量聚合(累加值)和全量聚合(提取窗口信息)
        SingleOutputStreamOperator<ProductStats> reduceDS = productStatsWithWMDS.keyBy(ProductStats::getSku_id)
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .reduce(new ReduceFunction<ProductStats>() {
                    @Override
                    public ProductStats reduce(ProductStats stats1, ProductStats stats2) throws Exception {
                        stats1.setDisplay_ct(stats1.getDisplay_ct() + stats2.getDisplay_ct());
                        stats1.setClick_ct(stats1.getClick_ct() + stats2.getClick_ct());
                        stats1.setCart_ct(stats1.getCart_ct() + stats2.getCart_ct());
                        stats1.setFavor_ct(stats1.getFavor_ct() + stats2.getFavor_ct());
                        stats1.setOrder_amount(stats1.getOrder_amount().add(stats2.getOrder_amount()));
                        stats1.getOrderIdSet().addAll(stats2.getOrderIdSet());
                        //stats1.setOrder_ct(stats1.getOrderIdSet().size() + 0L);
                        stats1.setOrder_sku_num(stats1.getOrder_sku_num() + stats2.getOrder_sku_num());
                        stats1.setPayment_amount(stats1.getPayment_amount().add(stats2.getPayment_amount()));

                        stats1.getRefundOrderIdSet().addAll(stats2.getRefundOrderIdSet());
                        //stats1.setRefund_order_ct(stats1.getRefundOrderIdSet().size() + 0L);
                        stats1.setRefund_amount(stats1.getRefund_amount().add(stats2.getRefund_amount()));

                        stats1.getPaidOrderIdSet().addAll(stats2.getPaidOrderIdSet());
                        //stats1.setPaid_order_ct(stats1.getPaidOrderIdSet().size() + 0L);

                        stats1.setComment_ct(stats1.getComment_ct() + stats2.getComment_ct());
                        stats1.setGood_comment_ct(stats1.getGood_comment_ct() + stats2.getGood_comment_ct());
                        return stats1;

                    }
                }, new WindowFunction<ProductStats, ProductStats, Long, TimeWindow>() {
                    @Override
                    public void apply(Long aLong, TimeWindow window, Iterable<ProductStats> input, Collector<ProductStats> out) throws Exception {

                        //取出数据
                        ProductStats productStats = input.iterator().next();

                        //设置窗口时间
                        productStats.setStt(DateTimeUtil.toYMDhms(new Date(window.getStart())));
                        productStats.setEdt(DateTimeUtil.toYMDhms(new Date(window.getEnd())));

                        //设置订单数量
                        productStats.setOrder_ct((long) productStats.getOrderIdSet().size());
                        productStats.setPaid_order_ct((long) productStats.getPaidOrderIdSet().size());
                        productStats.setRefund_order_ct((long) productStats.getRefundOrderIdSet().size());

                        //将数据写出
                        out.collect(productStats);
                    }
                });

        //TODO 7.关联维度信息

        //7.1 关联SKU维度
        SingleOutputStreamOperator<ProductStats> productStatsWithSkuDS = AsyncDataStream.unorderedWait(reduceDS,
                new DimAsyncFunction<ProductStats>("DIM_SKU_INFO") {
                    @Override
                    public String getKey(ProductStats productStats) {
                        return productStats.getSku_id().toString();
                    }

                    @Override
                    public void join(ProductStats productStats, JSONObject dimInfo) throws ParseException {

                        productStats.setSku_name(dimInfo.getString("SKU_NAME"));
                        productStats.setSku_price(dimInfo.getBigDecimal("PRICE"));
                        productStats.setSpu_id(dimInfo.getLong("SPU_ID"));
                        productStats.setTm_id(dimInfo.getLong("TM_ID"));
                        productStats.setCategory3_id(dimInfo.getLong("CATEGORY3_ID"));

                    }
                }, 60, TimeUnit.SECONDS);

        //7.2 关联SPU维度
        SingleOutputStreamOperator<ProductStats> productStatsWithSpuDS =
                AsyncDataStream.unorderedWait(productStatsWithSkuDS,
                        new DimAsyncFunction<ProductStats>("DIM_SPU_INFO") {
                            @Override
                            public void join(ProductStats productStats, JSONObject jsonObject) throws ParseException {
                                productStats.setSpu_name(jsonObject.getString("SPU_NAME"));
                            }

                            @Override
                            public String getKey(ProductStats productStats) {
                                return String.valueOf(productStats.getSpu_id());
                            }
                        }, 60, TimeUnit.SECONDS);

        //7.3 关联Category维度
        SingleOutputStreamOperator<ProductStats> productStatsWithCategory3DS =
                AsyncDataStream.unorderedWait(productStatsWithSpuDS,
                        new DimAsyncFunction<ProductStats>("DIM_BASE_CATEGORY3") {
                            @Override
                            public void join(ProductStats productStats, JSONObject jsonObject) throws ParseException {
                                productStats.setCategory3_name(jsonObject.getString("NAME"));
                            }

                            @Override
                            public String getKey(ProductStats productStats) {
                                return String.valueOf(productStats.getCategory3_id());
                            }
                        }, 60, TimeUnit.SECONDS);

        //7.4 关联TM维度
        SingleOutputStreamOperator<ProductStats> productStatsWithTmDS =
                AsyncDataStream.unorderedWait(productStatsWithCategory3DS,
                        new DimAsyncFunction<ProductStats>("DIM_BASE_TRADEMARK") {
                            @Override
                            public void join(ProductStats productStats, JSONObject jsonObject) throws ParseException {
                                productStats.setTm_name(jsonObject.getString("TM_NAME"));
                            }

                            @Override
                            public String getKey(ProductStats productStats) {
                                return String.valueOf(productStats.getTm_id());
                            }
                        }, 60, TimeUnit.SECONDS);


        //TODO 8.将数据写入ClickHouse
        productStatsWithTmDS.print();
        productStatsWithTmDS.addSink(ClickHouseUtil.getSink("insert into table product_stats_210325 values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"));

        //TODO 9.启动任务
        env.execute("ProductStatsApp");

    }

}

代码流程图：

在这里插入图片描述

养不起心爱的猫该如何是好
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Flink实时数仓——DWS 层的设计访客主题宽表（6）
qq_46045632的博客
01-20 1172
DWS 层的定位是什么 轻度聚合，因为 DWS 层要应对很多实时查询，如果是完全的明细那么查询的压力是非常大的。 将更多的实时数据以主题的方式组合起来便于管理，同时也能减少维度查询的次数。 DWS 层-访客主题宽表的计算 设计一张 DWS 层的表其实就两件事：维度和度量(事实数据) 度量包括 PV、UV、跳出次数、进入页面数(session_count)、连续访问时长 维度包括在分析中比较重要的几个字段：渠道、地区、版本、新老用户进行聚合 需求分析与思路 接收各个明细数据，变为数据流.
Flink实时数仓课程（艺人直播项目）
10-12
《Flink实时数仓课程——艺人直播项目》深入解析 在大数据处理领域，Apache Flink以其强大的流处理能力和低延迟的特性，成为了许多企业和开发者首选的实时计算框架。本课程聚焦于“Flink实时数仓”在实际业务场景中...
11.Flink实时项目之支付宽表
Player_001的博客
04-17 2017
支付宽表的目的，最主要的原因是支付表没有到订单明细，支付金额没有细分到商品上， 没有办法统计商品级的支付状况。 所以本次宽表的核心就是要把支付表的信息与订单明细关联上。
基于Flink实时数仓——DWM 层-支付宽表（5）
qq_46045632的博客
01-19 415
需求分析与思路 支付宽表的目的，最主要的原因是支付表没有到订单明细，支付金额没有细分到商品上， 没有办法统计商品级的支付状况。 所以本次宽表的核心就是要把支付表的信息与订单宽表关联上。 解决方案有两个： 把订单宽表输出到 HBase 上，在支付宽表计算时查询 HBase，这相当于把订单宽表作为一种维度进行管理。 用流的方式接收订单宽表，然后用双流 join 方式进行合并。因为订单与支付产生有一定的时差。所以必须用 intervalJoin来管理流的状态时间，保证当支付到达时订单宽表还保存在状态中。（实.
DWS层:商品行为关键词主题宽表
weixin_42796403的博客
03-26 529
DWS层:商品行为关键词主题宽表 从商品主题获得，商品关键词与点击次数、订单次数、添加购物次数的统计表。 重构DWSProductStatsApp 重构DWSProductStatsApp, 增加最终的数据到Kafka的代码(因为flink没有直接读取clickhousse的方法，借助kafka中转) private void sink2Kafka(SingleOutputStreamOperator<ProductStats> resultStream) { resultStream.
Flink构造宽表实时入库案例介绍
最新发布
u014439239的博客
01-10 1436
本文讲解如何使用flink进行数据异构
基于 Flink 的典型 ETL 场景实现-实时数仓篇.pdf
06-19
Apache Flink 是一个流行的开源流处理框架，被广泛用于构建实时数仓的ETL（提取、转换、加载）流程。本报告将深入探讨如何利用Flink实现实时数仓的典型场景。 一、实时数据提取（Extract） 在实时数仓中，数据源...
s硅谷大数据项目之Flink实时数仓完整版
04-10
004-实时数仓(CDC编码 FlinkSQL方式）.avi 008-实时数仓(采集模块 课程介绍）.avi 009-实时数仓(采集模块 分层介绍）.avi 010-实时数仓(采集模块 需求介绍）.avi 011-实时数仓(采集模块 离线架构）.avi 012-...
艺人直播-Flink实时数仓视频教程
10-12
7. **Flink与实时数仓**：课程的重点在于如何将Flink与实时数仓结合。学员将学习如何设计实时ETL流程，将实时数据流入Hadoop、Hive或其它数据仓库系统，以支持实时分析和决策。 8. **监控与调试**：在实际项目中，...
艺人直播-Flink实时数仓
10-11
分享一套flink课程——艺人直播-Flink实时数仓，完整视频课程下载，提供代码、文档资料。 基于“艺人直播平台”业务背景的flink实时数据分析（实时数仓）项目，基于主流的实时数据分析系统技术架构实现，内含各类...
大数据 Flink SQL CDC 实时数据整库同步 实时宽表 实时计算 流批一体
zhaoyang10的专栏
12-15 5365
应用案例 基于 Apache Flink 和规则引擎的实时风控解决方案 ​ 日均百亿级日志处理：微博基于Flink的实时计算平台建设 基于Flink的超大规模在线实时反欺诈系统的建设与实践 每秒1.8亿条高峰流量，美团数仓上Flink Flink CDC Flink CDC采集MySQL binlog日志实时写入ClickHouse Docker 安装 Flink Docker Hub flink最新版本 docker安装flink 使用Docker搭建Flink集群 docker-compose 部署fl
【Flink实时数仓】需求二：用户事件信息宽表的构建 Kafka Hbase Flink
qq_31412425的博客
07-23 774
实时中的宽表其实是在退维，退维是数据处理中的一种操作，它是将细粒度的数据合并、归并为粗粒度数据的过程。在数据处理的过程中，原始数据往往包含大量的细节和细粒度信息，而有时候我们需要将这些细粒度数据转化为更高层次、更普遍的概要信息，以支持更广泛的数据分析和业务需求，这个过程就是退维。总之，退维是数据处理中的重要环节，它帮助我们从复杂的细粒度数据中提取出有用的信息，简化数据分析过程，同时还有助于节约存储空间和提高数据处理效率。通过退维，我们可以更好地理解数据，发现数据的规律和趋势，并支持更广泛的业务应用和决策。
基于 FLINK SQL 的实时数据打宽
chbxw
09-15 1156
一、数据打宽 二、双流 Join & 区间 Join 三、时态表 Join 四、案例 关注我的公众号【宝哥大数据】， 更多大数据干货 参考： https://www.bilibili.com/video/BV1Ap4y1h7j1?from=search&seid=16517504794128610121&spm_id_from=333.337.0.0 完整课程及PPT下载：https://flink-learning.org.cn/activity/detail/1e05a0837
【实时数仓】Day04-DWS层业务：DWS设计、访客宽表、商品主题宽表、流合并、地区主题表、FlinkSQL、关键词主题表、分词...
USTSD的博客
01-09 1006
一、DWS层与DWM设计 1、思路 之前已经进行分流 但只需要一些指标进行实时计算，将这些指标以主题宽表的形式输出 2、需求 访客、商品、地区、关键词四层的需求(可视化大屏展示、多维分析) 3、DWS层定位 轻度聚合、主题中管理 二、DWS层-访客主题宽表的计算 DWS表主要包含维度表和事实表 维度表主要包括渠道、地区、版本、新老用户等 事实表主要包括PV、UV、跳出次数、进入页面数(...
9.Flink实时项目之订单宽表
Player_001的博客
03-17 3050
订单是统计分析的重要的对象，围绕订单有很多的维度统计需求，比如用户、地区、商品、品类、品牌等等。为了之后统计计算更加方便，减少大表之间的关联，所以在实时计算过程中将围绕订单的相关数据整合成为一张订单的宽表。那究竟哪些数据需要和订单整合在一起？
Flink实时销售宽表构建
xkxdqj的博客
12-09 3575
Flink 实时宽表
Flink实时数仓订单宽表设计思路及优化
狗不理的博客
12-05 1169
Flink数仓建设有感
DWS 层-商品主题宽表的计算
chbxw
03-23 584
与访客的 dws 层的宽表类似，也是把多个事实表的明细数据汇总起来组合成宽表 1.1、需求分析与思路 ➢ 从 Kafka 主题中获得数据流 ➢ 把 Json 字符串数据流转换为统一数据对象的数据流 ➢ 把统一的数据结构流合并为一个流 ➢ 设定事件时间与水位线 ➢ 分组、开窗、聚合 ➢ 写入 ClickHouse ...
大数据Flink电商实时数仓实战项目流程全解（七） DWS层设计--访客主题宽表、商品主题宽表的计算
日句灬的博客
08-06 1695
这几天复习计网的东西去了~~不定期更新 之所以单独将这个主题宽表拿出来讲，是因为他的设计过程非常具有代表性，可以参照这个表的设计方式去实现后续其他的主题宽表设计（后续有Flink Sql的实现过程、另讲）； 在该系列的第一篇文章中，我已经提高了各个层的设计目的；DWS层在本项目中的主要作用是为了ADS层的查询和后续可视化设计的，算是数据接口的直接数据来源，所以这里对实时性的要求很高，否则你再这里算个几十秒的延迟，最后展示出来的数据结果实时性肯定非常差； 对此，DWS层的设计应该突出实时性要求，在这里，不应该
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值