2024年最全零基础学Flink：Flink SQL（上），花三分钟看完这篇文章你就懂了

2401_84585339

于 2024-05-08 07:18:24 发布

阅读量907

点赞数 24

分类专栏：程序员文章标签： flink sql 大数据

本文链接：https://blog.csdn.net/2401_84585339/article/details/138555534

版权

程序员专栏收录该内容

118 篇文章 0 订阅

订阅专栏

最后

毕竟工作也这么久了，除了途虎一轮，也七七八八面试了不少大厂，像阿里、饿了么、美团、滴滴这些面试过程就不一一写在这篇文章上了。我会整理一份详细的面试过程及大家想知道的一些问题细节

美团面试经验

美团面试
字节面试经验

菜鸟面试经验

蚂蚁金服面试经验

唯品会面试经验

因篇幅有限，图文无法详细发出

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

当进行聚合的时候，数据持续输入，都会对聚合结果有影响，例如下图，对用户点击进行统计的时候，随着时间增长，用户点击的发生，其点击数据是会持续增加的，这就造成了持续查询的数据在不停的更新。

640?wx_fmt=png

下图是有时间窗口的聚合，在时间窗口内，聚合可以当成一个小的关系型聚合计算来理解。

640?wx_fmt=png

动态表输出流

动态表输出力流有三种模式Append-only stream，Retract stream，Upsert stream

Append-only stream 只有在动态Table仅通过INSERT更改修改时才能使用此模式，即它仅附加，并且以前发出的结果永远不会更新。

Retract stream 此模式。返回值是boolean类型。它用true或false来标记数据的插入和撤回，返回true代表数据插入，false代表数据的撤回

640?wx_fmt=png

Upsert stream 和 Retract stream最大的区别在于，更新数据的时候只使用一条编码消息，所以效率更高。

640?wx_fmt=png

代码案例

我们还是以几篇文章使用的订单流进行。我设计了两个查询，

一个是按时间窗口和商品类型对销售额进行聚合
另外一个是只按商品类型对销售额进行聚合。

前面部分消费kafka的部分没有什么变化，只是在获取初始数据流的时候，将首字段设置成了Timestamp类型。并在获取流的时候，加入watermarker。

然后就是前文提到的

tableEnv.registerDataStream(“orders”, oraderStream, "rowtime.rowtime, c1,c2, dm ,v ");

将流注册成动态表，并设置元数据，注意

rowtime.rowtime

这个写法，前文有详细说明。

在有时间聚合的动态表转换的时候，我使用了

toAppendStream

没有时间聚合的情况，使用了

toRetractStream

下面是完整代码：

import org.apache.flink.api.common.serialization.DeserializationSchema;

import org.apache.flink.api.common.typeinfo.TypeHint;

import org.apache.flink.api.common.typeinfo.TypeInformation;

import org.apache.flink.api.java.tuple.Tuple5;

import org.apache.flink.api.java.utils.ParameterTool;

import org.apache.flink.streaming.api.TimeCharacteristic;

import org.apache.flink.streaming.api.datastream.DataStream;

import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import org.apache.flink.streaming.api.functions.timestamps.AscendingTimestampExtractor;

import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer010;

import org.apache.flink.table.api.Table;

import org.apache.flink.table.api.java.StreamTableEnvironment;

import org.apache.flink.types.Row;

import java.io.IOException;

import java.sql.Time;

import java.sql.Timestamp;

import java.util.HashMap;

import java.util.Map;

public class App {

public static void main(String[] args) throws Exception {

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

Map properties= new HashMap();

properties.put(“bootstrap.servers”, “localhost:9092”);

properties.put(“group.id”, “test”);

properties.put(“enable.auto.commit”, “true”);

properties.put(“auto.commit.interval.ms”, “1000”);

properties.put(“auto.offset.reset”, “earliest”);

properties.put(“session.timeout.ms”, “30000”);

// properties.put(“key.deserializer”, “org.apache.kafka.common.serialization.StringDeserializer”);

// properties.put(“value.deserializer”, “org.apache.kafka.common.serialization.StringDeserializer”);

properties.put(“topicOrder”, “order”);

ParameterTool parameterTool = ParameterTool.fromMap(properties);

FlinkKafkaConsumer010 consumer010Order = new FlinkKafkaConsumer010(

parameterTool.getRequired(“topicOrder”), new DeserializationSchema() {

@Override

public TypeInformation getProducedType() {

return TypeInformation.of(new TypeHint<Tuple5<Timestamp,String,Integer,String,Integer>>(){});

}

@Override

public Tuple5<Timestamp,String,Integer,String,Integer> deserialize(byte[] message) throws IOException {

//%d,%s,%d,%s,%d

String[] res = new String(message).split(“,”);

Timestamp timestamp = new Timestamp(Long.valueOf(res[0]));

String catlog = res[1];

Integer subcat = Integer.valueOf(res[2]);

String dm = res[3];

Integer value = Integer.valueOf(res[4]);

Time eventTime = new Time(System.currentTimeMillis());

return Tuple5.of(timestamp,catlog,subcat,dm,value);

}

@Override

public boolean isEndOfStream(Object nextElement) {

return false;

}

}, parameterTool.getProperties());

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

env.setParallelism(1);

DataStream<Tuple5<Timestamp,String,Integer,String,Integer>> oraderStream = env.addSource(consumer010Order).assignTimestampsAndWatermarks(new AscendingTimestampExtractor<Tuple5<Timestamp,String,Integer,String,Integer>>() {

@Override

public long extractAscendingTimestamp(Tuple5<Timestamp,String,Integer,String,Integer> value) {

return value.f0.getTime();

}

});;

tableEnv.registerDataStream(“orders”, oraderStream, "rowtime.rowtime, c1,c2, dm ,v ");

String sql = “select sum(orders.v),CONCAT(orders.c1,CAST(orders.c2 AS VARCHAR)),TUMBLE_END(rowtime, INTERVAL ‘10’ SECOND) from orders group by CONCAT(orders.c1,CAST(orders.c2 AS VARCHAR)),TUMBLE(rowtime, INTERVAL ‘10’ SECOND)”;

//sql = “select sum(orders.v),CONCAT(orders.c1,CAST(orders.c2 AS VARCHAR)) from orders group by CONCAT(orders.c1,CAST(orders.c2 AS VARCHAR))”;

Table result1 = tableEnv.sqlQuery(sql);

result1.printSchema();

tableEnv.toAppendStream(result1, Row.class).print();

// tableEnv.toRetractStream(result1, Row.class).print();

env.execute("sql ");

}

结果