Flink中的水位线

已于 2024-06-03 10:14:18 修改
阅读量354 收藏 7
点赞数 4
分类专栏： Flink 文章标签： flink 大数据 Java
于 2024-05-03 15:16:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63257947/article/details/138377613
版权

文章目录

水位线概述

在Flink中，用来衡量事件时间进展的标记，就被称作“水位线”（Watermark）。
具体实现上，水位线可以看作一条特殊的数据记录，它是插入到数据流中的一个标记点，主要内容就是一个时间戳，用来指示当前的事件时间。而它插入流中的位置，就应该是在某个数据到来之后；这样就可以从这个数据中提取时间戳，作为当前水位线的时间戳了。

水位线和窗口的工作原理

在Flink中，窗口其实并不是一个“框”，应该把窗口理解成一个“桶”在Flink中，窗口可以把数据流切割成有限大小的多个“存储桶”(bucket);每个数据都会分发到对应的桶中,当到达窗口结束时间时，就对每个桶中收集的数据进行计算处理。
在这里插入图片描述
注意：Flink中窗口并不是静态准备好的，而是动态创建——当有落在这个窗口区间范围的数据达到时，才创建对应的窗口。另外，这里我们认为到达窗口结束时间时，窗口就触发计算并关闭，事实上“触发计算”和“窗口关闭”两个行为也可以分开进行，这部分内容我们会在后面详述。

Flink内置水位线

1.有序流中内置水位线设置

对于有序流，主要特点就是时间戳单调增长，所以永远不会出现迟到数据的问题。这是周期性生成水位线的最简单的场景，直接调用WatermarkStrategy.forMonotonousTimestamps()方法就可以实现。

package window;

import flink_Partition.WaterSensorMapFunction;
import flink_transfrom.WaterSensor;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

public class WatermarkDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<WaterSensor> sensorsDS = env
                .socketTextStream("hadoop102", 7777)
                .map(new WaterSensorMapFunction());

        //TODO 定义Watermark策略
        WatermarkStrategy<WaterSensor> watermarkStrategy = WatermarkStrategy.<WaterSensor>forMonotonousTimestamps() //升序的watermark，没有等待时间
               //指定 时间戳分配器，从数据中提取
                .withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
                    @Override
                    public long extractTimestamp(WaterSensor element, long recordTimestamp) {
                        //返回的时间戳，要 毫秒
                        System.out.println("数据=" + element + ",recordTs=" + recordTimestamp);
                        return element.getTs() * 1000L;
                    }
                });


        SingleOutputStreamOperator<WaterSensor> sensorsDSWithWatermark = sensorsDS.assignTimestampsAndWatermarks(watermarkStrategy);

        SingleOutputStreamOperator<String> watermark = sensorsDSWithWatermark.keyBy(r -> r.getId())
                // 使用 事件时间语义 的窗口
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(
                        new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
                            @Override
                            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

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

                                out.collect("key=" + s + "的窗口[" + windowStart + "," + windowEnd + ")包含" + count + "条数据===>" + elements.toString());
                            }
                        }
                );
        
        watermark.print();

        env.execute();
    }
}

在这里插入图片描述
在这里插入图片描述
10不在这个窗口中，10属于10-20这个窗口（我们再输入一个20，就会触发10-20这个窗口）：

在这里插入图片描述
在这里插入图片描述

2.乱序流中内置水位线设置

由于乱序流中需要等待迟到数据到齐，所以必须设置一个固定量的延迟时间。这时生成水位线的时间戳，就是当前数据流中最大的时间戳减去延迟的结果，相当于把表调慢，当前时钟会滞后于数据的最大时间戳。调用WatermarkStrategy. forBoundedOutOfOrderness()方法就可以实现。这个方法需要传入一个maxOutOfOrderness参数，表示“最大乱序程度”，它表示数据流中乱序数据时间戳的最大差值；如果我们能确定乱序程度，那么设置对应时间长度的延迟，就可以等到所有的乱序数据了。

package window;

import flink_Partition.WaterSensorMapFunction;
import flink_transfrom.WaterSensor;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

import java.time.Duration;

public class WatermarkDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<WaterSensor> sensorsDS = env
                .socketTextStream("hadoop102", 7777)
                .map(new WaterSensorMapFunction());

        //TODO 定义Watermark策略
        WatermarkStrategy<WaterSensor> watermarkStrategy = WatermarkStrategy
                .<WaterSensor>forBoundedOutOfOrderness(Duration.ofSeconds(3)) //指定watermark生成：乱序的，等待3s
               //指定 时间戳分配器，从数据中提取
                .withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
                    @Override
                    public long extractTimestamp(WaterSensor element, long recordTimestamp) {
                        //返回的时间戳，要 毫秒
                        System.out.println("数据=" + element + ",recordTs=" + recordTimestamp);
                        return element.getTs() * 1000L;
                    }
                });


        SingleOutputStreamOperator<WaterSensor> sensorsDSWithWatermark = sensorsDS.assignTimestampsAndWatermarks(watermarkStrategy);

        SingleOutputStreamOperator<String> watermark = sensorsDSWithWatermark.keyBy(r -> r.getId())
                // 使用 事件时间语义 的窗口
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(
                        new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
                            @Override
                            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

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

                                out.collect("key=" + s + "的窗口[" + windowStart + "," + windowEnd + ")包含" + count + "条数据===>" + elements.toString());
                            }
                        }
                );

        watermark.print();

        env.execute();
    }
}

在这里插入图片描述
在这里插入图片描述
输入10之后窗口并不会结束触发输出，因为有3s的等待时间。我们再输入11和13：

在这里插入图片描述
在这里插入图片描述
输入完13后窗口就要结束然后触发输出了，因为进展到了13-3=10s 窗口结束。输出的时候还是只输出0-10s窗口内的数据:1,2,8

自定义水位线

1.周期性水位线生成器

周期性生成器一般是通过onEvent()观察判断输入的事件，而在onPeriodicEmit()里发出水位线。

package window;

import org.apache.flink.api.common.eventtime.Watermark;
import org.apache.flink.api.common.eventtime.WatermarkGenerator;
import org.apache.flink.api.common.eventtime.WatermarkOutput;

public class myPeriodWatermarkGenerator<T> implements WatermarkGenerator<T> {

    //乱序等待时间
    private  long delayTs;
    //用来保存 当前为止最大的事件时间
    private long maxTs;

    public myPeriodWatermarkGenerator(long delayTs) {
        this.delayTs = delayTs;
        this.maxTs = Long.MIN_VALUE + this.delayTs+1;
    }

    /*
    每条数据来，都会调用一次： 用来提取最大的事件时间，保存下来
     */
    @Override
    public void onEvent(T event, long eventTimestamp, WatermarkOutput output) {
        maxTs=Math.max(maxTs,eventTimestamp);
        System.out.println("调用onEvent方法，获取目前为止最大时间戳="+maxTs);

    }

    /*
    周期性调用：发射watermark
     */
    @Override
    public void onPeriodicEmit(WatermarkOutput output) {
        output.emitWatermark(new Watermark(maxTs - delayTs - 1));
        System.out.println("调用onPeriodicEmit方法，生成watermark="+(maxTs-delayTs-1));

    }
}


package window;

import flink_Partition.WaterSensorMapFunction;
import flink_transfrom.WaterSensor;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkGenerator;
import org.apache.flink.api.common.eventtime.WatermarkGeneratorSupplier;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

import java.time.Duration;

public class WatermarkDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //周期2000ms
        env.getConfig().setAutoWatermarkInterval(2000);

        SingleOutputStreamOperator<WaterSensor> sensorsDS = env
                .socketTextStream("hadoop102", 7777)
                .map(new WaterSensorMapFunction());

        //TODO 定义Watermark策略
        WatermarkStrategy<WaterSensor> watermarkStrategy = WatermarkStrategy
                //指定自定义的生成器
                .<WaterSensor>forGenerator(new WatermarkGeneratorSupplier<WaterSensor>() {
                    @Override
                    public WatermarkGenerator<WaterSensor> createWatermarkGenerator(Context context) {
                        return new myPeriodWatermarkGenerator<>(3000L);
                    }
                })
               //指定 时间戳分配器，从数据中提取
                .withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
                    @Override
                    public long extractTimestamp(WaterSensor element, long recordTimestamp) {
                        //返回的时间戳，要 毫秒
                        System.out.println("数据=" + element + ",recordTs=" + recordTimestamp);
                        return element.getTs() * 1000L;
                    }
                });


        SingleOutputStreamOperator<WaterSensor> sensorsDSWithWatermark = sensorsDS.assignTimestampsAndWatermarks(watermarkStrategy);

        SingleOutputStreamOperator<String> watermark = sensorsDSWithWatermark.keyBy(r -> r.getId())
                // 使用 事件时间语义 的窗口
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(
                        new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
                            @Override
                            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

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

                                out.collect("key=" + s + "的窗口[" + windowStart + "," + windowEnd + ")包含" + count + "条数据===>" + elements.toString());
                            }
                        }
                );

        watermark.print();

        env.execute();
    }
}

在这里插入图片描述

在这里插入图片描述
我们在onPeriodicEmit()里调用output.emitWatermark()，就可以发出水位线了；这个方法由系统框架周期性地调用，默认200ms一次。
如果想修改默认周期时间，可以通过下面方法修改。例如：修改为400ms

env.getConfig().setAutoWatermarkInterval(400L);

2.断点式水位线生成器

断点式生成器会不停地检测onEvent()中的事件，当发现带有水位线信息的事件时，就立即发出水位线。我们把发射水位线的逻辑写在onEvent方法当中即可。

package window;

import org.apache.flink.api.common.eventtime.Watermark;
import org.apache.flink.api.common.eventtime.WatermarkGenerator;
import org.apache.flink.api.common.eventtime.WatermarkOutput;

public class myPunctuatedWatermarkGenerator<T> implements WatermarkGenerator<T> {

    //乱序等待时间
    private  long delayTs;
    //用来保存 当前为止最大的事件时间
    private long maxTs;

    public myPunctuatedWatermarkGenerator(long delayTs) {
        this.delayTs = delayTs;
        this.maxTs = Long.MIN_VALUE + this.delayTs+1;
    }

    /*
    每条数据来，都会调用一次： 用来提取最大的事件时间，保存下来,并发射watermark
     */
    @Override
    public void onEvent(T event, long eventTimestamp, WatermarkOutput output) {
        maxTs=Math.max(maxTs,eventTimestamp);
        output.emitWatermark(new Watermark(maxTs - delayTs - 1));
        System.out.println("调用onEvent方法，获取目前为止的最大时间戳="+maxTs+",watermark="+(maxTs-delayTs-1));
    }

    /*
    周期性调用：不需要
     */
    @Override
    public void onPeriodicEmit(WatermarkOutput output) {

    }

}


package window;

import flink_Partition.WaterSensorMapFunction;
import flink_transfrom.WaterSensor;
import org.apache.commons.lang.time.DateFormatUtils;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkGenerator;
import org.apache.flink.api.common.eventtime.WatermarkGeneratorSupplier;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

import java.time.Duration;

public class WatermarkDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //周期2000ms
        env.getConfig().setAutoWatermarkInterval(2000);

        SingleOutputStreamOperator<WaterSensor> sensorsDS = env
                .socketTextStream("hadoop102", 7777)
                .map(new WaterSensorMapFunction());

        //TODO 定义Watermark策略
        WatermarkStrategy<WaterSensor> watermarkStrategy = WatermarkStrategy
                //自定义的 断点式生成
                .<WaterSensor>forGenerator(new WatermarkGeneratorSupplier<WaterSensor>() {
                    @Override
                    public WatermarkGenerator<WaterSensor> createWatermarkGenerator(Context context) {
                        return new myPunctuatedWatermarkGenerator<>(3000L);
                    }
                })
               //指定 时间戳分配器，从数据中提取
                .withTimestampAssigner(new SerializableTimestampAssigner<WaterSensor>() {
                    @Override
                    public long extractTimestamp(WaterSensor element, long recordTimestamp) {
                        //返回的时间戳，要 毫秒
                        System.out.println("数据=" + element + ",recordTs=" + recordTimestamp);
                        return element.getTs() * 1000L;
                    }
                });


        SingleOutputStreamOperator<WaterSensor> sensorsDSWithWatermark = sensorsDS.assignTimestampsAndWatermarks(watermarkStrategy);

        SingleOutputStreamOperator<String> watermark = sensorsDSWithWatermark.keyBy(r -> r.getId())
                // 使用 事件时间语义 的窗口
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(
                        new ProcessWindowFunction<WaterSensor, String, String, TimeWindow>() {
                            @Override
                            public void process(String s, Context context, Iterable<WaterSensor> elements, Collector<String> out) throws Exception {
                                long startTs = context.window().getStart();
                                long endTs = context.window().getEnd();
                                String windowStart = DateFormatUtils.format(startTs, "yyyy-MM-dd HH:mm:ss.SSS");
                                String windowEnd = DateFormatUtils.format(endTs, "yyyy-MM-dd HH:mm:ss.SSS");

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

                                out.collect("key=" + s + "的窗口[" + windowStart + "," + windowEnd + ")包含" + count + "条数据===>" + elements.toString());
                            }
                        }
                );

        watermark.print();

        env.execute();
    }
}

在这里插入图片描述
在这里插入图片描述

IT牛爷爷
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Flink流计算编程--watermark（水位线）简介
lmalds的专栏
09-30 6万+
1、watermark的概念watermark是一种衡量Event Time进展的机制，它是数据本身的一个隐藏属性。通常基于Event Time的数据，自身都包含一个timestamp，例如1472693399700（2016-09-01 09:29:59.700），而这条数据的watermark时间则可能是：watermark(1472693399700) = 1472693396700(2016
flink水位线案例 中的数据源
03-30
数据源
Flink时间窗口和水位线
m0_57697768的博客
06-11 1246
当一个窗口被触发计算完成后，窗口中的元素会被清除，并且该窗口的状态也会被清除。窗口的触发计算和窗口关闭是两个不同的操作，使用allowedLatenessAIP设置窗口的推迟关闭，即使水位线触发了关窗，因为设置的推迟关窗，窗口只会触发计算，之后属于该窗口的迟到数据到来后仍会触发计算，只有水位线到达延迟关窗时间后窗口才会真正关闭。时间窗口的水位线是参考所有上游任务发送的最小的水位线的，如果存在一个上游任务一直没有数据发送，那么该上游任务的水位线为Long的最小值，窗口将无法触发，所以设置空闲等待时间；
Flink中水位线Watermark
weixin_40659514的博客
11-09 836
flink的watermark介绍
Flink之水位线（Watermark）
四维大脑的博客
04-25 7332
在流数据处理应用中，一个很重要、也很常见的操作就是窗口计算。所谓的“窗口”，一般就是划定的一段时间范围，也就是“时间窗”；对在这范围内的数据进行处理，就是所谓的窗口计算。所以窗口和时间往往是分不开的。接下来我们就深入了解一下 Flink 中的时间语义和窗口的应用。
Flink水位线传递
weixin_43527591的博客
02-06 640
本文主要介绍Flink水位线（watermark）的传递理论与原理
Flink中水位线的时间戳为何要减一
qq_39889944的博客
11-04 278
本文是作者对水位线为何必须减一这个问题的见解，希望借此能在编写水位线代码时能牢记减一操作
flink 窗口和水位线
qq_66563605的博客
07-21 805
window、watermark
Flink-水位线的设置以及传递
m0_46507516的博客
11-19 2151
flink，水位线生成，自定义水位线，水位线传递
【入门Flink】- 09Flink水位线Watermark
打怪升级
11-11 1039
Flink 水位线 和 水位线生成策略
flink中的时间语义和水位线及迟到处理
03-30
Flink 中的窗口（窗口的作用，窗口的分类，Windows API，窗口函数）和时间语义（时间语义，水位线，使用步骤）以迟到数据处理（推迟水位线推进，设置窗口延迟关闭，使用测流接受迟到的数据）基于时间的合流-双流联结...
flink中文教程.zip
03-02
Flink中文教程主要涵盖了分布式流处理框架Apache Flink的核心概念、使用方法以及实践案例，旨在帮助初学者和开发者深入理解并熟练运用Flink。以下是对这些主题的详细阐述： 1. **概念**： - **流处理**：Flink是一...
Flink 中文文档资料.zip
01-17
flink Flink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料.zipFlink 中文文档资料...
flink 中文教程.rar
03-25
Flink开发使用的说明文档，十分好用！
FlinkCDC-3.1.1 DataStream Source
最新发布
SunTecTec
07-04 145
scala版本根据下载flink.tgz安装包时指定的版本号。在poml文件中，导入的flink-table依赖把。
Flink CDC MySQL同步MySQL错误记录
eagle89的专栏
07-02 414
Flink CDC MySQL同步MySQL错误记录
Flink CDC3.X + Flink1.19环境搭建
sl4379的博客
07-04 349
Flink CDC3.X + Flink1.19测试监听MySQL8的binlog，实现CDC
Flink ProcessFunction不同流异同及应用场景
linweidong的专栏
06-28 1250
状态管理与事件时间：所有函数均支持事件时间和水位线处理，状态管理（除了），但Keyed系列额外支持键控状态。流处理处理多个流，而和支持广播状态传播。窗口处理和专用于窗口处理，前者基于键控窗口，后者处理全窗口数据。灵活性和最为灵活，适用于广泛的复杂逻辑处理；在窗口上下文中提供了额外的处理能力。
flink中水位线的作用
06-09
在Flink中，水位线（Watermark）是一种用于处理无界流数据的机制，用于标记事件时间（EventTime）流的进度。水位线用于告诉系统事件时间已经到达了哪个点，从而触发一些操作。水位线的作用主要包括以下几个方面： 1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT牛爷爷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值