Flink 窗口 join

已于 2022-07-13 17:08:00 修改
阅读量917 收藏 1
点赞数 2
分类专栏： flink 文章标签： flink 大数据 java
于 2022-07-07 16:37:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31021213/article/details/125661751
版权

文章目录

Flink 窗口 join

Flink的窗口Join分为2中，一种为普通的window join (类似 inner join)，一种为Interval Join (间隔 join)。

窗口Join (Window Join)

定义：

Flink 提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。类似于SQL中的Join，

API 文档：

leftStream.join(rightStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(<WindowAssigner>)
    .apply(<JoinFunction>)
  • leftStream：参与 join 的数据流
  • rightStream：参与 join 的另一个数据流
  • where：第一条数据流的 key
  • equalTo：第二条数据流的key
  • window：设置窗口信息，例如 滚动窗口（tumbling window）、滑动窗口（sliding window）和会话窗口（session window）都可以使用
    • 滚动窗口
      滚动窗口Join
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
 
...

DataStream<Integer> orangeStream = ...
DataStream<Integer> greenStream = ...

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(TumblingEventTimeWindows.of(Time.milliseconds(2)))
    .apply (new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });
  • 滑动窗口
    滑动窗口Join
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

...

DataStream<Integer> orangeStream = ...
DataStream<Integer> greenStream = ...

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(SlidingEventTimeWindows.of(Time.milliseconds(2) /* size */, Time.milliseconds(1) /* slide */))
    .apply (new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });
  • 会话窗口
    会话窗口Join
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
 
...

DataStream<Integer> orangeStream = ...
DataStream<Integer> greenStream = ...

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(EventTimeSessionWindows.withGap(Time.milliseconds(1)))
    .apply (new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });
  • apply：窗口处理函数，只能调用 .apply()。内部可以实现JoinFunction或者FlatJoinFunction，来返回 join 后的结果。
    • JoinFunction
/**
* IN1: 第一个流的输出类型
* IN2: 第二个流的输出类型
* OUT: join后的输出类型
*/
public interface JoinFunction<IN1, IN2, OUT> extends Function, Serializable {
    OUT join(IN1 var1, IN2 var2) throws Exception;
}
  • FlatJoinFunction
/**
* IN1: 第一个流的输出类型
* IN2: 第二个流的输出类型
* OUT: 通过收集器（Collector）来收集 join 结果
*/
public interface FlatJoinFunction<IN1, IN2, OUT> extends Function, Serializable {
    void join(IN1 var1, IN2 var2, Collector<OUT> var3) throws Exception;
}

示例：

package com.ali.flink.demo.driver;

import com.ali.flink.demo.utils.DataGeneratorImpl002;
import com.ali.flink.demo.utils.FlinkEnv;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.datagen.DataGeneratorSource;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * join function
 */
public class FlinkJoinFunctionDemo01 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = FlinkEnv.FlinkDataStreamRunEnv();

        env.setParallelism(1);

        DataGeneratorSource<String> dataGeneratorSource1 = new DataGeneratorSource<>(new DataGeneratorImpl002());

        DataStream<String> sourceStream1 = env.addSource(dataGeneratorSource1).returns(String.class);
//        dataGeneratorStream.print("source");

        SingleOutputStreamOperator<Event> mapStream1 = sourceStream1
                .map(new MapFunction<String, Event>() {
                    @Override
                    public Event map(String s) throws Exception {
                        JSONObject jsonObject = JSON.parseObject(s);
                        String username = jsonObject.getString("username");
                        String eventtime = jsonObject.getString("eventtime");
                        String click_url = jsonObject.getString("click_url");
                        return new Event(username, click_url, eventtime);
                    }
                });

        mapStream1.print("map source_1");

        DataGeneratorSource<String> dataGeneratorSource2 = new DataGeneratorSource<>(new DataGeneratorImpl002());

        DataStream<String> sourceStream2 = env.addSource(dataGeneratorSource2).returns(String.class);
//        dataGeneratorStream.print("source");

        SingleOutputStreamOperator<Event> mapStream2 = sourceStream2
                .map(new MapFunction<String, Event>() {
                    @Override
                    public Event map(String s) throws Exception {
                        JSONObject jsonObject = JSON.parseObject(s);
                        String username = jsonObject.getString("username");
                        String eventtime = jsonObject.getString("eventtime");
                        String click_url = jsonObject.getString("click_url");
                        return new Event(username, click_url, eventtime);
                    }
                });

        mapStream2.print("map source_2");

        mapStream1.join(mapStream2)
                .where(new KeySelector<Event, String>() {
                    @Override
                    public String getKey(Event event) throws Exception {
                        return event.userName + '-' + event.clickUrl;
                    }
                })
                .equalTo(new KeySelector<Event, String>() {
                    @Override
                    public String getKey(Event event) throws Exception {
                        return event.userName + '-' + event.clickUrl;
                    }
                })
                .window(TumblingProcessingTimeWindows.of(Time.seconds(20)))
                .apply(new JoinFunction<Event, Event, String>() {
                    @Override
                    public String join(Event event, Event event2) throws Exception {
                        return event.toString() + "====>" + event2.toString();
                    }
                }).print("join");

        env.execute("tumble window test");
    }

    public static class Event{
        private String userName;
        private String clickUrl;
        private String eventTime;

        public Event(String userName, String clickUrl, String eventTime) {
            this.userName = userName;
            this.clickUrl = clickUrl;
            this.eventTime = eventTime;
        }

        @Override
        public String toString() {
            return "Event{" +
                    "userName='" + userName + '\'' +
                    ", clickUrl='" + clickUrl + '\'' +
                    ", eventTime='" + eventTime + '\'' +
                    '}';
        }
    }
}

结果：

map source_1> Event{userName='bbb', clickUrl='url1', eventTime='2022-07-07 16:14:15'}
map source_2> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 16:14:16'}
map source_1> Event{userName='bbb', clickUrl='url2', eventTime='2022-07-07 16:14:23'}
map source_2> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 16:14:23'}
map source_1> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 16:14:24'}
map source_1> Event{userName='aaa', clickUrl='url2', eventTime='2022-07-07 16:14:30'}
map source_2> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 16:14:32'}
map source_1> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 16:14:32'}
join> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 16:14:32'}====>Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 16:14:32'}
join> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 16:14:24'}====>Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 16:14:23'}

间隔Join (Interval Join)

定义：

间隔Join
间隔Join 用一个共同的 key 连接两个流的元素（我们现在称它们为 A 和 B），其中流 B 的元素的时间戳位于流 A 中元素的时间戳的相对时间间隔内。
其满足 b.timestamp ∈ [a.timestamp + lowerBound; a.timestamp + upperBound]或 a.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound

API文档：

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.time.Time;

...

DataStream<Integer> orangeStream = ...
DataStream<Integer> greenStream = ...

orangeStream
    .keyBy(<KeySelector>)
    .intervalJoin(greenStream.keyBy(<KeySelector>))
    .between(Time.milliseconds(-2), Time.milliseconds(1))
    .process (new ProcessJoinFunction<Integer, Integer, String(){

        @Override
        public void processElement(Integer left, Integer right, Context ctx, Collector<String> out) {
            out.collect(first + "," + second);
        }
    });

示例：

Interval Join必须设置watermark。

package com.ali.flink.demo.driver;

import com.ali.flink.demo.utils.DataGeneratorImpl002;
import com.ali.flink.demo.utils.FlinkEnv;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.functions.source.datagen.DataGeneratorSource;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.util.Date;

/**
 * Interval Join
 */
public class FlinkIntervalJoinFunctionDemo01 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = FlinkEnv.FlinkDataStreamRunEnv();

        env.setParallelism(1);

        DataGeneratorSource<String> dataGeneratorSource1 = new DataGeneratorSource<>(new DataGeneratorImpl002());

        DataStream<String> sourceStream1 = env.addSource(dataGeneratorSource1).returns(String.class);
//        dataGeneratorStream.print("source");

        SingleOutputStreamOperator<Event> mapStream1 = sourceStream1
                .map(new MapFunction<String, Event>() {
                    @Override
                    public Event map(String s) throws Exception {
                        JSONObject jsonObject = JSON.parseObject(s);
                        String username = jsonObject.getString("username");
                        String eventtime = jsonObject.getString("eventtime");
                        String click_url = jsonObject.getString("click_url");
                        return new Event(username, click_url, eventtime);
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long l) {
                                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                Date event_time = null;
                                try {
                                    event_time = simpleDateFormat.parse(event.eventTime);
                                } catch (ParseException e) {
                                    e.printStackTrace();
                                }
                                return event_time.getTime();
                            }
                        }));

        mapStream1.print("map source_1");

        DataGeneratorSource<String> dataGeneratorSource2 = new DataGeneratorSource<>(new DataGeneratorImpl002());

        DataStream<String> sourceStream2 = env.addSource(dataGeneratorSource2).returns(String.class);
//        dataGeneratorStream.print("source");

        SingleOutputStreamOperator<Event> mapStream2 = sourceStream2
                .map(new MapFunction<String, Event>() {
                    @Override
                    public Event map(String s) throws Exception {
                        JSONObject jsonObject = JSON.parseObject(s);
                        String username = jsonObject.getString("username");
                        String eventtime = jsonObject.getString("eventtime");
                        String click_url = jsonObject.getString("click_url");
                        return new Event(username, click_url, eventtime);
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event event, long l) {
                                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                Date event_time = null;
                                try {
                                    event_time = simpleDateFormat.parse(event.eventTime);
                                } catch (ParseException e) {
                                    e.printStackTrace();
                                }
                                return event_time.getTime();
                            }
                        }));

        mapStream2.print("map source_2");

        mapStream1
                .keyBy(new KeySelector<Event, String>() {
                    @Override
                    public String getKey(Event event) throws Exception {
                        return event.userName + '-' + event.clickUrl;
                    }
                })
                .intervalJoin(mapStream2.keyBy(new KeySelector<Event, String>() {
                    @Override
                    public String getKey(Event event) throws Exception {
                        return event.userName + '-' + event.clickUrl;
                    }
                }))
                .between(Time.seconds(-5), Time.seconds(5))
                .process(new ProcessJoinFunction<Event, Event, String>() {
                    @Override
                    public void processElement(Event event, Event event2, Context context, Collector<String> collector) throws Exception {
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String left_time = simpleDateFormat.format(new Date(context.getLeftTimestamp()));
                        String right_time = simpleDateFormat.format(new Date(context.getRightTimestamp()));
                        String timestamp = simpleDateFormat.format(new Date(context.getTimestamp()));
                        collector.collect("left_time : " + left_time + "-- right_time : " + right_time + "-- timestamp : " + timestamp + " || " +  event.toString() + "====>" + event2.toString());
                    }
                }).print("Interval Join");

        env.execute("tumble window test");
    }

    public static class Event{
        private String userName;
        private String clickUrl;
        private String eventTime;

        public Event(String userName, String clickUrl, String eventTime) {
            this.userName = userName;
            this.clickUrl = clickUrl;
            this.eventTime = eventTime;
        }

        @Override
        public String toString() {
            return "Event{" +
                    "userName='" + userName + '\'' +
                    ", clickUrl='" + clickUrl + '\'' +
                    ", eventTime='" + eventTime + '\'' +
                    '}';
        }
    }
}

结果：

map source_2> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 17:11:29'}
map source_1> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 17:11:32'}
Interval Join> left_time : 2022-07-07 17:11:32-- right_time : 2022-07-07 17:11:29-- timestamp : 2022-07-07 17:11:32 || Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 17:11:32'}====>Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 17:11:29'}
map source_2> Event{userName='aaa', clickUrl='url1', eventTime='2022-07-07 17:11:38'}
map source_1> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 17:11:40'}
map source_2> Event{userName='ccc', clickUrl='url1', eventTime='2022-07-07 17:11:43'}
map source_1> Event{userName='ccc', clickUrl='url2', eventTime='2022-07-07 17:11:45'}
map source_2> Event{userName='bbb', clickUrl='url2', eventTime='2022-07-07 17:11:52'}
map source_1> Event{userName='bbb', clickUrl='url2', eventTime='2022-07-07 17:11:53'}
Interval Join> left_time : 2022-07-07 17:11:53-- right_time : 2022-07-07 17:11:52-- timestamp : 2022-07-07 17:11:53 || Event{userName='bbb', clickUrl='url2', eventTime='2022-07-07 17:11:53'}====>Event{userName='bbb', clickUrl='url2', eventTime='2022-07-07 17:11:52'}
coding or coded
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink样例完整代码
05-31
2. **Flink API**：学习如何使用DataStream API和DataSet API来创建数据源、数据转换（如map、filter、join等）和数据接收器。 3. **状态管理**：理解Flink的状态持久化和检查点机制，这对于保证处理的一致性和故障...
flink的三种windows join
weixin_40809627的博客
06-09 3686
window join用于连接两个流的元素，他们在一个窗口钟用于共享一个公共的key.我们一般可以用一个窗口分配器定义这些窗口（join情况下一般包含了Tumbling Windows （滚动）、Sliding Windows（滑动）和Session Windows （会话窗口）） Windows Join的代码一般形式如下： 注：创建两个流元素的成对组合的行为类似于内连接。如果来自一个流的元素和另一个流没有相对应的连接元素，则不会发出该元素。 结合在一起的那些元素将其时间戳设置为各自窗口的最大时间戳。例
Flink Window Join机制
yang灬仔
07-24 1402
Flink Window Join机制 window join连接两个流的元素，它们共享一个公共key并位于同一个窗口中。可以使用flink window定义这些窗口，并对来自这两个流的元素求值。 然后将两边的元素传递给用户定义的JoinFunction或FlatJoinFunction，用户可以在其中发出满足连接条件的结果。 参考Flink Stream Joining，一般用法概括如下: stream.join(otherStream) .where(<KeySelector&.
43、Flink 的 Window Join 详解
最新发布
猫猫爱吃小鱼粮
05-27 481
Flink 的 Window Join 详解
Flink中的双流Join详解
LBJ_小松鼠的博客
08-05 5099
1-Flink中双流Join介绍 注意:双流Join是Flink面试的高频问题 Join大体分类只有两种：Window Join和Interval Join。 Window Join又可以根据Window的类型细分出3种： Tumbling Window Join、Sliding Window Join、Session Widnow Join。 Windows类型的join都是利用window的机制，先将数据缓存在Window State中，当窗口触发计算时，执行join操作； interval joi
Flink--连接(Join)
weixin_42927126的博客
06-14 373
Window Join（窗口连接） 窗口连接是指将同一个窗口中的两个流数据通过同一个key连接起来。这些窗口可以使用Window Assigner定义，并根据两个流中的数据进行计算。 连接两边的数据被传给一个用户定义好的JoinFunction或者FlatJoinFunction，将满足条件的结果数据输出来。 通用用法总结如下： stream.join(otherStream) .where(<KeySelector>) .equalTo(<KeySelector>)
flink 资料
02-26
5. **连接器和转换函数**：熟悉Flink内置的各种连接器，如Kafka、HDFS等，以及转换函数的使用，如Map、Filter、Join等。 6. **Flink SQL支持**：随着Flink SQL的引入，使得SQL开发者也能轻松使用Flink，了解其语法...
Flink实战总结1
08-03
Flink的窗口机制可以实现流处理的窗口操作，例如Tumbling Window、Sliding Window等。Barrier机制可以实现流处理的_barrier操作，例如 Window、Session等。 Flink的配置可以通过flink-conf.yaml文件来实现，例如...
Flink 多流转换 （四） 窗口联结（Window Join）
weixin_45417821的博客
04-19 2061
文章目录窗口联结的调用窗口联结实例 Flink 为这种场景专门提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。类似于SQL中的Join 窗口联结的调用 窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结
Flink双流Join 3种解决方案 + 2种优化方案
huashetianzu的专栏
06-10 3716
在流式计算中，左右表的数据都是无界的，而且是实时到来的。这就会引起流式计算中的 2 个问题 + 大数据中的 2 个核心问题
空0008
Direction_Wind的博客
04-11 2167
8。
Flink--9、双流联结（窗口联结、间隔联结）
星光不问赶路人，岁月不负有心人
10-06 870
双流联结（窗口联结、间隔联结）
Flink SQL:Queries(Window JOIN)
weixin_48813624的博客
10-27 794
Flink SQL:Queries(Window JOIN)
Flink SQL之窗口JOIN
marui156的专栏
07-07 699
滚动窗口有固定的尺寸，窗口间的元素无重复示例：每10分钟将10分钟内的金额汇总计算。
Flink1.11 intervalJoin watermark生成，状态清理机制源码理解&Demo分析
qq_34864753的博客
12-14 2319
参考博客https://cloud.tencent.com/developer/article/1738836 数据类型为左流FlinkClick(userid=gk01, click=Pay, ctime=2020-12-14 09:55:00.000) ; 右流为FlinkPay(userid=gk01, payway=alipy, ptime=2020-12-14 09:58:00.000) join的这段代码如下 clickOut.keyBy(t->t.getUs...
flink Window Join、Interval Join、Window CoGroup (两流匹配 指定key联结，开窗口进行窗口操作)
热门推荐
不是一枚开发
06-05 6万+
  Flink 提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理  窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结窗口函数进行处理计算   .where()的参数是键选择器（KeySelector），
Flink开发-窗口Join
qq884121435的博客
08-17 557
Flink开发-窗口Join1. 等值Join2. LeftOuterJoin3. IntervalJoin 双流数据流入时必须两个窗口同时满足窗口触发条件才会进行运算。 1. 等值Join public static void main(String[] args) throws Exception { //local模式默认的并行度是当前机器的逻辑核数 StreamExecutionEnvironment env = StreamExecutionEnviro
Flink 双流 Join 的3种操作示例
Ververica的博客
11-16 1577
在数据库中的静态表上做 OLAP 分析时，两表 join 是非常常见的操作。同理，在流式处理作业中，有时也需要在两条流上做 join 以获得更丰富的信息。Flink DataStream...
Flink SQL join 窗口
06-06
Flink SQL中的JOIN操作可以和窗口一起使用，实现窗口上的JOIN计算，这可以在实时流处理中非常有用。 窗口是数据流处理中的一种重要概念，它可以将数据流按照时间或者数量等维度进行切分，然后对每个窗口内的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值