Flink API - ProcessFunction

最新推荐文章于 2024-01-23 09:07:05 发布
最新推荐文章于 2024-01-23 09:07:05 发布
阅读量175 收藏 1
点赞数
分类专栏： flink 文章标签： flink java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44760145/article/details/129251563
版权

在这里插入图片描述
Flink 本身提供了多层 API ，具体结构层次如下：
在这里插入图片描述
过程函数（ProcessFunction）是 Flink 的最底层 API，它不定义任何的操作算子，仅仅通过统一的 process 操作。在处理函数中，使用者直面数据流中最基本的元素：数据事件（event）、状态（state）以及时间（time）。
https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/datastream/operators/process_function/
在这里插入图片描述
Flink 提供了 8 个不同的处理函数：

  1. ProcessFunction 最基本的处理函数，基于 DataStream 直接调用 process() 时作为参数传
  2. KeyedProcessFunction 对流按键分区后的处理函数，基于 KeyedStream 调用 process() 时作为参数传入。要想使用定时器、状态就必须是基于 KeyedStream。
  3. ProcessWindowFunction 开窗之后的处理函数，也是全窗口函数的代表。基于 WindowedStream 调用 process() 时作为参数传入。
  4. ProcessAllWindowFunction 同样是开窗之后的处理函数，基于 AllWindowedStream 调用 process() 时作为参数传入。
  5. CoProcessFunction 合并（connect）两条流之后的处理函数。
  6. ProcessJoinFunction 间隔连接（interval join）两条流之后的处理函数。
  7. BroadcastProcessFunction 广播连接流处理函数，这里的“广播连接流”BroadcastConnectedStream，是一个未 keyBy 的普通 DataStream 与一个广播流（BroadcastStream）做连接（conncet）之后的产物。
  8. KeyedBroadcastProcessFunction 按键分区的广播连接流处理函数，这时的广播连接流，是一个KeyedStream 与广播流（BroadcastStream）做连接之后的结果。

ProcessFunction

针对没有 keyBy 的数据流，可以使用 ProcessFunction 接口，针对流中的每个元素输出 0 个、1 个或者多个元素。（与类似 RichFlatMapFunction）
● ProcessFunction<IN, OUT>：IN是输入的泛型，OUT是输出的泛型
● processElement：每来一条数据，调用一次
● 使用.process(new ProcessFunction<I, O>)来调用。
ProcessFunction 函数虽然在没有分组的情况下也可以获取 timer（定时器）和 state（状态）但是在编译是会报 Keyed state can only be used on a ‘keyed stream’, i.e., after a ‘keyBy()’ operation 异常

        DataStreamSource<Integer> sourceStream = env
                .addSource(new SourceFunction<Integer>() {
                    private boolean running = true;
                    private Random random = new Random();

                    @Override
                    public void run(SourceContext<Integer> ctx) throws Exception {
                        while (running) {
                            ctx.collect(random.nextInt(100));
                            Thread.sleep(1000);
                        }
                    }

                    @Override
                    public void cancel() {
                        running = false;
                    }
                });
        
        sourceStream
                .process(new ProcessFunction<Integer, Integer>() {
                    @Override
                    public void processElement(Integer value, Context ctx, Collector<Integer> out) throws Exception {
                        if (value % 10 == 1){
                            out.collect(value);
                            out.collect(value);
                        }
                    }
                })
                .print();


# 异常演示
public class ProcessFunctions {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        // ProcessFunction 不能使用 状态变量 不能使用 onTimer 编译会出错

        // 求平均值  实现 map - reduce

        DataStreamSource<Integer> sourceStream = env
                .addSource(new SourceFunction<Integer>() {
                    private boolean running = true;
                    private Random random = new Random();

                    @Override
                    public void run(SourceContext<Integer> ctx) throws Exception {
                        while (running) {
                            ctx.collect(random.nextInt(100));
                            Thread.sleep(1000);
                        }
                    }

                    @Override
                    public void cancel() {
                        running = false;
                    }
                });
        
        // ProcessFunction 不能使用 状态变量 不能使用 onTimer 编译会出错
        sourceStream
                .process(new ProcessFunction<Integer, String>() {

                    private ValueState<Tuple2<Integer, Integer>> avgState;

                    @Override
                    public void open(Configuration parameters) throws Exception {
                        super.open(parameters);
                        avgState = getRuntimeContext().getState(new ValueStateDescriptor<Tuple2<Integer, Integer>>("avg-state", Types.TUPLE(Types.INT, Types.INT)));
                    }

                    @Override
                    public void processElement(Integer value, Context ctx, Collector<String> out) throws Exception {

                        if (avgState.value() == null) {
                            avgState.update(Tuple2.of(value, 1));
                        } else {
                            avgState.update(Tuple2.of(avgState.value().f0 + value, avgState.value().f1 + 1));
                        }

                        ctx.timerService().registerProcessingTimeTimer(ctx.timerService().currentProcessingTime() + 10L);

                    }

                    @Override
                    public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
                        super.onTimer(timestamp, ctx, out);

                        ctx.timerService().registerProcessingTimeTimer(timestamp + 10L);

                        out.collect("avg = " + ((double) avgState.value().f1 / avgState.value().f0));

                    }
                })
                .print("avg：");


        env.execute();

    }

}

KeyedProcessFunction

针对 keyBy 之后的键控流（KeyedStream），可以使用 KeyedProcessFunction
● KeyedProcessFunction<KEY, IN, OUT>：KEY是key的泛型，IN是输入的泛型，OUT是输出的泛型。
● processElement：来一条数据，触发调用一次。
● onTimer：定时器。时间到达某一个时间戳触发调用。


public class NumValueDataContinuousRiseKeyedProcessFunction {

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

        // 整数连续 1s 上升报警

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        DataStreamSource<Integer> randomNumSourceStream = env
                .addSource(new SourceFunction<Integer>() {

                    private boolean running = true;
                    private Random random = new Random();

                    @Override
                    public void run(SourceContext<Integer> ctx) throws Exception {
                        while (running) {
                            ctx.collect(random.nextInt(100000));

                            try {
                                TimeUnit.MILLISECONDS.sleep(200);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                    @Override
                    public void cancel() {
                        running = false;
                        random = null;
                    }
                });

        randomNumSourceStream
                // 将所有数据分到一个 slot
                .keyBy(r -> 1)
                // KEY、INPUT、OUTPUT
                .process(new KeyedProcessFunction<Integer, Integer, String>() {

                    // 保存上一条数据
                    private ValueState<Integer> lastValueState;

                    // 保存定时器
                    private ValueState<Long> timerTs;

                    private final Long oneS = 1000L;

                    @Override
                    public void open(Configuration parameters) throws Exception {
                        lastValueState = getRuntimeContext().getState(new ValueStateDescriptor<Integer>("lastValueState", Types.INT));
                        timerTs = getRuntimeContext().getState(new ValueStateDescriptor<Long>("timerTs", Types.LONG));
                    }

                    @Override
                    public void processElement(Integer value, Context ctx, Collector<String> out) throws Exception {

                        // =====================
                        Integer lastVal = lastValueState.value() == null ? Integer.MIN_VALUE : lastValueState.value();

                        // 跟新上一个元素
                        lastValueState.update(value);

                        Long ts = null;
                        if (timerTs.value() != null){
                            ts = timerTs.value();
                        }

                        if (lastVal >= value){
                            if (ts != null){
                                System.out.println("当前元素小与上一条元素,curr = " + value + ", last = " + lastVal + ", 删除定时器 = " + ts);
                                ctx.timerService().deleteProcessingTimeTimer(ts);
                                timerTs.clear();
                            }
                        }else {
                            System.out.println("当前元素大于上一条元素 -->>>，curr = " + value + ", last = " + lastVal);
                            if (ts == null){
                                long timer = ctx.timerService().currentProcessingTime() + oneS;
                                System.out.println("当前元素大于上一条，并且是第一条元素，curr = " + value + ", last = " + lastVal + ", 注册定时器 = " + timer);
                                ctx.timerService().registerProcessingTimeTimer(timer);
                                timerTs.update(timer);
                            }

                        }

                    }

                    @Override
                    public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
                        out.collect("整数连续一秒上升");
                        timerTs.clear();
                    }
                })
                .print();


        env.execute();


    }

}

ProcessWindowFunction

针对 WindowedStream 之后的数据流，可以使用 ProcessWindowFunction
● ProcessWindowFunction<IN, OUT, KEY, W extends Window>。
● processElement：来一条数据，触发调用一次。
● onTimer：定时器。时间到达某一个时间戳触发调用。


public class WinElemsCountProcessWindowFunction {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> withWatermarkStream = env
                .fromCollection(
                        Arrays.asList(
                                Tuple2.of("Alick", 1),
                                Tuple2.of("Alick", 2),
                                Tuple2.of("Alick", 3),
                                Tuple2.of("BOb", 3),
                                Tuple2.of("BOb", 5),
                                Tuple2.of("BOb", 7),
                                Tuple2.of("BOb", 10),
                                Tuple2.of("Alick", 7)
                        )
                )
                .assignTimestampsAndWatermarks(
                        new WatermarkStrategy<Tuple2<String, Integer>>() {
                            @Override
                            public WatermarkGenerator<Tuple2<String, Integer>> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context) {
                                return new WatermarkGenerator<Tuple2<String, Integer>>() {

                                    private Long delay = 0L;
                                    private Long watermark = -Long.MAX_VALUE + delay + 1L;

                                    @Override
                                    public void onEvent(Tuple2<String, Integer> event, long eventTimestamp, WatermarkOutput output) {
                                        watermark = Math.max(event.f1,watermark);
                                    }

                                    @Override
                                    public void onPeriodicEmit(WatermarkOutput output) {
                                        output.emitWatermark(new Watermark(watermark - delay - 1L));
                                    }
                                };
                            }

                            @Override
                            public TimestampAssigner<Tuple2<String, Integer>> createTimestampAssigner(TimestampAssignerSupplier.Context context) {
                                return new TimestampAssigner<Tuple2<String, Integer>>() {
                                    @Override
                                    public long extractTimestamp(Tuple2<String, Integer> element, long recordTimestamp) {
                                        return element.f1 * 1000L;
                                    }
                                };
                            }
                        }
                );
//                .assignTimestampsAndWatermarks(
//                        WatermarkStrategy
//                                .<Tuple2<String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(0L))
//                                .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Integer>>() {
//                                    @Override
//                                    public long extractTimestamp(Tuple2<String, Integer> element, long recordTimestamp) {
//                                        return element.f1 * 1000L;
//                                    }
//                                })
//                );


        KeyedStream<Tuple2<String, Integer>, String> keyedStream = withWatermarkStream
                .keyBy(r -> r.f0);

        WindowedStream<Tuple2<String, Integer>, String, TimeWindow> winStream = keyedStream
                .window(TumblingEventTimeWindows.of(Time.seconds(5)));

        SingleOutputStreamOperator<String> countWinElemsStream = winStream
                .process(
                        new ProcessWindowFunction<Tuple2<String, Integer>, String, String, TimeWindow>() {
                            @Override
                            public void process(String key, Context context, Iterable<Tuple2<String, Integer>> elements, Collector<String> out) throws Exception {

                                Timestamp winStart = new Timestamp(context.window().getStart());
                                Timestamp winEnd = new Timestamp(context.window().getEnd());

                                long count = elements.spliterator().getExactSizeIfKnown();

                                out.collect("key = " + key + " , win [ " + winStart + " - " + winEnd + " ) 有 " + count + " 个元素");

                            }
                        }
                );

        countWinElemsStream.print();


        env.execute();


    }

}

ProcessAllWindowFunction

针对 AllWindowedStream 之后的数据流，可以使用 ProcessAllWindowFunction
● ProcessAllWindowFunction<IN, OUT, W extends Window>
● process(Context context, Iterable elements, Collector out)：窗口触发时执行


public class WinElemsCountProcessAllWindowFunction {

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

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        env.setParallelism(1);


        SingleOutputStreamOperator<Event> withWatermarkStream = env
                .addSource(new ClickSource())
                .assignTimestampsAndWatermarks(
                        new WatermarkStrategy<Event>() {
                            @Override
                            public WatermarkGenerator<Event> createWatermarkGenerator(WatermarkGeneratorSupplier.Context context) {
                                return new WatermarkGenerator<Event>() {

                                    private long delay = 0L;

                                    private long maxWatermark = -Long.MAX_VALUE + delay + 1L;

                                    @Override
                                    public void onEvent(Event event, long eventTimestamp, WatermarkOutput output) {
                                        maxWatermark = Math.max(event.timestamp, maxWatermark);
                                    }

                                    @Override
                                    public void onPeriodicEmit(WatermarkOutput output) {
                                        output.emitWatermark(new Watermark(maxWatermark - delay - 1L));
                                    }
                                };

                            }

                            @Override
                            public TimestampAssigner<Event> createTimestampAssigner(TimestampAssignerSupplier.Context context) {
                                return new TimestampAssigner<Event>() {
                                    @Override
                                    public long extractTimestamp(Event element, long recordTimestamp) {
                                        return element.timestamp;
                                    }
                                };
                            }
                        }
                );

        AllWindowedStream<Event, GlobalWindow> allWindowedStream = withWatermarkStream
                .windowAll(GlobalWindows.create());

        SingleOutputStreamOperator<String> countAlWinElemsStream = allWindowedStream
                .trigger(
                        // 每 5 s 触发一次窗口计算
                        new Trigger<Event, GlobalWindow>() {

                            public final Long tenS = 5_000L;

                            @Override
                            public TriggerResult onElement(Event element, long timestamp, GlobalWindow window, TriggerContext ctx) throws Exception {

                                ValueState<Long> tenSTriggerState = ctx.getPartitionedState(new ValueStateDescriptor<Long>("tenSTriggerState", Types.LONG));

                                if (tenSTriggerState.value() == null) {
                                    long timer = ctx.getCurrentWatermark() + tenS;
                                    ctx.registerEventTimeTimer(timer);
                                    tenSTriggerState.update(timer);
                                }

                                return TriggerResult.CONTINUE;
                            }

                            @Override
                            public TriggerResult onProcessingTime(long time, GlobalWindow window, TriggerContext ctx) throws Exception {
                                return TriggerResult.CONTINUE;
                            }

                            @Override
                            public TriggerResult onEventTime(long time, GlobalWindow window, TriggerContext ctx) throws Exception {
                                ValueState<Long> tenSTriggerState = ctx.getPartitionedState(new ValueStateDescriptor<Long>("tenSTriggerState", Types.LONG));

                                tenSTriggerState.clear();

                                return TriggerResult.FIRE;
                            }

                            @Override
                            public void clear(GlobalWindow window, TriggerContext ctx) throws Exception {
                                System.out.println("=============================");
                            }
                        }
                )
                .process(
                        new ProcessAllWindowFunction<Event, String, GlobalWindow>() {
                            @Override
                            public void process(Context context, Iterable<Event> elements, Collector<String> out) throws Exception {

                                out.collect("窗口中有 " + elements.spliterator().getExactSizeIfKnown() + " 条元素");

                            }
                        }
                );

        countAlWinElemsStream.print();


        env.execute();


    }

}

CoProcessFunction、ProcessJoinFunction、BroadcastProcessFunction、KeyedBroadcastProcessFunction API 在多流操作是详细介绍
ProcessFunction 原理将在 基于时间和窗口 做详细介绍

参考资料
https://nightlies.apache.org/flink/flink-docs-release-1.16/docs/dev/datastream/operators/process_function/

wenvlove
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink Process Function
shenjianyu_rex的博客
09-07 355
前言 转换算子是无法访问事件的时间戳信息和水位线信息的。而这在一些应用场景下，极为重要。例如MapFunction这样的map转换算子就无法访问时间戳或者当前事件的事件时间。 基于此，DataStream API提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的一些事件，例如超时事件等。Process Function用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的window函数和转换算子无法实现)。例如，Flink SQL就是使用Pr
Flink之ProcessFunction API（底层API）
heroking
02-01 605
一、产生背景 转换算子是无法访问事件的时间戳信息和水位线信息的。而这在一些应用场景下，极为重要。例如MapFunction这样的map转换算子就无法访问时间戳或者当前事件的事件时间。 基于此，DataStream API提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的一些事件，例如超时事件等。Process Function用来构建事件...
Flink-处理函数
m0_63475429的博客
10-16 1252
在处理函数中，我们直面的就是数据流中最基本的元素：数据事件（event）、状态（state） 以及时间（time）。这就相当于对流有了完全的控制权。处理函数比较抽象，没有具体的操作， 所以对于一些常见的简单应用（比如求和、开窗口）会显得有些麻烦；不过正是因为它不限定 具体做什么，所以理论上我们可以做任何事情，实现所有需求。所以可以说，处理函数是我们 进行 Flink 编程的“大招”，轻易不用，一旦放出来必然会扫平一切。
Flink的ProcessFunction API
fighting
07-28 1336
1 ProcessFunction    ProcessFunction是一个低阶的流处理操作，可以访问事件(event)(流元素)，状态(state)(容错性，一致性，仅在keyed stream中)，定时器(timers)(event time和processing time， 仅在keyed stream中)。也就是说可以访问普通的转换算子无法访问事件的时间戳信息和Watermark的。    ProcessFunction可以看作是一个具有keyed state 键控状态和 timers定时器访问权
Flink ProcessFunction
Java_KW的博客
04-06 1019
Flink ProcessFunction 文章目录Flink ProcessFunction一、 KeyedProcessFunction二、TimerService和定时器（Timers）三、侧输出流（SideOutput）四、CoProcessFunction 之前使用的转换算子是无法访问事件的时间戳信息和水位线信息的，在某些应用场景下，我们需要这些信息。因此，DataStream API提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的一些
flink-local-train:flink入门到项目实践
05-06
文章会对Flink中基本API如：DataSet、DataStream、Table、Sql和常用特性如：Time&Window、窗口函数、Watermark、触发器、分布式缓存、异步IO、侧输出、广播和高级应用如：ProcessFunction、状态管理等知识点进行整理...
大数据技术之Flink教程
04-02
3. **分层API**：Flink提供层次化的API，包括底层的过程函数（Process Function），它允许直接处理有状态流，适用于复杂计算；DataStream API和DataSet API是核心API，分别处理有界和无界流数据，提供丰富的转换和...
flink道路监控系统实战项目
05-07
2. **Flink架构**：包括JobManager、TaskManager、DataStream API和批处理API（Batch API）等组成部分，以及它们如何协同工作。 3. **流处理模型**：介绍Flink的时间窗口、事件时间、处理时间等概念，以及如何处理...
Flink超神文档.pdf
01-29
- **ProcessFunction API**: 提供更底层的操作，支持更多的自定义逻辑。 #### 六、DataFlows分区策略 **6.1 DataFlows分区策略** - **shuffle**: 随机分配元素到不同 Task。 - **rebalance**: 重新平衡数据分布。...
flink1.14_scala2.12
09-20
4. **SQL与Table API**：结合Flink的Table API和SQL，Scala程序员可以编写声明式处理逻辑，降低复杂性并提高代码可读性。 5. **容错与扩展性**：Flink的容错机制与Scala的并发模型相结合，能够确保大规模数据处理...
Flink之processFunction
shufangreal的博客
03-05 280
Flink之keyedProcessFunction processFuntion是Flink的底层Api，我们可以更好的通过context来控制TimeService，还可以保存dataStream中的状态信息，并加入到逻辑使用中。 Flink提供了8中ProcessFunction，这里用keyedProcessFunction来示例 // processFunction的调用 stream....
Flink ProcessFunction详解
菜鸟也学大数据的博客
01-05 3116
前言 我们之前学习的转换算子是无法访问事件的时间戳信息和水位线信息的。而这.在一.些应用场景下，极为重要。例如MapFunction这样的map转换算子就无法访问时间戳或者当前事件的事件时间。 基于此，DataStreamAPI提供了一系列的Low-Level转换算子。可以访问时间戳、watermark以及注册定时事件。还可以输出特定的-一些事件，例如超时事件等。ProcessFunction用来构建事件驱动的应用以及实现自定义的业务逻辑(使用之前的window函数和转换算子无法实现)。例如，Flink
Flink的处理函数——processFunction
雷神乐乐的博客
10-06 2009
Flink的处理函数——processFunction
Flink processFunction API
qq_27242695的博客
06-30 123
文章目录Flink processFunction API1 KeyedProcessFunction2 TimerService 和 定时器（Timers） Flink processFunction API 1 KeyedProcessFunction KeyedProcessFunction 用来操作 KeyedStream。KeyedProcessFunction 会处理流的每一个元素，输出为 0 个、1 个或者多个元素。所有的 Process Function 都继承自RichFunction 接
Flink中处理函数（Process Function)
m0_37689903的博客
06-26 897
本文主要介绍了按键分区处理函数（KeyedProcessFunction）和窗口处理函数（ProcessWindowFunction）以及测输出流
Flink学习笔记之Process Function
qq_38835878的博客
08-17 583
预计一周时间来完成这篇文章， 对Flink文档提供的基础入门的每个环节进行研究记录（目的是想参加阿里的Flink编程比赛）: 如图Flink提供了不同级别的抽象编程模型，先看最低级别的Stateful Stream Processing，它通过Process Function嵌入到DataStream API当中(有说法是在Flink未来的迭代过程当中会移除DataSet API, 在现有...
【基础】Flink -- ProcessFunction
情绪瓜皮皮丶的学习之路
02-18 1440
整理总结了 Flink 中处理函数相关的知识和简单使用方法
Flink处理函数（ProcessFunction、KeyedProcessFunction、ProcessWindowFunction、 ProcessAllWindowFunction）
最新发布
roi666的博客
01-23 1393
/定义一小时窗口@Overridecount++;
以下对flink api 中的ProcessFUnction的说法错误的是：
06-13
以下是四个关于Flink API中ProcessFunction的说法，其中有一个是错误的： 1. ProcessFunction是Flink提供的一个用于处理流式数据的函数式编程接口，可以对数据进行各种转换、过滤和计算操作。 2. ProcessFunction提供了open()、processElement()和close()三个方法，用于在处理每个元素之前、之后和整个函数生命周期结束时进行初始化、清理和资源释放等操作。 3. ProcessFunction可以访问事件时间和处理时间，并提供了相应的API用于处理和控制时间，如设置定时器、注册回调函数等。 4. ProcessFunction只能在KeyedStream上使用，并且需要使用keyBy()方法将流数据按照指定的Key进行分区，以便进行有状态的操作。 其中，说法4是错误的。ProcessFunction可以在KeyedStream上使用，也可以在非KeyedStream上使用。在KeyedStream上使用时，可以使用keyBy()方法将流数据按照指定的Key进行分区，以便进行有状态的操作。在非KeyedStream上使用时，则无需进行分区，可以直接对数据进行操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值