Flink的流关联

已于 2022-08-20 15:50:33 修改
阅读量1.5k 收藏 5
点赞数 1
分类专栏： Flink 文章标签： flink
于 2021-10-18 17:29:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/day_ue/article/details/120774403
版权

1.流关联

1.1 join
DataStream<Integer> orangeStream = ...
DataStream<Integer> greenStream = ...

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    //窗口可以是滚动窗口，也可以是滑动窗口，或者session窗口
    .window(TumblingEventTimeWindows.of(Time.milliseconds(2)))
    .apply(new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });
1.2 coGroup

只有inner join肯定还不够，如何实现left/right outer join呢？答案就是利用coGroup()算子。它的调用方式类似于join()算子，也需要开窗，但是CoGroupFunction比JoinFunction更加灵活，可以按照用户指定的逻辑匹配左流和/或右流的数据并输出。

clickRecordStream
  .coGroup(orderRecordStream)
  .where(record -> record.getMerchandiseId())
  .equalTo(record -> record.getMerchandiseId())
  .window(TumblingProcessingTimeWindows.of(Time.seconds(10)))
  .apply(new CoGroupFunction<AnalyticsAccessLogRecord, OrderDoneLogRecord, Tuple2<String, Long>>() {
    @Override
    public void coGroup(Iterable<AnalyticsAccessLogRecord> accessRecords, Iterable<OrderDoneLogRecord> orderRecords,                         Collector<Tuple2<String, Long>> collector) throws Exception {
      for (AnalyticsAccessLogRecord accessRecord : accessRecords) {
        boolean isMatched = false;
        for (OrderDoneLogRecord orderRecord : orderRecords) {
          // 右流中有对应的记录
          collector.collect(new Tuple2<>(accessRecord.getMerchandiseName(), orderRecord.getPrice()));
          isMatched = true;
        }
        if (!isMatched) {
          // 右流中没有对应的记录
          collector.collect(new Tuple2<>(accessRecord.getMerchandiseName(), null));
        }
      }
    }
  })
  .print().setParallelism(1);
1.3 interval join

右流相对左流偏移的时间区间进行关联，即：right.timestamp ∈ [left.timestamp + lowerBound; left.timestamp + upperBound]

注意：目前 interval join 只支持 Event 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(first + "," + second);
        }
    });
1.4 connect

自身没有join关联的概念，仅仅是两个流合并在一起。要实现join的操作需要自己代码实现。

// 流1 要先按照id分组，再设置水印和事件时间，因为后面注册的定时器是基于事件时间的
DataStreamSource<Order> sourceStream1 = env.addSource(consumer);
KeyedStream<Order, String> stream1 = sourceStream1.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.seconds(5)) {
            @Override
            public long extractTimestamp(Order element) {
				// 这里从element中获取事件时间
                return Order.getTime;
            }
        }).keyBy(Order::getOrderId);
// 流2 要先按照id分组，再设置水印和事件时间，因为后面注册的定时器是基于事件时间的
DataStreamSource<Order> sourceStream2 = env.addSource(consumer);
KeyedStream<Order, String> stream2 = sourceStream1.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Order>(Time.seconds(5)) {
            @Override
            public long extractTimestamp(Order element) {
				// 这里从element中获取事件时间
                return Order.getTime;
            }
        }).keyBy(Order::getOrderId);
// 定义两个侧切流的outputTag
OutputTag<Order> outputTag1 = new OutputTag<>("stream1");
OutputTag<Order> outputTag2 = new OutputTag<>("stream2");


stream1.connect(stream2).process(new CoProcessFunction<Order, Order, Tuple2<Order, Order>>() {

	// 流1的状态
	ValueState<Order> state1;
	// 流2的状态
	ValueState<Order> state2;
	
	// 定义一个用于删除定时器的状态
	ValueState<Long> timeState;
	
	@Override
	public void open(Configuration parameters) throws Exception {
		super.open(parameters);
		// 初始化状态
		state1 = getRuntimeContext().getState(new ValueStateDescriptor<>("state1", Order.class));
		state2 = getRuntimeContext().getState(new ValueStateDescriptor<>("state2", Order.class));
		timeState = getRuntimeContext().getState(new ValueStateDescriptor<>("timeState", Long.class));
	}
	
	// 流1的处理逻辑
	@Override
	public void processElement1(Order value, Context ctx, Collector<Tuple2<Order, Order>> out) throws Exception {
		Order  value2 = state2.value();
		// 流2不为空表示流2先来了，直接将两个流拼接发到下游
		if (value2 != null) {
			out.collect(Tuple2.of(value, value2));
			// 清空流2对用的state信息
			state2.clear();
			// 流2来了就可以删除定时器了，并把定时器的状态清除
			ctx.timerService().deleteEventTimeTimer(timeState.value());
			timeState.clear();
		} else {
			// 流2还没来，将流1放入state1中，
			state1.update(value);
			// 并注册一个1分钟的定时器，流1中的 eventTime + 60s
			long time = value.getTime() + 60000;
			timeState.update(time);
			ctx.timerService().registerEventTimeTimer(time);
		}
	}
	
	// 流2的处理逻辑与流1的处理逻辑类似
	@Override
	public void processElement2(Order value, Context ctx, Collector<Tuple2<Order, Order>> out) throws Exception {
		Order value1 = state1.value();
		if (value1 != null) {
			out.collect(Tuple2.of(value1, value));
			state1.clear();
			ctx.timerService().deleteEventTimeTimer(timeState.value());
			timeState.clear();
		} else {
			state2.update(value);
			long time = value.getTime()+ 60000;
			timeState.update(time);
			ctx.timerService().registerEventTimeTimer(time);
		}
	}
	
	@Override
	public void onTimer(long timestamp, OnTimerContext ctx, Collector<Tuple2<Order, Order>> out) throws Exception {
		super.onTimer(timestamp, ctx, out);
		// 定时器触发了，即1分钟内没有收到两个流
		// 流1不为空，则将流1侧切输出
		if (state1.value() != null) {
		ctx.output(outputTag1, state1.value());
		}
	
		// 流2不为空，则将流2侧切输出
		if (state2.value() != null) {
		ctx.output(outputTag2, state2.value());
		}
	
		state1.clear();
		state2.clear();
	}
});
1.5 union

虽然可以合并多个数据流，但有一个限制，即多个数据流的数据类型必须相同。输出的就是普通的DataStream。

val stream1: DataStream[StockPrice] = ...
val stream2: DataStream[StockPrice] = ...
val stream3: DataStream[StockPrice] = ...
val unionStockStream: DataStream[StockPrice] = stream1.union(stream2, stream3)

2.维表关联

2.1 预加载维表

通过定义一个类实现RichMapFunction，在open()中读取维表数据加载到内存中，在probe流map()方法中与维表数据进行关联。RichMapFunction中open方法里加载维表数据到内存的方式特点如下：

  • 优点：实现简单
  • 缺点：因为数据存于内存，所以只适合小数据量并且维表数据更新频率不高的情况下。虽然可以在open中定义一个定时器定时更新维表，但是还是存在维表更新不及时的情况。
class MapJoinDemo1 extends RichMapFunction<Tuple2<String, Integer>, Tuple3<String, Integer, String>> {
        //定义一个变量，用于保存维表数据在内存
        Map<Integer, String> dim;

        @Override
        public void open(Configuration parameters) throws Exception {
            //在open方法中读取维表数据，可以从数据中读取、文件中读取、接口中读取等等。
            dim = new HashMap<>();
            dim.put(1001, "beijing");
            dim.put(1002, "shanghai");
            dim.put(1003, "wuhan");
            dim.put(1004, "changsha");
        }

        @Override
        public Tuple3<String, Integer, String> map(Tuple2<String, Integer> value) throws Exception {
            //在map方法中进行主流和维表的关联
            String cityName = "";
            if (dim.containsKey(value.f1)) {
                cityName = dim.get(value.f1);
            }
            return new Tuple3<>(value.f0, value.f1, cityName);
        }
    }
}
2.2 热存储维表

这种方式是将维表数据存储在Redis、HBase、MySQL等外部存储中，实时流在关联维表数据的时候实时去外部存储中查询，这种方式特点如下：

  • 优点：维度数据量不受内存限制，可以存储很大的数据量。
  • 缺点：因为维表数据在外部存储中，读取速度受制于外部存储的读取速度；另外维表的同步也有延迟。
2.2.1 cache减轻访问压力

可以使用缓存来存储一部分常访问的维表数据，以减少访问外部系统的次数，比如使用guava Cache。

class MapJoinDemo1 extends RichMapFunction<Tuple2<String, Integer>, Tuple3<String, Integer, String>> {
        LoadingCache<Integer, String> dim;

        @Override
        public void open(Configuration parameters) throws Exception {
            //使用google LoadingCache来进行缓存
            dim = CacheBuilder.newBuilder()
                    //最多缓存个数，超过了就根据最近最少使用算法来移除缓存
                    .maximumSize(1000)
                    //在更新后的指定时间后就回收
                    .expireAfterWrite(10, TimeUnit.MINUTES)
                    //指定移除通知
                    .removalListener(new RemovalListener<Integer, String>() {
                        @Override
                        public void onRemoval(RemovalNotification<Integer, String> removalNotification) {
                            System.out.println(removalNotification.getKey() + "被移除了，值为：" + removalNotification.getValue());
                        }
                    })
                    .build(
                            //指定加载缓存的逻辑
                            new CacheLoader<Integer, String>() {
                                @Override
                                public String load(Integer cityId) throws Exception {
                                    String cityName = readFromHbase(cityId);
                                    return cityName;
                                }
                            }
                    );
        }

        private String readFromHbase(Integer cityId) {
            //读取hbase，模拟从hbase读取数据
            Map<Integer, String> temp = new HashMap<>();
            temp.put(1001, "beijing");
            temp.put(1002, "shanghai");
            temp.put(1003, "wuhan");
            temp.put(1004, "changsha");
            String cityName = "";
            if (temp.containsKey(cityId)) {
                cityName = temp.get(cityId);
            }
            return cityName;
        }

        @Override
        public Tuple3<String, Integer, String> map(Tuple2<String, Integer> value) throws Exception {
            //在map方法中进行主流和维表的关联
            String cityName = "";
            if (dim.get(value.f1) != null) {
                cityName = dim.get(value.f1);
            }
            return new Tuple3<>(value.f0, value.f1, cityName);
        }
    }
}
2.2.2 异步IO提高吞吐量

Flink与外部存储系统进行读写操作的时候可以使用同步方式，也就是发送一个请求后等待外部系统响应，然后再发送第二个读写请求，这样的方式吞吐量比较低，可以用提高并行度的方式来提高吞吐量，但是并行度多了也就导致了进程数量多了，占用了大量的资源。

Flink中可以使用异步IO来读写外部系统，这要求外部系统客户端支持异步IO，不过目前很多系统都支持异步IO客户端。但是如果使用异步就要涉及到三个问题：

  • 超时：如果查询超时那么就认为是读写失败，需要按失败处理；
  • 并发数量：如果并发数量太多，就要触发Flink的反压机制来抑制上游的写入。
  • 返回顺序错乱：顺序错乱了要根据实际情况来处理，Flink支持两种方式：允许乱序、保证顺序。
public class JoinDemo3 {
    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStream<Tuple2<String, Integer>> textStream = env.socketTextStream("localhost", 9000, "\n")
                .map(p -> {
                    //输入格式为：user,1000,分别是用户名称和城市编号
                    String[] list = p.split(",");
                    return new Tuple2<String, Integer>(list[0], Integer.valueOf(list[1]));
                })
                .returns(new TypeHint<Tuple2<String, Integer>>() {
                });


        DataStream<Tuple3<String,Integer, String>> orderedResult = AsyncDataStream
                //保证顺序：异步返回的结果保证顺序，超时时间1秒，最大容量2，超出容量触发反压
                .orderedWait(textStream, new JoinDemo3AyncFunction(), 1000L, TimeUnit.MILLISECONDS, 2)
                .setParallelism(1);

        DataStream<Tuple3<String,Integer, String>> unorderedResult = AsyncDataStream
                //允许乱序：异步返回的结果允许乱序，超时时间1秒，最大容量2，超出容量触发反压
                .unorderedWait(textStream, new JoinDemo3AyncFunction(), 1000L, TimeUnit.MILLISECONDS, 2)
                .setParallelism(1);

        orderedResult.print();
        unorderedResult.print();
        env.execute("joinDemo");
    }

    //定义个类，继承RichAsyncFunction，实现异步查询存储在mysql里的维表
    //输入用户名、城市ID，返回 Tuple3<用户名、城市ID，城市名称>
    static class JoinDemo3AyncFunction extends RichAsyncFunction<Tuple2<String, Integer>, Tuple3<String, Integer, String>> {
        // 链接
        private static String jdbcUrl = "jdbc:mysql://192.168.145.1:3306?useSSL=false";
        private static String username = "root";
        private static String password = "123";
        private static String driverName = "com.mysql.jdbc.Driver";
        java.sql.Connection conn;
        PreparedStatement ps;

        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);

            Class.forName(driverName);
            conn = DriverManager.getConnection(jdbcUrl, username, password);
            ps = conn.prepareStatement("select city_name from tmp.city_info where id = ?");
        }

        @Override
        public void close() throws Exception {
            super.close();
            conn.close();
        }

        //异步查询方法
        @Override
        public void asyncInvoke(Tuple2<String, Integer> input, ResultFuture<Tuple3<String,Integer, String>> resultFuture) throws Exception {
            // 使用 city id 查询
            ps.setInt(1, input.f1);
            ResultSet rs = ps.executeQuery();
            String cityName = null;
            if (rs.next()) {
                cityName = rs.getString(1);
            }
            List list = new ArrayList<Tuple2<Integer, String>>();
            list.add(new Tuple3<>(input.f0,input.f1, cityName));
            resultFuture.complete(list);
        }

        //超时处理
        @Override
        public void timeout(Tuple2<String, Integer> input, ResultFuture<Tuple3<String,Integer, String>> resultFuture) throws Exception {
            List list = new ArrayList<Tuple2<Integer, String>>();
            list.add(new Tuple3<>(input.f0,input.f1, ""));
            resultFuture.complete(list);
        }
    }
}
2.3 广播流关联实时更新

利用Flink的Broadcast State将维度数据流广播到下游做join操作。特点如下：

  • 优点：维度数据变更后可以即时更新到结果中。
  • 缺点：数据保存在内存中，支持的维度数据量比较小。
//定义城市流
        DataStream<Tuple2<Integer, String>> cityStream = env.socketTextStream("localhost", 9001, "\n")
                .map(p -> {
                    //输入格式为：城市ID,城市名称
                    String[] list = p.split(",");
                    return new Tuple2<Integer, String>(Integer.valueOf(list[0]), list[1]);
                })
                .returns(new TypeHint<Tuple2<Integer, String>>() {
                });

        //将城市流定义为广播流
        final MapStateDescriptor<Integer, String> broadcastDesc = new MapStateDescriptor("broad1", Integer.class, String.class);
        BroadcastStream<Tuple2<Integer, String>> broadcastStream = cityStream.broadcast(broadcastDesc);

        DataStream result = textStream.connect(broadcastStream)
                .process(new BroadcastProcessFunction<Tuple2<String, Integer>, Tuple2<Integer, String>, Tuple3<String, Integer, String>>() {
                    //处理非广播流，关联维度
                    @Override
                    public void processElement(Tuple2<String, Integer> value, ReadOnlyContext ctx, Collector<Tuple3<String, Integer, String>> out) throws Exception {
                        ReadOnlyBroadcastState<Integer, String> state = ctx.getBroadcastState(broadcastDesc);
                        String cityName = "";
                        if (state.contains(value.f1)) {
                            cityName = state.get(value.f1);
                        }
                        out.collect(new Tuple3<>(value.f0, value.f1, cityName));
                    }

                    @Override
                    public void processBroadcastElement(Tuple2<Integer, String> value, Context ctx, Collector<Tuple3<String, Integer, String>> out) throws Exception {
                        System.out.println("收到广播数据：" + value);
                        ctx.getBroadcastState(broadcastDesc).put(value.f0, value.f1);
                    }
                });
2.4 temporalTable

Temporal table是持续变化表上某一时刻的视图，Temporal table function是一个表函数，传递一个时间参数，返回Temporal table这一指定时刻的视图。

可以将维度数据流映射为Temporal table，主流与这个Temporal table进行关联，可以关联到某一个版本（历史上某一个时刻）的维度数据。

Temporal table function join的特点如下：

  • 优点：维度数据量可以很大，维度数据更新及时，不依赖外部存储，可以关联不同版本的维度数据。
  • 缺点：只支持在Flink SQL API中使用。
public class JoinDemo5 {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        EnvironmentSettings bsSettings = EnvironmentSettings.newInstance().useBlinkPlanner().inStreamingMode().build();
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env, bsSettings);

        //定义主流
        DataStream<Tuple2<String, Integer>> textStream = env.socketTextStream("localhost", 9000, "\n")
                .map(p -> {
                    //输入格式为：user,1000,分别是用户名称和城市编号
                    String[] list = p.split(",");
                    return new Tuple2<String, Integer>(list[0], Integer.valueOf(list[1]));
                })
                .returns(new TypeHint<Tuple2<String, Integer>>() {
                });

        //定义城市流
        DataStream<Tuple2<Integer, String>> cityStream = env.socketTextStream("localhost", 9001, "\n")
                .map(p -> {
                    //输入格式为：城市ID,城市名称
                    String[] list = p.split(",");
                    return new Tuple2<Integer, String>(Integer.valueOf(list[0]), list[1]);
                })
                .returns(new TypeHint<Tuple2<Integer, String>>() {
                });

        //转变为Table
        Table userTable = tableEnv.fromDataStream(textStream, "user_name,city_id,ps.proctime");
        Table cityTable = tableEnv.fromDataStream(cityStream, "city_id,city_name,ps.proctime");

        //定义一个TemporalTableFunction
        TemporalTableFunction dimCity = cityTable.createTemporalTableFunction("ps", "city_id");
        //注册表函数
        tableEnv.registerFunction("dimCity", dimCity);

        //关联查询
        Table result = tableEnv
                .sqlQuery("select u.user_name,u.city_id,d.city_name from " + userTable + " as u " +
                        ", Lateral table (dimCity(u.ps)) d " +
                        "where u.city_id=d.city_id");
        
        //打印输出
        DataStream resultDs = tableEnv.toAppendStream(result, Row.class);
        resultDs.print();
        env.execute("joinDemo");
    }
}
2.5 四种维表关联对比

img
参考文档

day_ue
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实战：flink实时数仓双流join
huzechen的博客
03-07 2526
业务场景我的实时订单流想要关联另一个流的维度数据，我们该如何设计。•A流：订单流，从binlog中获取下单数据，缺点是，表内维度数据缺少经纬度信息（举例）。•B流：用户流量信息，保存用户...
Flink流处理之迭代案例
01-27
但是对于流处理（DataStream），Flink同样提供了对迭代的支持，这一节我们主要来分析流处理中的迭代，我们将会看到流处理中的迭代相较于批处理有相似之处，但差异也是十分之明显。 可迭代的流处理程序允许定义“步...
基于开源的flink对其实时sql进行扩展；主要实现了流与维表的join
08-08
基于开源的flink，对其实时sql进行扩展；主要实现了流与维表的join
Flink通过异步流关联Mysql
Appreciate(欣赏)
02-17 1455
对于异步 I/O 操作的需求 在与外部系统交互（用数据库中的数据扩充流数据）的时候，需要考虑与外部系统的通信延迟对整个流处理应用的影响。 简单地访问外部数据库的数据，比如使用 MapFunction，通常意味着同步交互： MapFunction 向数据库发送一个请求然后一直等待，直到收到响应。在许多情况下，等待占据了函数运行的大部分时间。 与数据库异步交互是指一个并行函数实例可以并发地处理多个请求和接收多个响应。这样，函数在等待的时间可以发送其他请求和接收其他响应。至少等待的时间可以被多个请求摊分。大多数情
FlinkSQL流式关联Hbase大表方案(走二级索引)
qq_32068809的博客
02-10 3210
我们在做实时数据开发的时候，通常要用spark、flink去消费kafka的数据，拿到数据流后会和外部数据库(Hbase、MySQL等)进行维表关联来把数据流打宽。当然了，有些外部数据库不只是存储维度数据，也会有很多事实数据，并且这些数据更新频繁，数据量巨大，但是我们的Flink流也会去实时的join这些巨大的事实表，这就需要选择一个合适的外部数据库作为支持，这个外部数据库一定要满足海量数据高效的读写性能，这样才能满足实时场景的需求，说到这，我们的目光自然而然的落到了Hbase上，来吧，我们直接上图，下..
Flink 连接流详解
qq_34125999的博客
02-14 873
最简单的合流操作，就是直接将多条流合在一起，叫作流的“联合”（union）。联合操作要求必须流中的数据类型必须相同，合并之后的新流会包括所有流中的元素，数据类型不变。这种合流方式非常简单粗暴，就像公路上多个车道汇在一起一样。在代码中，我们只要基于 DataStream 直接调用.union()方法，传入其他 DataStream 作为参数，就可以实现流的联合了；union()的参数可以是多个 DataStream，所以联合操作可以实现多条流的合并。这里需要考虑一个问题。
Flink维表Join实践
鸣宇淳的专栏
06-01 4583
这个文章是根据 【实时数仓篇】基于 Flink 的典型 ETL 场景实现 写的，对视频中讲解的四种维表Join分别实现了一些Demo。 常见的维表Join方式有四种： 预加载维表 热存储维表 广播维表 Temporal table function join 下面分别使用这四种方式来实现一个join的需求，这个需求是：一个主流中数据是用户信息，字段包括用户姓名、城市id；维表是城市数据，字段包括城市ID、城市名称。要求用户表与城市表关联，输出为：用户名称、城市ID、城市名称。 1、 预加载维表 通过定义
Flink多流关联(超过两个实时流)
u013939918的博客
04-11 7894
Flink怎么实现多个实时流的关联。官方文档，很多教程 给的Demo都是两个实时流的关联。 1. 分析业务数据源，很多需要多个流的join的场景 是伪命题，用union即可。 2. union + group by ，在基于key的流中可以取代join。优势： 在join 发生数据倾斜或者反压，很难 checkpoint时，用union可以回避这个问题。 3. 例如三个流join，可以...
Flink维表Join
GavinKai
11-05 3747
衡量指标 总体来讲，关联维表有三个基础的方式：实时数据库查找关联（Per-Record Reference Data Lookup）、预加载维表关联（Pre-Loading of Reference Data）和维表变更日志关联（Reference Data Change Stream），而根据实现上的优化可以衍生出多种关联方式，且这些优化还可以灵活组合产生不同效果（不过为了简单性这里不讨论同时应用多种优化的实现方式）。对于不同的关联方式，我们可以从以下 7 个关键指标来衡量（每个指标的得分将以 1-..
Flink笔记-双流join
ooeeerrtt的博客
05-06 481
一、intervalJoin 流A intervalJoin 流B，只要满足以下条件即为join成功。 流B的时间戳大于等于流A的时间戳减下界 且流B的时间戳小于等于流A的时间戳加上界 且流A的key等于流B的key。 ProcessJoinFunction public class TwoStreamJoinStream { public static vo...
大数据培训Flink 常见的维表 Join 方案
weixin_45695430的博客
04-18 1875
以下文章来源于大数据左右手 ，作者左右 前言 实时数仓，难免会遇到join维表的业务。现总结几种方案，供各位看官选择： 查找关联（同步，异步） 状态编程,预加载数据到状态中，按需取 冷热数据 广播维表 Temporal Table Join Lookup Table Join 查找关联 查找关联就是在主流数据中直接访问外部数据（mysql，redis，impala ...）去根据主键或者某种关键条件去关联取值。 适合: 维表数据量大，但是主数据不大的业务实时计算。 缺点：数据量大的时候
flink流批一体存储
05-26
flink流批一体存储
flink流处理初始demo
03-27
flink流处理初始demo，可以在此基础上编写自己的flink程序。内包含flink流处理程序基本框架和批处理程序基本框架。
Flink的流处理
01-07
Flink是一个用于对无界和有界数据流进行有状态计算的框架。Flink在不同的抽象级别提供多个API，并为常见用例提供专用库。 流媒体应用程序的构建块 可以由流处理框架构建和执行的应用程序类型由框架控制流，状态和...
flink流处理API
01-07
Environment getExecutionEnvironment 创建一个执行环境，表示当前执行程序的上下文。 如果程序是独立调用的，则此方法返回本地执行环境；...如果没有设置并行度，会以flink-conf.yaml中的配置为准，默认
Flink多流处理之join(关联)
AnameJL的博客
08-10 857
join的使用
Flink-join(流表关联流表，流表关联维表),自定义函数，sql如何保证数据唯一性,执行一组sql的好处...
weixin_48370579的博客
08-03 1817
10、Flink join 1、Regular Joins 将两个关联表长存再状态中，可以一直关联上 会导致状态越来越大 和批处理关联结果是一样的 -- 创建学生表流表，数据再kafka中 drop table student_join; CREATE TABLE student_join ( id String, name String, age int, gender STRI...
Flink教程(12) 两条流关联 window窗口的 join leftJoin使用案例
Java Spring Elasticsearch
03-19 1676
两条流关联 window窗口的 join leftJoin使用案例一、温度数据和实体类1. 温度数据2. 实体类3. 将字符串映射成SensorRecord对象二、window join1. 获取2条数据流2. join的代码3. KeySelector4. 设置join后的结果对象三、window left join1. left join主体代码2. MyCoGroupFunction 一、温度数据和实体类 1. 温度数据 第一个是id，第二个四温度，第三个是事件事件 1,20.5,2021-01-29
Flink--9、双流联结（窗口联结、间隔联结）
最新发布
星光不问赶路人，岁月不负有心人
10-06 742
双流联结（窗口联结、间隔联结）
写个flink 流关联sink到clickhouse的代码
04-20
这是一个简单的 Flink 流程序，将从 Kafka 中读取数据，经过 Flink 的转换后将数据写入 Kafka 和 ClickHouse 中。请注意，这个程序只是示例代码，如果您在实际环境中使用，请根据实际情况进行修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值