2021年大数据Flink（四十）：Flink模拟双十一实时大屏统计
2024-06-10 15:00:47
目录
Flink模拟双十一实时大屏统计
需求
数据
编码步骤:
1.env
2.source
3.transformation
4.使用上面聚合的结果,实现业务需求:
5.execute
参考代码
实现代码 (基于上面参考代码重新写一套)
实现效果
Flink模拟双十一实时大屏统计
需求
在大数据的实时处理中，实时的大屏展示已经成了一个很重要的展示项，比如最有名的双十一大屏实时销售总价展示。除了这个，还有一些其他场景的应用，比如我们在我们的后台系统实时的展示我们网站当前的pv、uv等等，其实做法都是类似的。
今天我们就做一个最简单的模拟电商统计大屏的小例子，
需求如下：
1.实时计算出当天零点截止到当前时间的销售总额
2.计算出各个分类的销售top3
3.每秒钟更新一次统计结果
数据
首先我们通过自定义source 模拟订单的生成，生成了一个Tuple2,第一个元素是分类，第二个元素表示这个分类下产生的订单金额，金额我们通过随机生成.
/*** 自定义数据源实时产生订单数据Tuple2<分类, 金额>*/
public static class MySource implements SourceFunction<Tuple2<String, Double>>{private boolean flag = true;private String[] categorys = {"女装", "男装","图书", "家电","洗护", "美妆","运动", "游戏","户外", "家具","乐器", "办公"};private Random random = new Random();@Overridepublic void run(SourceContext<Tuple2<String, Double>> ctx) throws Exception {while (flag){//随机生成分类和金额int index = random.nextInt(categorys.length);//[0~length) ==> [0~length-1]String category = categorys[index];//获取的随机分类double price = random.nextDouble() * 100;//注意nextDouble生成的是[0~1)之间的随机数,*100之后表示[0~100)ctx.collect(Tuple2.of(category,price));Thread.sleep(20);}}@Overridepublic void cancel() {flag = false;}
}编码步骤:
1.env
2.source
3.transformation
3.1定义大小为一天的窗口,第二个参数表示中国使用的UTC+08:00时区比UTC时间早
keyBy(t->t.f0)
window(TumblingProcessingTimeWindows.of(Time.days(1), Time.hours(-8))
3.2定义一个1s的触发器
.trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(1)))
3.3聚合结果.aggregate(new PriceAggregate(), new WindowResult());
3.4看一下聚合的结果
CategoryPojo(category=男装, totalPrice=17225.26, dateTime=2020-10-20 08:04:12)
4.使用上面聚合的结果,实现业务需求:
tempAggResult.keyBy(CategoryPojo::getDateTime)
//每秒钟更新一次统计结果
.window(TumblingProcessingTimeWindows.of(Time.seconds(1)))
//在ProcessWindowFunction中实现该复杂业务逻辑
.process(new WindowResultProcess());
4.1实时计算出当天零点截止到当前时间的销售总额
4.2.计算出各个分类的销售top3
4.3.每秒钟更新一次统计结果
5.execute
参考代码
package cn.it.action;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.FastDateFormat;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
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.triggers.ContinuousProcessingTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.stream.Collectors;/*** Author lanson* Desc* 1.实时计算出当天零点截止到当前时间的销售总额 11月11日 00:00:00 ~ 23:59:59* 2.计算出各个分类的销售top3* 3.每秒钟更新一次统计结果*/
public class DoubleElevenBigScreem {public static void main(String[] args) throws Exception {//TODO 1.envStreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);env.setParallelism(1);//方便观察//TODO 2.sourceDataStream<Tuple2<String, Double>> orderDS = env.addSource(new MySource());//TODO 3.transformation--初步聚合:每隔1s聚合一下截止到当前时间的各个分类的销售总金额DataStream<CategoryPojo> tempAggResult = orderDS//分组.keyBy(t -> t.f0)//如果直接使用之前学习的窗口按照下面的写法表示://表示每隔1天计算一次//.window(TumblingProcessingTimeWindows.of(Time.days(1)));//表示每隔1s计算最近一天的数据,但是11月11日 00:01:00运行计算的是: 11月10日 00:01:00~11月11日 00:01:00 ---不对!//.window(SlidingProcessingTimeWindows.of(Time.days(1),Time.seconds(1)));//*例如中国使用UTC+08:00，您需要一天大小的时间窗口，//*窗口从当地时间的00:00:00开始，您可以使用{@code of(时间.天(1),时间.hours(-8))}.//下面的代码表示从当天的00:00:00开始计算当天的数据,缺一个触发时机/触发间隔//3.1定义大小为一天的窗口,第二个参数表示中国使用的UTC+08:00时区比UTC时间早.window(TumblingProcessingTimeWindows.of(Time.days(1), Time.hours(-8)))//3.2自定义触发时机/触发间隔.trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(1)))//.sum()//简单聚合//3.3自定义聚合和结果收集//aggregate(AggregateFunction<T, ACC, V> aggFunction,WindowFunction<V, R, K, W> windowFunction).aggregate(new PriceAggregate(), new WindowResult());//aggregate支持复杂的自定义聚合//3.4看一下聚合的结果tempAggResult.print("初步聚合的各个分类的销售总额");//初步聚合的各个分类的销售总额> DoubleElevenBigScreem.CategoryPojo(category=游戏, totalPrice=563.8662504982619, dateTime=2021-01-19 10:31:40)//初步聚合的各个分类的销售总额> DoubleElevenBigScreem.CategoryPojo(category=办公, totalPrice=876.5216500403918, dateTime=2021-01-19 10:31:40)//TODO 4.sink-使用上面初步聚合的结果(每隔1s聚合一下截止到当前时间的各个分类的销售总金额),实现业务需求:tempAggResult.keyBy(CategoryPojo::getDateTime).window(TumblingProcessingTimeWindows.of(Time.seconds(1)))//每隔1s进行最终的聚合并输出结果//.sum//简单聚合//.apply().process(new FinalResultWindowProcess());//在ProcessWindowFunction中实现该复杂业务逻辑//TODO 5.executeenv.execute();}/*** 自定义数据源实时产生订单数据Tuple2<分类, 金额>*/public static class MySource implements SourceFunction<Tuple2<String, Double>> {private boolean flag = true;private String[] categorys = {"女装", "男装", "图书", "家电", "洗护", "美妆", "运动", "游戏", "户外", "家具", "乐器", "办公"};private Random random = new Random();@Overridepublic void run(SourceContext<Tuple2<String, Double>> ctx) throws Exception {while (flag) {//随机生成分类和金额int index = random.nextInt(categorys.length);//[0~length) ==> [0~length-1]String category = categorys[index];//获取的随机分类double price = random.nextDouble() * 100;//注意nextDouble生成的是[0~1)之间的随机小数,*100之后表示[0~100)的随机小数ctx.collect(Tuple2.of(category, price));Thread.sleep(20);}}@Overridepublic void cancel() {flag = false;}}/*** 自定义聚合函数,指定聚合规则* AggregateFunction<IN, ACC, OUT>*/private static class PriceAggregate implements AggregateFunction<Tuple2<String, Double>, Double, Double> {//初始化累加器@Overridepublic Double createAccumulator() {return 0D;//D表示double,L表示Long}//把数据累加到累加器上@Overridepublic Double add(Tuple2<String, Double> value, Double accumulator) {return value.f1 + accumulator;}//获取累加结果@Overridepublic Double getResult(Double accumulator) {return accumulator;}//合并各个subtask的结果@Overridepublic Double merge(Double a, Double b) {return a + b;}}/*** 自定义窗口函数,指定窗口数据收集规则* WindowFunction<IN, OUT, KEY, W extends Window>*/private static class WindowResult implements WindowFunction<Double, CategoryPojo, String, TimeWindow> {private FastDateFormat df = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");@Override//void apply(KEY key, W window, Iterable<IN> input, Collector<OUT> out)public void apply(String category, TimeWindow window, Iterable<Double> input, Collector<CategoryPojo> out) throws Exception {long currentTimeMillis = System.currentTimeMillis();String dateTime = df.format(currentTimeMillis);Double totalPrice = input.iterator().next();out.collect(new CategoryPojo(category,totalPrice,dateTime));}}/*** 用于存储聚合的结果*/@Data@AllArgsConstructor@NoArgsConstructorpublic static class CategoryPojo {private String category;//分类名称private double totalPrice;//该分类总销售额private String dateTime;// 截止到当前时间的时间,本来应该是EventTime,但是我们这里简化了直接用当前系统时间即可}/*** 自定义窗口完成销售总额统计和分类销售额top3统计并输出* abstract class ProcessWindowFunction<IN, OUT, KEY, W extends Window>*/private static class FinalResultWindowProcess extends ProcessWindowFunction<CategoryPojo, Object, String, TimeWindow> {//注意://下面的key/dateTime表示当前这1s的时间//elements:表示截止到当前这1s的各个分类的销售数据@Overridepublic void process(String dateTime, Context context, Iterable<CategoryPojo> elements, Collector<Object> out) throws Exception {//1.实时计算出当天零点截止到当前时间的销售总额 11月11日 00:00:00 ~ 23:59:59double total = 0D;//用来记录销售总额//2.计算出各个分类的销售top3:如: "女装": 10000 "男装": 9000 "图书":8000//注意:这里只需要求top3,也就是只需要排前3名就行了,其他的不用管!当然你也可以每次对进来的所有数据进行排序,但是浪费!//所以这里直接使用小顶堆完成top3排序://70//80//90//如果进来一个比堆顶元素还有小的,直接不要//如果进来一个比堆顶元素大,如85,直接把堆顶元素删掉,把85加进去并继续按照小顶堆规则排序,小的在上面,大的在下面//80//85//90//创建一个小顶堆//https://blog.csdn.net/hefenglian/article/details/81807527Queue<CategoryPojo> queue = new PriorityQueue<>(3,//初识容量//正常的排序,就是小的在前,大的在后,也就是c1>c2的时候返回1,也就是升序,也就是小顶堆(c1, c2) -> c1.getTotalPrice() >= c2.getTotalPrice() ? 1 : -1);for (CategoryPojo element : elements) {double price = element.getTotalPrice();total += price;if(queue.size()< 3){queue.add(element);//或offer入队}else{if(price >= queue.peek().getTotalPrice()){//peek表示取出堆顶元素但不删除//queue.remove(queue.peek());queue.poll();//移除堆顶元素queue.add(element);//或offer入队}}}//代码走到这里那么queue存放的就是分类的销售额top3,但是是升序.需要改为逆序然后输出List<String> top3List = queue.stream().sorted((c1, c2) -> c1.getTotalPrice() >= c2.getTotalPrice() ? -1 : 1).map(c -> "分类:" + c.getCategory() + " 金额:" + c.getTotalPrice()).collect(Collectors.toList());//3.每秒钟更新一次统计结果-也就是直接输出double roundResult = new BigDecimal(total).setScale(2, RoundingMode.HALF_UP).doubleValue();//四舍五入保留2位小数System.out.println("时间: "+dateTime +" 总金额 :" + roundResult);System.out.println("top3: \n" + StringUtils.join(top3List,"\n"));}}
}实现代码 (基于上面参考代码重新写一套)
package cn.lanson.action;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.time.FastDateFormat;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
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.triggers.ContinuousProcessingTimeTrigger;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.PriorityQueue;
import java.util.Random;/*** Author lanson* Desc今天我们就做一个最简单的模拟电商统计大屏的小例子，* 需求如下：* 1.实时计算出当天零点截止到当前时间的销售总额* 2.计算出各个分类的销售额最大的top3* 3.每秒钟更新一次统计结果*/
public class DoubleElevenBigScreen {public static void main(String[] args) throws Exception {//TODO 1.envStreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();env.setRuntimeMode(RuntimeExecutionMode.AUTOMATIC);//TODO 2.source//订单数据Tuple2<分类, 金额>DataStreamSource<Tuple2<String, Double>> orderDS = env.addSource(new MySource());//TODO 3.transformation//-1.每秒预聚合各个分类的销售总额:从当天0点开始截止到目前为止的各个分类的销售总额SingleOutputStreamOperator<CategoryPojo> aggregateResult = orderDS.keyBy(t -> t.f0)//注意:下面的窗口表示每隔1天计算最近1天的数据,//.window(TumblingProcessingTimeWindows.of(Time.days(1)));//注意:下面的窗口表示每隔1s计算最近1天的数据(如果现在是1点,那么计算的是昨天1点到现在1点的1天的数据,而不是当天0点开始截止到目前为止的数据)//.window(SlidingProcessingTimeWindows.of(Time.days(1), Time.seconds(1)));//注意:中国使用UTC+08:00，您需要一天大小的时间窗口，//窗口从当地时间的每00:00:00开始，您可以使用{@code of（time.days（1），time.hours（-8））}.window(TumblingProcessingTimeWindows.of(Time.days(1), Time.hours(-8)))//注意:下面表示每秒触发计算.trigger(ContinuousProcessingTimeTrigger.of(Time.seconds(1)))//聚合(可以使用之前学习的简单聚合:sum/reduce/或自定义聚合:apply或使用aggregate聚合(可以指定如何聚合及如何收集聚合结果)).aggregate(new MyAggregate(), new MyWindow());//输出查看下预聚合的结果//aggregateResult.print();//按照分类将订单金额进行聚合://分类名称 金额 时间//男装 100 2021-11-11 11:11:11//女装 100 2021-11-11 11:11:11//男装 200 2021-11-11 11:11:12//女装 200 2021-11-11 11:11:12//-2.计算所有分类的销售总额和分类销售额最大Top3//要是每秒更新/计算所有分类目前的销售总额和分类销售额Top3//aggregateResult.keyBy(CategoryPojo::getDateTime)aggregateResult.keyBy(c -> c.getDateTime())//先按照时间对数据分组,因为后续要每秒更新/计算销售总额和分类销售额Top3.window(TumblingProcessingTimeWindows.of(Time.seconds(1)))//.apply(new WindowFunction<CategoryPojo, Object, String, TimeWindow>() {}).process(new MyProcessWindowFunction());//TODO 4.sink//TODO 5.executeenv.execute();}/*** abstract class ProcessWindowFunction<IN, OUT, KEY, W extends Window>*/public static class MyProcessWindowFunction extends ProcessWindowFunction<CategoryPojo, Object, String, TimeWindow> {@Overridepublic void process(String key, Context context, Iterable<CategoryPojo> categoryPojos, Collector<Object> out) throws Exception {Double totalAmount = 0d;//用来记录销售总额//用大小顶堆来计算TopN//用大顶堆(大的数据在堆顶,取最小的TopN时使用)还是小顶堆(小的数据在堆顶,取最大的TopN时使用)?//2--堆顶//3//4--堆底//5进来,比堆顶大,堆顶元素移除,5下沉//3//4//5//1进来,比堆顶小,原来不变//3//4//5//100进来,比堆顶大,堆顶元素移除,100下沉//4//5//100//注意:Java里面提供了一个优先级队列PriorityQueue实现了大小顶堆的功能//https://blog.csdn.net/hefenglian/article/details/81807527//所以创建一个长度为3的PriorityQueue,并指定比较规则(正常的比较规则:元素1>=元素2 ? 1:-1,就是小顶堆)PriorityQueue<CategoryPojo> queue = new PriorityQueue<>(3, (c1, c2) -> c1.getTotalPrice() >= c2.getTotalPrice() ? 1 : -1);for (CategoryPojo categoryPojo : categoryPojos) {//--1.计算截止到目前为止的所有分类的销售总额totalAmount += categoryPojo.getTotalPrice();//--2.分类销售额最大Top3if (queue.size() < 3) {queue.add(categoryPojo);} else {//queue.size() >= 3//查看堆顶元素,但不移除CategoryPojo peek = queue.peek();if (categoryPojo.getTotalPrice() > peek.getTotalPrice()) {//进来的元素比堆顶大//堆顶元素移除,进来的元素下沉//queue.remove(peek);queue.poll();queue.add(categoryPojo);}/*else{//进来的元素比堆顶小,不用变}*/}}//--3.直接在这里输出System.out.println("================================================================================================================================");System.out.println("----当前时间:----");System.out.println(key);System.out.println("----销售总额:----");System.out.println(new BigDecimal(totalAmount).setScale(2, RoundingMode.HALF_UP));System.out.println("----销售额Top3分类:----");queue.stream().map(c -> {c.setTotalPrice(new BigDecimal(c.getTotalPrice()).setScale(2, RoundingMode.HALF_UP).doubleValue());return c;}).sorted((c1, c2) -> c1.getTotalPrice() <= c2.getTotalPrice() ? 1 : -1).forEach(System.out::println);}}/*** interface AggregateFunction<IN, ACC, OUT>* 自定义聚合函数,实现各个分类销售额的预聚合/累加*/public static class MyAggregate implements AggregateFunction<Tuple2<String, Double>, Double, Double> {//初始化累加器@Overridepublic Double createAccumulator() {return 0d;}//将数据聚合/累加到累加器上@Overridepublic Double add(Tuple2<String, Double> value, Double accumulator) {return value.f1 + accumulator;}//获取累加结果@Overridepublic Double getResult(Double accumulator) {return accumulator;}//合并结果(和历史结果合并)@Overridepublic Double merge(Double a, Double b) {return a + b;}}/*** interface WindowFunction<IN, OUT, KEY, W extends Window>* 自定义窗口函数,实现窗口聚合数据的收集*/public static class MyWindow implements WindowFunction<Double, CategoryPojo, String, TimeWindow> {private FastDateFormat df = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");@Overridepublic void apply(String key, TimeWindow window, Iterable<Double> input, Collector<CategoryPojo> out) throws Exception {double totalPrice = 0d;for (Double price : input) {totalPrice += price;}//System.out.println(df.format(window.getStart())+"-----"+df.format(window.getEnd()));CategoryPojo categoryPojo = new CategoryPojo();categoryPojo.setCategory(key);categoryPojo.setDateTime(df.format(System.currentTimeMillis()));categoryPojo.setTotalPrice(totalPrice);out.collect(categoryPojo);}}/*** 用于存储聚合的结果*/@Data@AllArgsConstructor@NoArgsConstructorpublic static class CategoryPojo {private String category;//分类名称private double totalPrice;//该分类总销售额private String dateTime;// 截止到当前时间的时间,本来应该是EventTime,但是我们这里简化了直接用当前系统时间即可}/*** 自定义数据源实时产生订单数据Tuple2<分类, 金额>*/public static class MySource implements SourceFunction<Tuple2<String, Double>> {private boolean flag = true;private String[] categorys = {"女装", "男装", "图书", "家电", "洗护", "美妆", "运动", "游戏", "户外", "家具", "乐器", "办公"};private Random random = new Random();@Overridepublic void run(SourceContext<Tuple2<String, Double>> ctx) throws Exception {while (flag) {//随机生成分类和金额int index = random.nextInt(categorys.length);//[0~length) ==> [0~length-1]String category = categorys[index];//获取的随机分类double price = random.nextDouble() * 100;//注意nextDouble生成的是[0~1)之间的随机数,*100之后表示[0~100)ctx.collect(Tuple2.of(category, price));Thread.sleep(20);}}@Overridepublic void cancel() {flag = false;}}
}
实现效果
2021年大数据Flink（四十）：Flink模拟双十一实时大屏统计相关推荐
- 客快物流大数据项目(四十六)：Spark操作Kudu dataFrame操作kudu
Spark操作Kudu dataFrame操作kudu 一.DataFrameApi读取kudu表中的数据 虽然我们可以通过上面显示的KuduContext执行大量操作,但我们还可以直接从默认数据源本 ...
- 客快物流大数据项目(四十四)：Spark操作Kudu创建表
Spark操作Kudu创建表 Spark与KUDU集成支持: DDL操作(创建/删除) 本地Kudu RDD Native Kudu数据源,用于DataFrame集成 从kudu读取数据 从Kudu执 ...
- 客快物流大数据项目(四十九)：开发环境初始化
目录 开发环境初始化 一.配置开发环境的HADOOP_HOME 二.将hadoop.
- 客快物流大数据项目(四十八)：Spark操作Kudu 修改表
Spark操作Kudu 修改表 代码示例 /*** 添加列* @param kuduContext*/ def addColumn(kuduContext: KuduContext): Unit ={ ...
- hive 如果表不存在则创建_从零开始学习大数据系列(四十七) Hive中数据的加载与导出...
[本文大约1400字,阅读时间5~10分钟] 在<从零开始学习大数据系列(三十八) Hive中的数据库和表>和<从零开始学习大数据系列(四十二)Hive中的分区>文章中,我们已 ...
- 2021年大数据HBase（十四）：HBase的原理及其相关的工作机制
全网最详细的大数据HBase文章系列,强烈建议收藏加关注! 新文章都已经列出历史文章目录,帮助大家回顾前面的知识重点. 目录 系列历史文章 HBase的原理及其相关的工作机制 一.HBase的flus ...
- 2021年大数据Hadoop（十四）：HDFS的高可用机制
全网最详细的Hadoop文章系列,强烈建议收藏加关注! 后面更新文章都会列出历史文章目录,帮助大家回顾知识重点. 目录 本系列历史文章 前言 HDFS的高可用机制 HDFS高可用介绍 组件介绍 Nam ...
- 2021年大数据Kafka（十二）：❤️Kafka配额限速机制❤️
全网最详细的大数据Kafka文章系列,强烈建议收藏加关注! 新文章都已经列出历史文章目录,帮助大家回顾前面的知识重点. 目录 系列历史文章 Kafka配额限速机制 限制producer端的速率 限制c ...
- 2021年大数据Kafka（十）：kafka生产者数据分发策略
全网最详细的大数据Kafka文章系列,强烈建议收藏加关注! 新文章都已经列出历史文章目录,帮助大家回顾前面的知识重点. 目录 系列历史文章 生产者数据分发策略 策略一:用户指定了partition 策 ...
最新文章
- python【蓝桥杯vip练习题库】PREV-52小数第n位（模拟）
- 雅虎开源发布/订阅消息平台Pulsar
- 鸟哥的Linux私房菜(服务器)- 簡易 Cluster 架設
- 【264】◀▶ Windows 批处理（CMD）
- 9.控制流语句_for循环
- 桥接模式源码解析(jdk)
- 二分查找（c语言实现）
- 科技情报研究所工资_我们所说的情报是什么？
- vscode 不能运行h5c3代码_让开发效率“飞起”的VS Code 插件
- poj 1422(二分图)
- 疑似 B 站后台源码泄露，ikun 潜入？
- HDU/HDOJ 1800 Flying to the Mars 搜索
- MybatisPlus常用条件查询器Wrapper的使用
- 安卓系统车牌离线识别，优秀的车牌识别算法
- 基于python3的百度街景地图爬虫
- Unbuntu22.04安装教程以及Unbuntu下C++环境的配置
- 超简单集成HMS Scan Kit扫码SDK,轻松实现扫码购
- 弘辽科技：拼多多推广单元和推广计划是一样的吗？
- 《寂静之声》口琴版，惊艳，有链接
- 古籍、中国通史、诗经、辞、、四书五经、诸子百家、四大名著、唐诗、宋词、明清小说、四库全书