Flink数据统计UV、PV统计(三种写法)

最新推荐文章于 2024-05-10 08:23:25 发布
最新推荐文章于 2024-05-10 08:23:25 发布
阅读量9.3k 收藏 40
点赞数 1
分类专栏： Flink 文章标签： flink PV UV BloomFilter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baifanwudi/article/details/105428152
版权

做了那么多次flink统计，发现我居然没写过uv，pv统计（因为uv,pv实时统计,公共平台帮做了），最近找了一些资料当练手了。

		public static final DateTimeFormatter TIME_FORMAT_YYYY_MM_DD_HHMMSS = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
		...
		 Properties propsConsumer = ...//Kafka配置;
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        FlinkKafkaConsumer011<String> detailLog = new FlinkKafkaConsumer011<String>("test-topic", new SimpleStringSchema(), propsConsumer);
        detailLog.setStartFromLatest();
        DataStream<String> detailStream = env.addSource(detailLog).name("uv-pv_log").disableChaining();
        detailStream.print();
        DataStream<Tuple2<UMessage,Integer>> detail = detailStream.map(new MapFunction<String, Tuple2<UMessage,Integer>>() {
            @Override
            public Tuple2<UMessage,Integer> map(String value) throws Exception {
                try {
                    UMessage uMessage = JSON.parseObject(value, UMessage.class);
                    return Tuple2.of(uMessage,1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return Tuple2.of(null,null);
            }
        }).filter(s->s!=null&&s.f0!=null).assignTimestampsAndWatermarks( new AscendingTimestampExtractor<Tuple2<UMessage,Integer>>() {
            @Override
            public long extractAscendingTimestamp(Tuple2<UMessage, Integer> element) {
                LocalDate localDate=LocalDate.parse(element.f0.getCreateTime(),TIME_FORMAT_YYYY_MM_DD_HHMMSS);
                long timestamp = localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli();
                return timestamp;
            }
        });

采用event时间，propsConsumer是kafka配置消息(忽略)，UMessage的POJO类

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class UMessage {

    private String uid;

    private String createTime;

    public UMessage() {
    }

    public UMessage(String uid, String createTime) {
        this.uid = uid;
        this.createTime = createTime;
    }
}

这段代码读数据源解析json文本，然后指定eventTime。

计算pv和uv

  • 写法一：
        DataStream<Tuple2<String,Integer>> statsResult=detail.windowAll(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
//               .trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(10)))
                .trigger(CountTrigger.of(1))
                .process(new ProcessAllWindowFunction<Tuple2<UMessage, Integer>, Tuple2<String,Integer>, TimeWindow>() {
                    @Override
                    public void process(Context context, Iterable<Tuple2<UMessage, Integer>> elements, Collector<Tuple2< String, Integer>> out) throws Exception {
                        Set<String> uvNameSet=new HashSet<String>();
                        Integer pv=0;
                        Iterator<Tuple2<UMessage,Integer>> mapIterator=elements.iterator();
                        while(mapIterator.hasNext()){
                            pv+=1;
                            String uvName=mapIterator.next().f0.getUid();
                            uvNameSet.add(uvName);
                        }
                        out.collect(Tuple2.of("uv", uvNameSet.size()));
                        out.collect(Tuple2.of("pv",pv));
                    }
                });
                
          statsResult.print();

这里注意一点windowAll(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))，
从是每天凌晨开始计算的，跨天自动清空的。
发送原始消息

{"uid":"uid001","createTime":"2020-04-08 23:50:55"}

{"uid":"uid002","createTime":"2020-04-08 23:54:55"}

{"uid":"uid003","createTime":"2020-04-08 23:55:55"}

{"uid":"uid001","createTime":"2020-04-08 23:56:55"}

{"uid":"uid001","createTime":"2020-04-09 00:01:55"}

{"uid":"uid002","createTime":"2020-04-09 00:02:55"}

{"uid":"uid001","createTime":"2020-04-09 00:03:55"}

统计结果

1> {"uid":"uid001","createTime":"2020-04-08 23:50:55"}
1> (uv,1)
2> (pv,1)
1> {"uid":"uid002","createTime":"2020-04-08 23:54:55"}
4> (pv,2)
3> (uv,2)
1> {"uid":"uid003","createTime":"2020-04-08 23:55:55"}
6> (pv,3)
5> (uv,3)
1> {"uid":"uid001","createTime":"2020-04-08 23:56:55"}
2> (pv,4)
1> (uv,3)
##这里开始清空
1> {"uid":"uid001","createTime":"2020-04-09 00:01:55"}
3> (uv,1)
4> (pv,1)
1> {"uid":"uid002","createTime":"2020-04-09 00:02:55"}
5> (uv,2)
6> (pv,2)
1> {"uid":"uid001","createTime":"2020-04-09 00:03:55"}
2> (pv,3)
1> (uv,2)

发现在1> {"uid":"uid001","createTime":"2020-04-09 00:01:55"},uv和pv又从0开始计算了。

但是还是有问题的，原始数据特别大，TumblingEventTimeWindows会缓存一天数据，每次重新计算，内存吃不消啊。
采用keyBy，window，重新修改这段代码。

  • 写法二：
                //写法二
        DataStream<Tuple3<String,String, Integer>> statsResult=detail.keyBy(new KeySelector<Tuple2<UMessage, Integer>, String>() {
            @Override
            public String getKey(Tuple2<UMessage, Integer> value) throws Exception {
                return value.f0.getCreateTime().substring(0,10);
            }
        }).window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
//               .trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(10)))
                .trigger(CountTrigger.of(1))
                .evictor(TimeEvictor.of(Time.seconds(0), true))
                .process(new ProcessWindowFunction<Tuple2<UMessage, Integer>, Tuple3<String,String, Integer>, String, TimeWindow>() {
                    private transient MapState<String, String> uvCountState;
                    private transient ValueState<Integer> pvCountState;
                    @Override
                    public void open(Configuration parameters) throws Exception {
                        super.open(parameters);
                        StateTtlConfig ttlConfig = StateTtlConfig.newBuilder(org.apache.flink.api.common.time.Time.minutes(60 * 6)).setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite).setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired).build();
                        MapStateDescriptor<String, String> uvDescriptor = new MapStateDescriptor<String, String>("uv_count", String.class, String.class);
                        ValueStateDescriptor<Integer> pvDescriptor= new ValueStateDescriptor<Integer>("pv_count", Integer.class);
                        uvDescriptor.enableTimeToLive(ttlConfig);
                        pvDescriptor.enableTimeToLive(ttlConfig);
                        uvCountState=getRuntimeContext().getMapState(uvDescriptor);
                        pvCountState=getRuntimeContext().getState(pvDescriptor);
                    }

                    @Override
                    public void process(String key, Context context, Iterable<Tuple2<UMessage, Integer>> elements, Collector<Tuple3<String,String, Integer>> out) throws Exception {
                        Integer pv=0;
                        Iterator<Tuple2<UMessage,Integer>> mapIterator=elements.iterator();
                        while(mapIterator.hasNext()){
                            pv+=1;
                            UMessage uMessage=mapIterator.next().f0;
                            String uvName=uMessage.getUid();
                            uvCountState.put(uvName,null);
                        }
                        Integer uv=0;
                        Iterator<String> uvIterator=uvCountState.keys().iterator();
                        while(uvIterator.hasNext()){
                            uvIterator.next();
                            uv+=1;
                        }
                        Integer originPv=pvCountState.value();
                        if(originPv==null){
                            pvCountState.update(pv);
                        }else{
                            pvCountState.update(originPv+pv);
                        }
                        out.collect(Tuple3.of(key,"uv",uv));
                        out.collect(Tuple3.of(key,"pv",pvCountState.value()));
                    }
                });
       statsResult.print();

evictor(TimeEvictor.of(Time.seconds(0), true))每次窗口计算剔除已经消息过数据。
发送消息测试

{"uid":"uid001","createTime":"2020-04-08 23:50:55"}
{"uid":"uid002","createTime":"2020-04-08 23:54:55"}
{"uid":"uid003","createTime":"2020-04-08 23:55:55"}
{"uid":"uid001","createTime":"2020-04-08 23:56:55"}
{"uid":"uid001","createTime":"2020-04-09 00:01:55"}
{"uid":"uid002","createTime":"2020-04-09 00:02:55"}
{"uid":"uid001","createTime":"2020-04-09 00:03:55"}
{"uid":"uid002","createTime":"2020-04-09 00:04:55"}
{"uid":"uid003","createTime":"2020-04-09 00:05:55"}
{"uid":"uid005","createTime":"2020-04-09 00:10:55"}
{"uid":"uid003","createTime":"2020-04-09 23:55:55"}
{"uid":"uid005","createTime":"2020-04-10 00:03:55"}
{"uid":"uid001","createTime":"2020-04-10 00:05:55"}

统计结果

1> {"uid":"uid001","createTime":"2020-04-08 23:50:55"}
1> (2020-04-08,uv,1)
1> (2020-04-08,pv,1)
1> {"uid":"uid002","createTime":"2020-04-08 23:54:55"}
1> (2020-04-08,uv,2)
1> (2020-04-08,pv,2)
1> {"uid":"uid003","createTime":"2020-04-08 23:55:55"}
1> (2020-04-08,uv,3)
1> (2020-04-08,pv,3)
1> {"uid":"uid001","createTime":"2020-04-08 23:56:55"}
1> (2020-04-08,uv,3)
1> (2020-04-08,pv,4)
1> {"uid":"uid001","createTime":"2020-04-09 00:01:55"}
2> (2020-04-09,uv,1)
2> (2020-04-09,pv,1)
1> {"uid":"uid002","createTime":"2020-04-09 00:02:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,2)
1> {"uid":"uid001","createTime":"2020-04-09 00:03:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,3)
1> {"uid":"uid002","createTime":"2020-04-09 00:04:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,4)
1> {"uid":"uid003","createTime":"2020-04-09 00:05:55"}
2> (2020-04-09,uv,3)
2> (2020-04-09,pv,5)
1> {"uid":"uid005","createTime":"2020-04-09 00:10:55"}
2> (2020-04-09,uv,4)
2> (2020-04-09,pv,6)
1> {"uid":"uid003","createTime":"2020-04-09 23:55:55"}
2> (2020-04-09,uv,4)
2> (2020-04-09,pv,7)
1> {"uid":"uid005","createTime":"2020-04-10 00:03:55"}
1> (2020-04-10,uv,1)
1> (2020-04-10,pv,1)
1> {"uid":"uid001","createTime":"2020-04-10 00:05:55"}
1> (2020-04-10,uv,2)
1> (2020-04-10,pv,2)

UV如果很多，MapState太大了，而且要每次遍历。采用BoomFilter

- 写法三

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

.....

 DataStream<Tuple3<String, String, Integer>> statsResult = detail.keyBy(new KeySelector<Tuple2<UMessage, Integer>, String>() {
            @Override
            public String getKey(Tuple2<UMessage, Integer> value) throws Exception {
                return value.f0.getCreateTime().substring(0, 10);
            }
        }).window(TumblingEventTimeWindows.of(Time.days(1), Time.hours(-8)))
//               .trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(10)))
                .trigger(CountTrigger.of(1))
                .evictor(TimeEvictor.of(Time.seconds(0), true))
                .process(new ProcessWindowFunction<Tuple2<UMessage, Integer>, Tuple3<String, String, Integer>, String, TimeWindow>() {


                    private transient ValueState<BloomFilter<String>> boomFilterState;
                    private transient ValueState<Integer> uvCountState;
                    private transient ValueState<Integer> pvCountState;

                    @Override
                    public void open(Configuration parameters) throws Exception {
                        super.open(parameters);
                        StateTtlConfig ttlConfig = StateTtlConfig.newBuilder(org.apache.flink.api.common.time.Time.minutes(60 * 6)).setUpdateType(StateTtlConfig.UpdateType.OnCreateAndWrite).setStateVisibility(StateTtlConfig.StateVisibility.NeverReturnExpired).build();
                        ValueStateDescriptor<BloomFilter<String>> boomFilterDescriptor = new ValueStateDescriptor<BloomFilter<String>>("boom_filter", TypeInformation.of(new TypeHint<BloomFilter<String>>() {
                        }));
                        ValueStateDescriptor<Integer> pvDescriptor = new ValueStateDescriptor<Integer>("pv_count", Integer.class);
                        ValueStateDescriptor<Integer> uvDescriptor = new ValueStateDescriptor<Integer>("uv_count", Integer.class);
                        boomFilterDescriptor.enableTimeToLive(ttlConfig);
                        pvDescriptor.enableTimeToLive(ttlConfig);
                        uvDescriptor.enableTimeToLive(ttlConfig);
                        boomFilterState = getRuntimeContext().getState(boomFilterDescriptor);
                        pvCountState = getRuntimeContext().getState(pvDescriptor);
                        uvCountState = getRuntimeContext().getState(uvDescriptor);
                    }

                    @Override
                    public void process(String key, Context context, Iterable<Tuple2<UMessage, Integer>> elements, Collector<Tuple3<String, String, Integer>> out) throws Exception {
                        Integer uv = uvCountState.value();
                        Integer pv = pvCountState.value();
                        BloomFilter<String> bloomFilter = boomFilterState.value();
                        if (bloomFilter == null) {
                            bloomFilter = BloomFilter.create(Funnels.unencodedCharsFunnel(), 10*1000*1000L);
                            uv = 0;
                            pv = 0;
                        }

                        Iterator<Tuple2<UMessage, Integer>> mapIterator = elements.iterator();
                        while (mapIterator.hasNext()) {
                            pv += 1;
                            UMessage uMessage = mapIterator.next().f0;
                            String uid = uMessage.getUid();
                            if (!bloomFilter.mightContain(uid)) {
                                bloomFilter.put(uid); //不包含就添加进去
                                uv += 1;
                            }
                        }

                        boomFilterState.update(bloomFilter);
                        uvCountState.update(uv);
                        pvCountState.update(pv);

                        out.collect(Tuple3.of(key, "uv", uv));
                        out.collect(Tuple3.of(key, "pv", pv));
                    }
                });
        statsResult.print();

统计结果为

1> {"uid":"uid001","createTime":"2020-04-08 23:50:55"}
1> (2020-04-08,uv,1)
1> (2020-04-08,pv,1)
1> {"uid":"uid002","createTime":"2020-04-08 23:54:55"}
1> (2020-04-08,uv,2)
1> (2020-04-08,pv,2)
1> {"uid":"uid003","createTime":"2020-04-08 23:55:55"}
1> (2020-04-08,uv,3)
1> (2020-04-08,pv,3)
1> {"uid":"uid001","createTime":"2020-04-08 23:56:55"}
1> (2020-04-08,uv,3)
1> (2020-04-08,pv,4)
1> {"uid":"uid001","createTime":"2020-04-09 00:01:55"}
2> (2020-04-09,uv,1)
2> (2020-04-09,pv,1)
1> {"uid":"uid002","createTime":"2020-04-09 00:02:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,2)
1> {"uid":"uid001","createTime":"2020-04-09 00:03:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,3)
1> {"uid":"uid002","createTime":"2020-04-09 00:04:55"}
2> (2020-04-09,uv,2)
2> (2020-04-09,pv,4)
1> {"uid":"uid003","createTime":"2020-04-09 00:05:55"}
2> (2020-04-09,uv,3)
2> (2020-04-09,pv,5)
1> {"uid":"uid005","createTime":"2020-04-09 00:10:55"}
2> (2020-04-09,uv,4)
2> (2020-04-09,pv,6)
1> {"uid":"uid003","createTime":"2020-04-09 23:55:55"}
2> (2020-04-09,uv,4)
2> (2020-04-09,pv,7)
1> {"uid":"uid005","createTime":"2020-04-10 00:03:55"}
1> (2020-04-10,uv,1)
1> (2020-04-10,pv,1)
1> {"uid":"uid001","createTime":"2020-04-10 00:05:55"}
1> (2020-04-10,uv,2)
1> (2020-04-10,pv,2)

与写法二，统计结果一样。

参考文档：

https://www.cnblogs.com/Springmoon-venn/p/10919648.html
https://blog.csdn.net/u010271601/article/details/104868913
https://blog.csdn.net/u010271601/article/details/104833153

小白鸽
关注
  • 1
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
大数据Flink（七十三）：SQL的滚动窗口（TUMBLE）
Lansonli（蓝深李）的博客
09-05 1130
（TUMBLE 算子）：接收到上游算子发的一条一条的数据，然后将每一条数据按照时间戳划分到对应的窗口中（根据事件时间、处理时间的不同语义进行划分），上述案例为事件时间，事件时间中，滚动窗口算子接收到上游的 Watermark 大于窗口的结束时间时，则说明当前这一分钟的滚动窗口已经结束了，将窗口计算完的结果发往下游算子（一条一条发给下游。数据源算子（From Order）：连接到 Kafka topic，数据源算子一直运行，实时的从 Order Kafka 中一条一条的读取数据，然后一条一条发送给下游的。
基于埋点日志数据的网络流量统计 - PV、UV
08-01
PV、UV统计用到的数据文件
Flink实时统计pv、uv数
zhaozhufeng的博客
12-05 8065
flink实时计算pv、uv
Flink ValueStateDescriptor使用实例
最新发布
大模型大数据攻城狮的专栏
05-10 341
在Apache Flink中，是用于定义状态的一种数据结构，它允许你为每个键（key）存储一个值（value）。状态是 Flink 流处理模型的核心概念之一，它允许你在任务失败和恢复时保持数据的一致性。
Flink去重统计-基于自定义布隆过滤器
Rango_lhl的博客
05-19 929
一、背景说明 在Flink中对流数据进行去重计算是常有操作，如流量域对独立访客之类的统计，去重思路一般有三个： 基于Hashset来实现去重 数据存在内存，容量小，服务重启会丢失。 使用状态编程ValueState/MapState实现去重 常用方式，可以使用内存/文件系统/RocksDB作为状态后端存储。 结合Redis使用布隆过滤器实现去重 适用对上亿数据量进行去重实现，占用资源少效率高，有小概率误判。 这里以自定义布隆过滤器的方式，实现Flink窗口计算中独立访客的统计，数据集样例如下： 二、
大数据Flink实时大屏统计
赵广陆
09-10 1724
目录1 需求2 数据3 编码步骤:4 代码实现5 效果 1 需求 Flink模拟双十一实时大屏统计 在大数据的实时处理中，实时的大屏展示已经成了一个很重要的展示项，比如最有名的双十一大屏实时销售总价展示。除了这个，还有一些其他场景的应用，比如我们在我们的后台系统实 时的展示我们网站当前的pv、uv等等，其实做法都是类似的。 今天我们就做一个最简单的模拟电商统计大屏的小例子， 需求如下： 1.实时计算出当天零点截止到当前时间的销售总额 2.计算出各个分类的销售top3 3.每秒钟更新一次统计结果 2 数据
【Flink SQL】Flink SQL 语法篇（三）：窗口聚合（TUMBLE、HOP、SESSION、CUMULATE）
书山有路，学海无涯。记录成长，追逐梦想
01-30 2166
滚动窗口 将每个元素指定给指定窗口大小的窗口。滚动窗口具有固定大小，且不重叠。例如，指定一个大小为 5 分钟的滚动窗口。在这种情况下，Flink 将每隔 5 分钟开启一个新的窗口，其中每一条数都会划分到唯一的一个 5 分钟的窗口中。
Flink on zeppelin 结合kafka实时计算pv uv写入mysql
JasonLee实时计算
07-19 1108
上一篇文章主要介绍了Flink on zeppelin的安装和使用,配置了yarn的模式跑通了一个streaming wordcount的例子,本文主要介绍结合kafka的使用,实时计算...
Flink实时数仓：MySQL 关联 HBase维表数据到写入ClickHouse
.
08-10 1657
本文介绍了结合 MySQL 数据库、Flink、HBase 以及clickhouse来构建实时数仓，并通过流计算 Flink读取 MySQL 数据、关联 HBase 中的维表，最终将数据存入clickhouse进行指标分析，实现完整实时数仓的全流程操作指导。
Flink窗口机制
别这么骄傲
04-21 739
时间是为窗口服务的。窗口是什么？为什么会有窗口呢？（1）Flink要处理的数据，一般是从Kafka过来的流式数据，如果只是单纯地统计流的数据量，是没办法统计的。（2）所以，要人为的 加上了一个时间区间限制（窗口），才可以进行统计。
Flink（十三）【Flink SQL（上）SqlClient、DDL、查询】
梦想是动物管理员
01-15 1501
Flink SQL sql-client、DDL语句、查询语句
flink 网站访问量pv 独立访客数uv 计算
10-19
它被广泛用于实时数据处理，尤其是在网站分析领域，例如计算网站的访问量（PV，Page View）和独立访客数（UV，Unique Visitor）。这两个指标是衡量网站流量和用户活动的关键指标。 **PV（Page View）计算** PV表示...
flume+kafka+flink+mysql数据统计
04-20
本文将深入探讨这些技术及其在"flume+kafka+flink+mysql数据统计"中的应用。 首先，Flume 是 Apache Hadoop 的一个子项目，主要用于收集、聚合和移动大量日志数据。在本场景中，Flume 可以从 Nginx 服务器收集 Web ...
flink数据分流，Filter、Split、SideOutPut三种分流方式
01-17
本文将详细介绍 Flink 提供的三种主要数据分流方式：filter 分流、split 分流以及 SideOutput 分流。 1. **Filter 分流** Filter 分流是最基础的分流方式，它通过应用用户自定义的过滤函数来决定哪些元素应当保留...
基于Flink+SQL实现数据同步.doc
03-06
4. **Flink SQL**：是 Flink 提供的一种声明式语言，用于处理结构化和半结构化数据流。 #### 数据同步实现 ##### 1. 创建 Hive 表 首先，我们需要在 Hive 中创建一个外部表，用以存放展会的相关信息。以下为创建 ...
Flink入门(七) 写入HDFS
热门推荐
baifanwudi的专栏
03-06 1万+
maven依赖 增加 &lt;dependency&gt; &lt;groupId&gt;org.apache.flink&lt;/groupId&gt; &lt;artifactId&gt;flink-connector-filesystem_2.11&lt;/artifactId&gt; &lt;version...
Flink入门(十三) 读RocketMQ-Flink消息
baifanwudi的专栏
05-28 1万+
github已经有开源地址RocketMQ-Flink 直接把代码复制到自己代码中 这里面我新建一个类 org.apache.rocketmq.flink.common.serialization.SimpleStringDeserializationSchema package org.apache.rocketmq.flink.common.serialization; import or...
Flink入门(十)异步多线程Mysql打宽表，加维度
baifanwudi的专栏
05-07 8667
有这样需求，消息发来是有站点名，但与需要和mysql中维度表join出站名名的三字码（唯一标识符）。 flink版本1.6.3，maven配置如下： <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</a...
使用flink sql写一个pv，uv统计
02-21
我可以给你一个示例代码：// 创建一个TableEnvironment TableEnvironment tableEnv = TableEnvironment.create(env);...Table result = pv.join(uv).select("pageID, pvCount, uvCount"); result.printSchema();
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值