flink 多流转换(侧输出流分流、Union、Connect) 实时对账app 的支付操作和第三方的支付操作的双流 Join

谈谈Flink DataStream API中的三种双流join操作 前言 本文是基础中的基础,看官可以放心食用。 在数据库中的静态表上做OLAP分析时,两表join是非常常见的操作。同理,在流式处理作业中,有时也需要在两条流上做join以获得更丰富的信息。Flink DataStream API为用户提供了3个算子来实现双流join,分别是: join() coGroup() intervalJoin() 本文举例说明它们的使用方法,顺便聊聊比较特殊的inte... 阅读详情

前言


1. 分流

  将一条数据流拆分成完全独立的两条、甚至多条流,直接用处理函数(process function)的侧输出流(side output)即可
在这里插入图片描述

public class SplitStreamByOutputTag {
    private static OutputTag<Tuple3<String, String, Long>> MaryTag = new OutputTag<Tuple3<String, String, Long>>("Mary-pv") {};
    private static OutputTag<Tuple3<String, String, Long>> BobTag = new OutputTag<Tuple3<String, String, Long>>("Bob-pv") {};

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

        SingleOutputStreamOperator<Event> stream = env.addSource(new ClickSource());

        SingleOutputStreamOperator<Event> processedStream = stream.process(new ProcessFunction<Event, Event>() {
            @Override
            public void processElement(Event value, Context ctx, Collector<Event> out) throws Exception {
                if (value.user.equals("Mary")) {
                    ctx.output(MaryTag, new Tuple3<>(value.user, value.url, value.timestamp));
                } else if (value.user.equals("Bob")) {
                    ctx.output(BobTag, new Tuple3<>(value.user, value.url, value.timestamp));
                } else {
                    out.collect(value);
                }
            }
        });

        processedStream.getSideOutput(MaryTag).print("Mary pv");
        processedStream.getSideOutput(BobTag).print("Bob pv");
        processedStream.print("else");

        env.execute();
    }
}

2. 合流

2.1 联合(Union)

  联合操作要求必须流中的数据类型必须相同,合并之后的新流会包括所有流中的元素,数据类型不变
在这里插入图片描述

stream1.union(stream2, stream3, ...)

注意:
  对于合流之后的水位线,以最小的watermark为准,才可以保证所有流都不会再传来水位线之前的数据

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

        SingleOutputStreamOperator<Event> stream1 = env.socketTextStream("192.168.0.23", 7777)
                .map(data -> {
                    String[] field = data.split(",");
                    return new Event(field[0].trim(), field[1].trim(), Long.valueOf(field[2].trim()));
                })
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Event>forBoundedOutOfOrderness(Duration.ofSeconds(2))
                                .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                                    @Override
                                    public long extractTimestamp(Event element, long recordTimestamp) {
                                        return element.timestamp;
                                    }
                                })
                );
        stream1.print("stream1");
        SingleOutputStreamOperator<Event> stream2 = env.socketTextStream("192.168.0.23", 7778)
                .map(data -> {
                    String[] field = data.split(",");
                    return new Event(field[0].trim(), field[1].trim(),
                            Long.valueOf(field[2].trim()));
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy
                        .<Event>forBoundedOutOfOrderness(Duration.ofSeconds(5))
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event element, long
                                    recordTimestamp) {
                                return element.timestamp;
                            }
                        })
                );
        stream2.print("stream2");
        // 合并两条流
        stream1.union(stream2)
                .process(new ProcessFunction<Event, String>() {
                    @Override
                    public void processElement(Event value, Context ctx, Collector<String> out) throws Exception {
                        out.collect(" 水 位 线 : " + ctx.timerService().currentWatermark());
                    }
                })
                .print();
        env.execute();
    }
}

  在合流之后的 ProcessFunction 对应的算子任务中,逻辑时钟的初始状态:
在这里插入图片描述
  由于 Flink 会在流的开始处,插入一个负无穷大(Long.MIN_VALUE)的水位线,所以合流后的 ProcessFunction 对应的处理任务,会为合并的每条流保存一个分区水位线,初始值都是 Long.MIN_VALUE;而此时算子任务的水位线是所有分区水位线的最小值,因此也是Long.MIN_VALUE


2.2 连接(Connect)

2.2.1 连接流(ConnectedStreams)

  DataStream 中的数据只能有唯一的类型,所以连接得到的并不是 DataStream,而是一个连接流(ConnectedStreams)连接流可以看成是两条流形式上的统一,被放在了一个同一个流中;事实上内部仍保持各自的数据形式不变,彼此之间是相互独立的。需要进一步定义一个同处理(co-process)转换操作。两条流可以保持各自的数据类型、处理方式也可以不同,不过最终会统一到同一个 DataStream 中
在这里插入图片描述

public class CoMapExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStream<Integer> stream1 = env.fromElements(1, 2, 3);
        DataStream<Long> stream2 = env.fromElements(1L, 2L, 3L);

        ConnectedStreams<Integer, Long> connectedStreams = stream1.connect(stream2);
        SingleOutputStreamOperator<String> map = connectedStreams.flatMap(new CoFlatMapFunction<Integer, Long, String>() {
            @Override
            public void flatMap1(Integer value, Collector<String> out) throws Exception {
                out.collect("stream1:" + value);
            }

            @Override
            public void flatMap2(Long value, Collector<String> out) throws Exception {
                out.collect("stream2:" + value);
            }
        });

        map.print();
        env.execute();
    }
}

  ConnectedStreams 可直接调用.keyBy()进行按键分区的操作,传入两个参数 keySelector1和 keySelector2,是两条流中各自的键选择器,把两条流中 key 相同的数据放到一起(注意两条流定义的键的类型必须相同,否则会抛出异常)

connectedStreams.keyBy(keySelector1, keySelector2);

2.2.2 CoProcessFunction

在这里插入图片描述
  使用CoProcessFunction方法,需要实现的就是 processElement1()、processElement2()两个方法,在每个数据到来时,会根据来源的流调用其中的一个方法进行处理。CoProcessFunction 可以通过上下文 ctx 来访问 timestamp、水位线,并通过 TimerService 注册定时器;另外提供了.onTimer()方法,用于定义定时触发的处理操作

//实时对账,app 的支付操作和第三方的支付操作的一个双流 Join。App 的支付事件和第三方的支付事件将会互相等待 5 秒钟,如果等不来对应的支付事件,那么就输出报警信息
public class BillCheckExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 来自 app 的支付日志
        SingleOutputStreamOperator<Tuple3<String, String, Long>> appStream = env
                .fromElements(Tuple3.of("order-1", "app", 1000L), Tuple3.of("order-2", "app", 2000L),Tuple3.of("order-3", "app", 9000L))
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple3<String, String, Long>>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple3<String, String, Long>>() {
                            @Override
                            public long extractTimestamp(Tuple3<String, String, Long>
                                                                 element, long recordTimestamp) {
                                return element.f2;
                            }
                        })
                );
        // 来自第三方支付平台的支付日志
        SingleOutputStreamOperator<Tuple4<String, String, String, Long>> thirdpartStream = env
                .fromElements(Tuple4.of("order-1", "third-party", "success", 3000L), Tuple4.of("order-3", "third-party", "success", 4000L), Tuple4.of("order-4", "third-party", "success", 8000L))
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple4<String, String, String, Long>>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple4<String, String, String, Long>>() {
                            @Override
                            public long extractTimestamp(Tuple4<String, String, String, Long>
                                                                 element, long recordTimestamp) {
                                return element.f3;
                            }
                        })
                );
        // 检测同一支付单在两条流中是否匹配,不匹配就报警
        appStream.connect(thirdpartStream)
                .keyBy(data -> data.f0, data -> data.f0)
                .process(new OrderMatchResult())
                .print();
        env.execute();
    }

    // 自定义实现 CoProcessFunction
    public static class OrderMatchResult extends CoProcessFunction<Tuple3<String, String, Long>, Tuple4<String, String, String, Long>, String> {
        // 定义状态变量,用来保存已经到达的事件
        private ValueState<Tuple3<String, String, Long>> appEventState;
        private ValueState<Tuple4<String, String, String, Long>> thirdPartyEventState;

        @Override
        public void open(Configuration parameters) throws Exception {
            appEventState = getRuntimeContext().getState(new ValueStateDescriptor<Tuple3<String, String, Long>>("app-event", Types.TUPLE(Types.STRING, Types.STRING, Types.LONG)));
            thirdPartyEventState = getRuntimeContext().getState(new ValueStateDescriptor<Tuple4<String, String, String, Long>>("thirdparty-event", Types.TUPLE(Types.STRING, Types.STRING, Types.STRING, Types.LONG)));
        }

        @Override
        public void processElement1(Tuple3<String, String, Long> value, Context ctx, Collector<String> out) throws Exception {
            if (thirdPartyEventState.value() != null) {
                out.collect(" 对 账 成 功 : " + value + " " + thirdPartyEventState.value());
                // 清空状态
                thirdPartyEventState.clear();
            } else {
                appEventState.update(value);
                ctx.timerService().registerEventTimeTimer(value.f2 + 5000L);
            }
        }

        @Override
        public void processElement2(Tuple4<String, String, String, Long> value, Context ctx, Collector<String> out) throws Exception {
            if (appEventState.value() != null) {
                out.collect("对账成功:" + appEventState.value() + " " + value);
                // 清空状态
                appEventState.clear();
            } else {
                // 更新状态
                thirdPartyEventState.update(value);
                // 注册一个 5 秒后的定时器,开始等待另一条流的事件
                ctx.timerService().registerEventTimeTimer(value.f3 + 5000L);
            }
        }
        @Override
        public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
            // 定时器触发,判断状态,如果某个状态不为空,说明另一条流中事件没来
            if (appEventState.value() != null) {
                out.collect("对账失败:" + appEventState.value() + " " + "第三方支付平台信息未到");
            }
            if (thirdPartyEventState.value() != null) {
                out.collect("对账失败:" + thirdPartyEventState.value() + " " + "app信息未到");
            }
            appEventState.clear();
            thirdPartyEventState.clear();
        }
    }
}

2.2.3 广播连接流(BroadcastConnectedStream)

  DataStream 调用.connect()方法时,传入的参数可以不是一个 DataStream,而是一个广播流(BroadcastStream),这时合并两条流得到的就变成了一个广播连接(BroadcastConnectedStream)
  这种连接方式往往用在需要动态定义某些规则或配置的场景。因为规则是实时变动的,所以可以用一个单独的流来获取规则数据;而这些规则或配置是对整个应用全局有效的,所以不能只把这数据传递给一个下游并行子任务处理,而是要广播(broadcast)给所有的并行子任务。而下游子任务收到广播出来的规则,会把它保存成一个状态,即广播状态(broadcast state)
  广播状态底层是用一个映射(map)结构来保存的。在代码实现上,可以直接调用DataStream 的.broadcast()方法,传入一个映射状态描述器(MapStateDescriptor)说明状态的名称和类型,就可以得到规则数据的广播流(BroadcastStream)

MapStateDescriptor<String, Rule> ruleStateDescriptor = new 
MapStateDescriptor<>(...);
BroadcastStream<Rule> ruleBroadcastStream = ruleStream
 .broadcast(ruleStateDescriptor);
DataStream<String> output = stream
 .connect(ruleBroadcastStream)
 .process( new BroadcastProcessFunction<>() {...} );

  BroadcastProcessFunction 与 CoProcessFunction 类似,同样是一个抽象类,需要实现两个方法,针对合并的两条流中元素分别定义处理操作。区别在于这里一条流是正常处理数据,而另一条流则是要用新规则来更新广播状态,所以对应的两个方法叫作.processElement()和.processBroadcastElement()
在这里插入图片描述


2.2 基于时间的合流——双流联结(Join)

双流联结

Flink双流JOIN 阅读详情

相关推荐

Flink-多流转换(合流,分流,双流join)

Flink的合流、分流、以及双流join,广播流,测输出流各种流详解以及案例

m0_46507516的博客 4317

【Flink】Flink 的分流操作

所谓的分流就是将一条数据去拆分成多条数据流, 就是基于一个DataStream , 来得到多个平等的DataStream 简单的代码实现 使用侧输出流

iiiitttttt的博客 2048

flink分流

分流

JustinMars的博客 1813

Flink Flink中的分流

所谓“分流”,就是将一条数据流拆分成完全独立的两条、甚至多条流。也就是基于一个DataStream,定义一些筛选条件,将符合条件的数据拣选出来放到对应的流里。

文文x的博客 1730

Flink,join,coGroup,connect,union的区别、使用和实

join: 1 可用于DataStream和DataSet。只能2个DataStream一起join,或者2个DataSet一起join 2 用于DataStream时返回是JoinedStreams ,用于DataSet时返回是JoinOperatorSets 3用于DataStream时需要与窗口同时使用,语法是:join where equalTo window apply ,用于DataSet时的语法是:join where equalTo with (where是指定第一个输入的分区...

Top5软件工程硕士,先后在京东、字节从事多年Java后端开发、实时和离线大数据开发 7705

大麦网抢票软件工具开发系列(一)

前言《大麦网》都知道吧,就是那个被网友声称“大麦网你卖啥了?”票务平台。近期有听到朋友说《大麦网》的票很难抢,基本上都是说:“哎哟喂,被挤爆啦,请稍后重试!”,也不知道《大麦网》...

架构文摘 1万+

最新 Flink 1.13 多流转换(Union、Connect、Window Join、Interval Join、Window CoGroup)快速入门、详细教程

一、分流;二、基本合流;1. 联合(Union);2. 连接(Connect);2.2 广播连接流(BroadcastConnectedStreams);三、基于时间的合流--双流联结(Join);1.窗口联结(Window Join);2. 间隔联结(Interval Join);3. 窗口同组联结(Window CoGroup);四、Flink 常见的维表 Join 方案;1. 预加载;2. 热存储;3.广播维表;4. Temporal join

博文约礼 1877

Habitat安装全网最详细教程,手把手带你跑通example.py(全网唯一)

全网最详细具身智能仿真平台habitat的安装教程

shannanshouyin的博客 2762

Flink多流转换实战:从电商订单对账到用户行为分析,5个真实场景代码详解

本文深入解析Flink多流转换技术在电商和用户行为分析中的实战应用,涵盖订单对账、用户行为路径分析等5个真实场景。通过双流join、合流与分流等核心操作,结合完整代码示例,展示如何实现高效实时数据处理与业务洞察,提升系统响应速度与决策精准度。

sre5engineer的博客 455

飞牛fnOS安装1Panel后Docker容器消失?三步教你恢复数据并避免踩坑

本文详细解析了飞牛fnOS安装1Panel后Docker容器消失的问题,指出这是由于daemon.json文件被覆盖导致。通过SSH连接、修复配置文件和系统重启三个步骤,用户可以轻松恢复数据。文章还提供了预防措施和最佳实践,帮助用户避免类似问题。

yellow的专栏 875

FPGA 上的 YOLOv8 实时目标检测:从模型优化到硬件加速全解析

本文全面解析了将YOLOv8目标检测模型部署到FPGA进行硬件加速的完整流程。通过模型裁剪、混合精度量化等优化手段,结合HLS设计专用计算引擎与数据流,实现了高能效比的实时推理。文章深入探讨了软硬协同部署、性能调试与优化技巧,为追求极致实时性与低功耗的边缘AI应用提供了从算法到硬件的实战指南。

weixin_29031161的博客 609

Flink多流转换(1)—— 分流&合流

本文介绍了flink多流转换中的分流和河流

WHY的博客 2540

在MDK5.37版本中添加Complier Version 5( 解决Missing Compiler Version 5 )

本文章仅作为个人学习记录,方法也是从其他博主的博客中得到的,链接如下:二、Keil——Missing Compiler Version 5 和 core_cm3.c 问题解决 - YI颗白菜 - 博客园 (cnblogs.com) 问题描述 更新最新的keil版本(MDK5.37)后,在编译以前版本的工程文件时,发现出现了非常多的报错,在网上搜索之后发现原来时编译器版本不匹配的问题,即MDK5.37中使用的是Version 6版本的编译器,而缺少Version 5,对于以前编写的工

leveling99的博客 1万+

flink的分流操作,简单易懂,赶紧收藏!

案例:kafka数据格式为json类型,json中的value有数组,也有json的,数组元素是json。现在提供这么一个场景,数据中的元素为同一类信息,将info 数组中的每个元素单独作为一个json串输出,同时将tags的值输出。而侧输出流的标记和提取,都离不开一个“输出标签”(OutputTag),它指定了侧输出流的id和类型。flink消费kafka,根据数据业务特点解耦写入不同的主题中,这常见场景就是日志数据,性能数据等要这样处理,后续再消费不同的主题进行实时分析.// 1.读kafka。

m0_73541150的博客 1412

【ArcGIS Pro微课1000例】0073:ArcGIS Pro3.5.2学习版下载及安装教程

ArcGIS Pro 3.5.2安装教程摘要:系统需Windows10及以上,8GB内存(推荐32GB)。安装步骤:1)安装.NET 8.0运行环境;2)执行主程序安装包,按向导完成基础安装;3)安装升级补丁;4)替换AfCore.dll文件并导入注册表。注意安装后删除临时文件节省空间。软件下载地址包含在百度网盘链接。安装过程需依次完成环境配置、主程序安装、补丁更新及破解步骤。

智慧空间实验室 1788

第3.2.1章 Eigen代码实战:四元数赋值用法总结及与变换矩阵转换

Eigen库中四元数(Quaternion)的赋值方法解析:Quaterniond和Quaternion<double>本质相同,但Quaterniond是更简洁的别名。主要赋值方式包括直接构造(w,x,y,z分量、旋转矩阵或轴角)、赋值运算符和成员函数赋值。使用时需注意参数顺序、归一化处理和头文件包含,常见错误包括模板参数缺失和构造顺序错误。四元数广泛应用于旋转矩阵转换、姿态组合等场景,合理选择赋值方式能提高代码可读性和正确性。

行知SLAM 587

Flink之多流转换(分流、合流)

无论是基本的简单转换和聚合,还是基于窗口的计算,我们都是针对一条流上的数据进行处理的。而在实际应用中,可能需要将不同来源的数据连接合并在一起处理,也有可能需要将一条流拆分开,所以经常会有对多条流进行处理的场景。本章我们就来讨论 Flink 中对多条流进行转换的操作。 简单划分的话,多流转换可以分为“分流”和“合流”两大类。目前分流的操作一般是通过侧输出流(side output)来实现,而合流的算子比较丰富,根据不同的需求可以调用 union、connect、join 以及 coGroup 等接口进行连接

四维大脑的博客 3160

ABAP Cloud:面向云时代的 ABAP 开发范式与实践指南

摘要: 本文系统讲解SAP ABAP Cloud开发模型,涵盖其架构、工具链、规范及实践。ABAP Cloud作为统一开发模型,支持在SAP BTP和S/4HANA上构建云就绪应用,遵循clean core原则,通过RAP(RESTful应用编程模型)实现低耦合扩展。文章详细解析其核心构成(RAP、稳定API、clean core约束)、工具链(ADT、软件物流)及两种典型扩展场景(on-stack与side-by-side),并附可运行RAP示例代码(如销售笔记应用)。重点强调通过规范开发确保系统可升级性

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 416

FLINK 分流

在Apache Flink中,分流(Stream Splitting)是指将一条数据流拆分成完全独立的两条或多条流的过程。这通常基于一定的筛选条件,将符合条件的数据拣选出来并放入对应的流中。

王小工小工历程 2006

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Flink 多流转换之 Union(联合)数据流

Flink 多流转换-Union 联合且排序

寒枫的博客 1901

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Flink的Interval-join实现原理,以及关联不上怎么办

动态表---做Join转换的流--->(假如左主)会受到三条消息:左null+,左null-,左右+普通Join(Window和IntervalJoin)底层维护了俩状态,所以。③用此数据和另外一条流中的缓存数据做关联。⑤判断数据是否超过上限时间,做缓存清除。使用回撤流/upsertKafka。④根据关联逻辑进行处理。

weixin_47950169的博客 1979

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Flink学习笔记(四):flink数据分流

前面介绍了如何从kafka获取数据,那么当大量数据格式不一致的时候想对某一种类型进行处理该如何实现呢? flink为我们提供了一套处理方式,分流处理 一、分流场景 原Stream流需要拆分为Stream1和Stream2流 Stream1需要再次拆分为StreamA,StreamB流 Stream2需要再次拆分为StreamC,StreamD流 #mermaid-svg-q9Cu4aiUUcUi8KGu .label { font-family: 'trebuchet ms', verdana,

小白的专栏 2381

Flink 三种数据流分流(推荐旁路分流)

前言 ​ 近来,因为flink版本的漏洞:CVE—2020—17519#Apache,官方进行了1.12大版本更新,并说到:我们强烈建议所有用户升级到Flink 1.12.1。然后我就发现了Remove deprecated DataStream#split。文中介绍的split方法已经被舍弃(移除),官方推荐使用Side Outputs(旁路分流)。但是我还是保留了该部分代码,一方面是flink的演变的变化,另外一方面写也写了(删了多不好[< _<])。 ​ 所以目前flink 1.12.1只

长臂人猿的博客 5037

Flink双流Join 3种解决方案 + 2种优化方案

这一期的面试题主要是介绍下面的答案都是博主收集小伙伴萌的答案 + 博主自己的理解进行的一个总结。

2301_78556605的博客 2275

Flink中的多流转换

在Flink的使用过程中,经常可能会遇到将一个流的数据拆分成多个流,此时就需要将一个DataStream拆分成独立的两个或多个DataStream,一般情况下可能需要根据一些条件将不同的数据过滤出来写入不同的流。在1.13版本中,使用处理函数(process function)的侧输出流(side output)将一个流进行拆分。处理函数本身可以认为是一个转换算子,它的输出类型比较单一,处理之后得到的仍然是一个DataStream。但是侧输出流并不受此限制,可以任意自定义输出数据,看起来就像从主流分叉出来的

大数据进阶之路 1297

Flink 双流 Join 的3种操作示例

在数据库中的静态表上做 OLAP 分析时,两表 join 是非常常见的操作。同理,在流式处理作业中,有时也需要在两条流上做 join 以获得更丰富的信息。Flink DataStream...

Ververica的博客 1950
上一篇: flink 控制窗口行为(触发器、移除器、允许延迟、将迟到的数据放入侧输出流)
下一篇: flink Window Join、Interval Join、Window CoGroup (两流匹配 指定key联结,开窗口进行窗口操作)
但行益事莫问前程
但行益事莫问前程 新星创作者: 数据库技术领域 新星创作者: 数据库技术领域
博客等级 码龄7年 8490粉丝 225原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

但行益事莫问前程

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

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

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

打赏作者

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

抵扣说明:

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

余额充值