flink Window Join、Interval Join、Window CoGroup (两流匹配 指定key联结,开窗口进行窗口操作)

Flink SQL:Queries(Window JOIN) 阅读详情


1. 窗口联结(Window Join)

  Flink 提供了一个窗口联结(window join)算子,可以定义时间窗口,并将两条流中共享一个公共键(key)的数据放在窗口中进行配对处理

1.1 窗口联结的调用

  窗口联结在代码中的实现,首先需要调用 DataStream 的.join()方法来合并两条流,得到一个 JoinedStreams;接着通过.where()和.equalTo()方法指定两条流中联结的 key;然后通过.window()开窗口,并调用.apply()传入联结窗口函数进行处理计算

stream1.join(stream2)
 .where(<KeySelector>)
 .equalTo(<KeySelector>)
 .window(<WindowAssigner>)
 .apply(<JoinFunction>)

  .where()的参数是键选择器(KeySelector),用来指定第一条流中的 key; 而.equalTo()传入的 KeySelector 则指定了第二条流中的 key。两者相同的元素,如果在同一窗口中,就可以匹配起来

1.2 窗口联结的处理流程

  首先会按照 key 分组、进入对应的窗口中存储;当到达窗口结束时间时,算子会先统计出窗口内两条流的数据的所有组合,也就是对两条流中的数据做一个笛卡尔积(相当于表的交叉连接,cross join),然后进行遍历,把每一对匹配的数据,作为参数(first,second)传入 JoinFunction 的.join()方法进行计算处理,得到的结果直接输出。所以窗口中每有一对数据成功联结匹配,JoinFunction的.join()方法就会被调用一次,并输出一个结果
在这里插入图片描述

1.3 窗口联结实例

public class WindowJoinExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStream<Tuple2<String, Long>> stream1 = env.fromElements(Tuple2.of("a", 1000L), Tuple2.of("b", 1000L), Tuple2.of("a", 2000L), Tuple2.of("b", 2000L))
                .assignTimestampsAndWatermarks(WatermarkStrategy
                        .<Tuple2<String, Long>>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                                   @Override
                                                   public long extractTimestamp(Tuple2<String, Long> stringLongTuple2, long l) {
                                                       return stringLongTuple2.f1;
                                                   }
                                               }
                        )
                );
        DataStream<Tuple2<String, Long>> stream2 = env.fromElements(Tuple2.of("a", 3000L), Tuple2.of("b", 3000L), Tuple2.of("a", 4000L), Tuple2.of("b", 4000L))
                .assignTimestampsAndWatermarks(WatermarkStrategy
                        .<Tuple2<String, Long>>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                                   @Override
                                                   public long extractTimestamp(Tuple2<String,
                                                           Long> stringLongTuple2, long l) {
                                                       return stringLongTuple2.f1;
                                                   }
                                               }
                        )
                );
        stream1.join(stream2)
                .where(new KeySelector<Tuple2<String, Long>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Long> value) throws Exception {
                        return value.f0;
                    }
                }).equalTo(new KeySelector<Tuple2<String, Long>, String>() {
                               @Override
                               public String getKey(Tuple2<String, Long> value) throws Exception {
                                   return value.f0;
                               }
                           }
        )
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .apply(new FlatJoinFunction<Tuple2<String, Long>, Tuple2<String, Long>, String>() {
                    @Override
                    public void join(Tuple2<String, Long> first, Tuple2<String, Long> second, Collector<String> out) throws Exception {
                        out.collect(first + "=>" + second);
                    }
                })
                .print();
        env.execute();
    }
}

在这里插入图片描述

2.间隔联结(Interval Join)

  在电商网站中,用户行为往往会有短时间内的强关联。假设有两条流,一条是下订单的流,一条是浏览数据的流,可针对同一个用户做一个联结,使用户的下订单事件和用户的最近十分钟的浏览数据进行一个联结查询(Interval Join)

2.1 间隔联结的原理

The interval join joins elements of two streams ( A & B ) with a common key and where elements of stream B have timestamps that lie in a relative time interval to timestamps of elements in stream A
在这里插入图片描述

  对黄色的流(A)中的任意一个数据元素 a,划分一段时间间隔:[a.timestamp + lowerBound, a.timestamp + upperBound],绿色的流( B)中的数据元素 b, key相同且时间戳在这
个区间范围内,a 和 b 成功配对

where a and b are elements of A and B that share a common key. Both the lower and upper bound can be either negative or positive as long as the lower bound is always smaller or equal to the upper bound. The interval join currently only performs inner joins.
When a pair of elements are passed to the ProcessJoinFunction, they will be assigned with the larger timestamp (which can be accessed via the ProcessJoinFunction.Context) of the two elements.

2.2 间隔联结的调用

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(left + "," + right);
        }
    });

2.3 间隔联结实例

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

        SingleOutputStreamOperator<Tuple3<String, String, Long>> orderStream = env.fromElements(
                Tuple3.of("Mary", "order-1", 5000L),
                Tuple3.of("Alice", "order-2", 5000L),
                Tuple3.of("Bob", "order-3", 20000L),
                Tuple3.of("Alice", "order-4", 20000L),
                Tuple3.of("Cary", "order-5", 51000L)
        )
                .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<Event> clickStream = env.fromElements(
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=200", 3500L),
                new Event("Bob", "./prod?id=2", 2500L),
                new Event("Alice", "./prod?id=300", 36000L),
                new Event("Bob", "./home", 30000L),
                new Event("Bob", "./prod?id=1", 23000L),
                new Event("Bob", "./prod?id=3", 33000L)
        )
                .assignTimestampsAndWatermarks(WatermarkStrategy
                        .<Event>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Event>() {
                            @Override
                            public long extractTimestamp(Event element, long recordTimestamp) {
                                return element.timestamp;
                            }
                        })
                );
        orderStream
                .keyBy(new KeySelector<Tuple3<String, String, Long>, String>() {
                    @Override
                    public String getKey(Tuple3<String, String, Long> data) throws Exception {
                        return data.f0;
                    }
                })
                .intervalJoin(clickStream.keyBy(new KeySelector<Event, String>() {
                    @Override
                    public String getKey(Event data) throws Exception {
                        return data.user;
                    }
                }))
                .between(Time.seconds(-5), Time.seconds(10)) //之前5秒钟 之后10秒钟 范围
                .process(new ProcessJoinFunction<Tuple3<String, String, Long>, Event, String>() {
                    @Override
                    public void processElement(Tuple3<String, String, Long> left, Event right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(right + " => " + left);
                    }
                })
                .print();

        env.execute();
    }
}

结果:
在这里插入图片描述


3.窗口同组联结(Window CoGroup)

  与 window join 非常类似,将两条流合并之后开窗处理匹配的元素,调用时只需要将.join()换为.coGroup()

stream1.coGroup(stream2)
 .where(<KeySelector>)
 .equalTo(<KeySelector>)
 .window(TumblingEventTimeWindows.of(Time.hours(1)))
 .apply(<CoGroupFunction>)

  与 window join 的区别在于,调用.apply()方法定义具体操作时,传入的是一个CoGroupFunction
在这里插入图片描述
  传入的三个参数,分别代表两条流中的数据以及用于输出的收集器(Collector)。不同的是,前两个参数不再是单独的每一组配对数据了,而是传入了可遍历的数据集合。即不会再去计算窗口中两条流数据集的笛卡尔积,而是直接把收集到的所有数据一次性传入,至于要怎样配对完全是自定义的。这样.coGroup()方法只会被调用一次,而且即使一条流的数据没有任何另一条流的数据匹配,也可以出现在集合中

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

        DataStream<Tuple2<String, Long>> stream1 = env.fromElements(
                Tuple2.of("a", 1000L),
                Tuple2.of("b", 1000L),
                Tuple2.of("a", 2000L),
                Tuple2.of("b", 2000L)
        )
                .assignTimestampsAndWatermarks(WatermarkStrategy
                        .<Tuple2<String, Long>>forMonotonousTimestamps()
                        .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                                   @Override
                                                   public long extractTimestamp(Tuple2<String, Long> stringLongTuple2, long l) {
                                                       return stringLongTuple2.f1;
                                                   }
                                               }
                        )
                );
        DataStream<Tuple2<String, Long>> stream2 = env.fromElements(
                Tuple2.of("a", 3000L),
                Tuple2.of("b", 3000L),
                Tuple2.of("a", 4000L),
                Tuple2.of("b", 4000L)
        )
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                .<Tuple2<String, Long>>forMonotonousTimestamps()
                                .withTimestampAssigner(new SerializableTimestampAssigner<Tuple2<String, Long>>() {
                                                           @Override
                                                           public long extractTimestamp(Tuple2<String, Long> stringLongTuple2, long l) {
                                                               return stringLongTuple2.f1;
                                                           }
                                                       }
                                )
                );
        stream1
                .coGroup(stream2)
                .where(r -> r.f0)
                .equalTo(r -> r.f0)
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                .apply(new CoGroupFunction<Tuple2<String, Long>, Tuple2<String, Long>, String>() {
                    @Override
                    public void coGroup(Iterable<Tuple2<String, Long>> iter1, Iterable<Tuple2<String, Long>> iter2, Collector<String> collector) throws Exception {
                        collector.collect(iter1 + "=>" + iter2);
                    }
                })
                .print();
        env.execute();
    }
}
Flink教程(22) 窗口 interval join的使用案例 Flink 窗口 interval join的使用一、前言二、interval join介绍三、语法案例 一、前言 在之前的博客两条流关联 window窗口的 join leftJoin使用案例中,介绍了window join的使用方法。 但是window join可能稍微复杂和麻烦,现在在真实的工作中,用interval join的情况比较多。 interval join相对逻辑简单,好理解些。 二、interval join介绍 interval join只支持事件时间的场景 只能支持两条流的关联 在 阅读详情

相关推荐

《Flink应用实战》(四)--合并流-IntervalJoin算子

Flink 中的两个流要实现 Join 操作,必须满足以下两点:流需要能够等待,即:两个流必须在同一个窗口中;双流等值 Join,即:两个流中,必须有一个字段相等才能够 Join 上。Flink 中支持双流 Join 的算子目前已知有5种,如下::union 支持双流 Join,也支持多流 Join。多个流类型必须一致;:connector 支持双流 Join,两个流的类型可以不一致;:该方法只支持 inner join,即:相同窗口下,两个流中,Key都存在且相同时才会关联成功;:同样能够实现双流 Joi

一锅粥 1821

flink的三种windows join

window join用于连接两个流的元素,他们在一个窗口钟用于共享一个公共的key.我们一般可以用一个窗口分配器定义这些窗口(join情况下一般包含了Tumbling Windows (滚动)、Sliding Windows(滑动)和Session Windows (会话窗口)) Windows Join的代码一般形式如下: 注:创建两个流元素的成对组合的行为类似于内连接。如果来自一个流的元素和另一个流没有相对应的连接元素,则不会发出该元素。 结合在一起的那些元素将其时间戳设置为各自窗口的最大时间戳。例

weixin_40809627的博客 3847

大数据必懂知识点:万字长文看懂Flink各种Join

在探讨Flink的Join操作之前,我们需要理解其在整个系统架构中的核心地位。,它使开发者能够灵活地整合来自多个数据源的信息,从而实现更高级的数据分析和业务逻辑。Flink支持多种Join类型,包括等,每种类型都有其特定的应用场景和优势。这些多样化的Join选项使得Flink能够在处理各种复杂的实时数据流问题时表现出色,如等。通过巧妙运用这些Join操作,开发者可以构建出高效、精确的流处理应用程序,充分发挥Flink在大数据处理领域的强大能力。

大模型大数据攻城狮的专栏 1415

43、Flink 的 Window Join 详解

Flink 的 Window Join 详解

猫猫爱吃小鱼粮 838

【天线与电波传播】电波传播部分 第7章 电波传播的基础知识3

菲涅尔区与菲涅尔带的基本知识

Chen59_2328的博客 1602

Imatest-Star模块(西门子星图)

星图分析指南:基于ISO12233标准的MTF测试方法,通过放射状射线和正弦灰度变化评估相机SFR性能。

weixin_64706696的博客 1577

flink window之Window Join

基本语法: stream.join(otherStream) .where(<KeySelector>) .equalTo(<KeySelector>) .window(<WindowAssigner>) .apply(<JoinFunction>) 1、Tumbling Window Join 案例: val fsEnv = StreamExecutionEnvironment.getExecutionEnvironmen

qq_44962429的博客 722

FPGA新手必看:GT收发器示例工程从零搭建到调试(附眼图测试技巧)

本文详细解析了FPGA中GT收发器示例工程的从零搭建到调试全流程,特别适合新手入门。内容涵盖工程创建、GT Wizard IP核配置、示例工程代码解析及眼图测试技巧,帮助读者快速掌握高速串行通信的关键技术。重点介绍了眼图测试的硬件连接规范和常见问题排查方法,提升调试效率。

weixin_29248313的博客 395

Flink--9、双流联结(窗口联结、间隔联结)

双流联结(窗口联结、间隔联结)

星光不问赶路人,岁月不负有心人 1457

Qt多线程实战:如何优雅地处理Modbus设备通信中的线程安全问题

本文深入探讨了在Qt框架下实现Modbus设备通信时的多线程安全问题,提供了优雅的解决方案。通过生产者-消费者模型、任务队列与锁机制等设计模式,有效解决了界面卡顿、数据包错乱等问题。文章还详细介绍了对象生命周期管理、信号槽连接类型选择等关键实现细节,帮助开发者构建稳定可靠的Modbus通信模块。

weixin_30897233的博客 488

手把手教你用mitmproxy抓包抖音数据流(附Python脚本模板)

本文详细介绍了如何使用mitmproxy抓包抖音数据流,包括环境搭建、证书安装和Python脚本模板。从mitmproxy配置到抖音API解析,提供完整的移动端数据流分析方案,帮助开发者快速掌握数据抓取技术,适用于应用优化、竞品分析和安全审计等场景。

weixin_33670786的博客 309

Flink时间窗口和水位线

当一个窗口被触发计算完成后,窗口中的元素会被清除,并且该窗口的状态也会被清除。窗口的触发计算和窗口关闭是两个不同的操作,使用allowedLatenessAIP设置窗口的推迟关闭,即使水位线触发了关窗,因为设置的推迟关窗,窗口只会触发计算,之后属于该窗口的迟到数据到来后仍会触发计算,只有水位线到达延迟关窗时间后窗口才会真正关闭。时间窗口的水位线是参考所有上游任务发送的最小的水位线的,如果存在一个上游任务一直没有数据发送,那么该上游任务的水位线为Long的最小值,窗口将无法触发,所以设置空闲等待时间;

m0_57697768的博客 2500

yolov5 FPGA实现及verilog代码仿真

本文介绍了一种基于FPGA的卷积神经网络加速器设计,采用混合架构实现网络功能。该系统将训练和图像预处理等复杂计算保留在PC端执行,仅将主干网络部署在FPGA上。由于片上资源限制,建议通过外接DDR存储扩展容量。文章提供了完整的Verilog HDL源码,包括卷积单元(convUnit)、卷积层(convLayerSingle)和处理单元(processingElement)等核心模块,均已通过仿真验证。该设计采用流水线结构,使用浮点运算单元实现卷积计算,支持32x32图像输入和5x5卷积核处理。系统架构图中

QQ_778132974的博客 579

Flink 窗口 join

Flink 窗口Join

qq_31021213的博客 1191

基于电能质量治理的场景实例:统一电能质量调节器(UPQC)与并网逆变器集成

本文通过Simulink平台,详细演示了统一电能质量调节器(UPQC)与并网逆变器的集成系统建模与仿真过程。主要内容包括:1)系统架构设计,包含光伏并网系统、非线性负载和电压扰动源;2)UPQC主电路设计,包括串联/并联单元拓扑和控制策略实现;3)与并网逆变器的能量交互与协同控制逻辑;4)典型电能质量问题的仿真测试场景。结果表明,该集成系统能有效治理电压暂降(维持负载电压380V±2%)和电流谐波(电网THD<3%),直流母线电压稳定在800V±5V。该系统为应对复杂电能质量问题提供了"电压

xiaoheshang_123的博客 310

Python实现商品价格监控与波动分析爬虫项目

本文通过完整的代码示例和详细的技术讲解,展示了如何实现商品价格的自动监控和波动分析。该项目不仅适用于个人购物助手,还可以扩展为商家的竞品监控工具。通过结合数据抓取、存储、分析与可视化,能够帮助我们更好地理解市场趋势并做出优化决策。

2201_76125261的博客 1745

Flink SQL Window Join 把时间维度“写进” JOIN 条件里

Window Join 是 Flink SQL 中基于时间窗口的表连接操作,其核心特点是: 时间窗口约束:数据按窗口切分,仅在相同窗口内且key匹配的记录间进行关联 状态清理:窗口结束时输出结果并清理状态,避免无限膨胀 语法上必须满足: 左右表需通过Windowing TVF处理 JOIN条件必须包含窗口边界相等 窗口类型和参数需完全一致 支持多种JOIN形态: INNER/LEFT/RIGHT/FULL OUTER SEMI JOIN(通过IN或EXISTS实现) 典型应用场景包括订单匹配、事件关联和业务

hello.reader 1074

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Flink 多流转换 (六) 窗口同组联结(Window CoGroup)

文章目录 除窗口联结和间隔联结之外,Flink 还提供了一个“窗口同组联结”(window coGroup)操作。它的用法跟 window join 非常类似,也是将两条流合并之后开窗处理匹配的元素,调用时只需要将.join()换为.coGroup()就可以了。 stream1.coGroup(stream2) .where(<KeySelector>) .equalTo(<KeySelector>) .window(TumblingEventTimeWindows.of(Ti

weixin_45417821的博客 1253

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

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

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

java Flink(三十六)Flink多流合并算子UNION、CONNECT、CoGroup、Join

UNION介绍 DataStream.union()方法将两条或者多条DataStream合并成一条具有与输入流相同类型的输出DataStream. 事件合流的方式为FIFO方式。操作符并不会产生一个特定顺序的事件流。union操作符也不会进行去重。每一个输入事件都被发送到了下一个操作符。 说明: 1.union 合并的流的元素必须是相同的 2.union 可以合并多条流 3.union不去重,合流顺序为先进先出 具体用法: DataStream<Sensor...

qq_40771567的博客 7167

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

FlinkSql,如何开窗,如何进行窗口内计算

将表应用一下TVF(table-valued function )函数,返回一个开窗的表,开窗TVF函数目前有三个。直接查询,报错,对于开窗后的表需要用,window_start,window_end。以最简单的Tumble,滚动窗口作为例子,无论什么开窗方式,查询方法是一样的。问题:每10分钟求最近10分钟交易额最大的前2条记录。问题:每10分钟求最近10分钟的总交易额。

javaMylife的博客 2499

【flink番外篇】2、flink的23种算子window join 和interval join 数据倾斜、分区介绍及详细示例(1)- window join

1、Flink 专栏等系列综合文章链接本文主要介绍Flink 的常用的operator window join 及详细示例。 如果需要了解更多内容,可以在本人Flink 专栏中了解更新系统的内容。 本文除了maven依赖外,没有其他依赖。本专题分为四篇文章介绍,即 【flink番外篇】2、flink的23种算子window join 和interval join 数据倾斜、分区介绍及详细示例(1)- window join 【flink番外篇】2、flink的23种算子window join 和interv

alanchanchn的专栏 6万+

最新 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

Flink双流时间窗口联接

Flink 除了可以在一条数据流上使用各种时间窗口算法来处理数据,还支持两条数据流上的一段时间窗口内的数据进行联接操作,类似于SQL中的 join 操作。

程序员小潘 1323

大数据Flink(八十八):Interval Join(时间区间 Join)

刚刚的案例也讲了,Regular Join 会产生回撤流,但是在实时数仓中一般写入的 sink 都是类似于 Kafka 这样的消息队列,然后后面接 clickhouse 等引擎,这些引擎又不具备处理回撤流的能力。可以发现 Inner Interval Join 和其他三种 Outer Interval Join 的区别在于,Outer 在随着时间推移的过程中,如果有数据过期了之后,会根据是否是 Outer 将没有 Join 到的数据也给输出。:Interval Join 在离线的概念中是没有的。

Lansonli(蓝深李)的博客 2831

44、Flink 的 Interval Join 详解

Flink 的 Interval Join 详解

猫猫爱吃小鱼粮 898

Flink系列之:窗口关联

在下面的例子中,通过将 join 的时间区域限定为固定的 5 分钟,数据集被分成两个不同的时间窗口:[12:00,12:05) 和 [12:05,12:10)。例如:在 Flink SQL Client 中,如果类型是 TIMESTAMP(3),2020-04-15 08:05 应该显示成 2020-04-15 08:05:00.000。如果在同一个窗口中,左侧记录在右侧至少有一个匹配的记录时,半窗口连接(Semi Window Join)就会输出左侧的记录。窗口表值函数之后直接使用窗口关联的限制。

zhengzaifeidelushang的博客 693
上一篇: flink 多流转换(侧输出流分流、Union、Connect) 实时对账app 的支付操作和第三方的支付操作的双流 Join
下一篇: flink 状态编程(有状态算子、 算子状态(Operator State)、按键分区状态(Keyed State)、状态持久化、状态后端)
但行益事莫问前程
但行益事莫问前程 新星创作者: 数据库技术领域 新星创作者: 数据库技术领域
博客等级 码龄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、付费专栏及课程。

余额充值