Flink处理数据库中的业务数据——将主表、从表做关联（Left Out Join）

最新推荐文章于 2024-07-08 22:47:23 发布
最新推荐文章于 2024-07-08 22:47:23 发布
阅读量4.2k 收藏 25
点赞数 4
分类专栏： Flink实时篇 文章标签： mysql kafka flink 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010271601/article/details/104897585
版权

文章目录

一、需求

1、需求说明

  • 在各种各样的系统中，都有订单数据表

  • 订单表：订单主表、订单明细表

       订单主表：
  		订单id、订单状态、订单总金额、订单的时间、用户ID

  订单明细表：
  		订单主表的ID、商品ID、商品的分类ID、商品的单价、商品的数量

统计某个商品分类的成交金额

  • 订单状态为成交的（主表中）
  • 商品的分类ID（明细表中）
  • 商品的金额即单价*数量（明细表中）
2、数据准备
  • 订单主表 OrderMain:
    在这里插入图片描述
  • OrderMain导入到Kafka中的数据：
{"data":[{"oid":"29001","create_time":"2020-03-16 00:38:01","total_money":"2000.0","status":"1",
"update_time":"2020-03-16 00:38:01","uid":"9999","province":"北京市"}],"database":"doit12",
"es":1584333481000,"id":4,"isDdl":false,"mysqlType":{"oid":"bigint(20)","create_time":"timestamp",
"total_money":"double","status":"int(11)","update_time":"timestamp","uid":"varchar(20)",
"province":"varchar(50)"},"old":null,"pkNames":["oid"],"sql":"","sqlType":{"oid":-5,"create_time":93,
"total_money":8,"status":4,"update_time":93,"uid":12,"province":12},"table":"ordermain",
"ts":1584333481540,"type":"INSERT"}
  • 订单明细表 OrderDetail：
    在这里插入图片描述
  • OrderDetail导入到Kafka的数据：
{"data":[{"id":"10","order_id":"29001","category_id":"2","sku":"20001","money":"1000.0","amount":"1",
"create_time":"2020-03-16 00:38:01","update_time":"2020-03-16 00:38:01"}],"database":"doit12",
"es":1584333481000,"id":4,"isDdl":false,"mysqlType":{"id":"bigint(20)","order_id":"bigint(20)",
"category_id":"int(11)","sku":"varchar(50)","money":"double","amount":"int(11)",
"create_time":"timestamp","update_time":"timestamp"},"old":null,"pkNames":["id"],"sql":"","sqlType":{"id
":-5,"order_id":-5,"category_id":4,"sku":12,"money":8,"amount":4,"create_time":93,"update_time":93}
,"table":"orderdetail","ts":1584333481600,"type":"INSERT"}

二、分析

  • 要想统计，需要将两个表中的数据拉取到Flink做Join关联。
  • 即要在同一个窗口中关联，就要划分窗口。
  • 划分窗口后，数据就有可能迟到，要处理迟到的数据。
  • 业务系统中数据，基本都是存储在关系型数据库中，如Mysql
  • 通过canal这个工具，可以把mysql中的业务数据，导入到kafka中（canal伪装成Mysql的Salve）
  • Flink通过 KafkaSource 从kafka中拉取业务数据
  • 拉取到的数据，要做处理，并将主表、从表关联起来（join）
  • 按EventTime划分窗口，处理迟到的数据
  • 然后再做统计成交金额

三、技术点

  • canal的使用及原理
  • kafka的生产者、消费者、Topic
  • Flink的EventTime滚动窗口 ☆☆☆
  • Flink的双流的LeftJoin ☆☆☆☆
  • Flink的测流输出迟到数据 ☆☆☆☆☆
  • Mysql的连接及查询 ☆☆

四、Join架构

没有join上的分两种情况：

  • （1）左表数据迟到
    -> 使用测流输出，单独捞出来，然后查订单主表（右表）的数据库，关联上主表（右表）数据
  • （2）右边数据迟到
    -> 根据左表的查询条件，查询右表的信息，查数据库或api接口
  • 然后，把这两种数据union在一起写出
    在这里插入图片描述

五、工具类、标准类

1、FlinkUtilsV2 获取KafkaSource的工具类
import org.apache.flink.api.common.restartstrategy.RestartStrategies;
import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.time.Time;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.runtime.state.filesystem.FsStateBackend;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.CheckpointConfig;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;


public class FlinkUtilsV2 {
    private static StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

    // 方法重载一：传入配置文件和数据类型
    public static <T> DataStream<T> createKafkaDataStream(ParameterTool parameters,
                                                          Class<? extends DeserializationSchema<T>> clazz) throws Exception {
        String topics = parameters.getRequired("kafka.topics");
        String groupId = parameters.getRequired("group.id");
        return createKafkaDataStream(parameters, topics, groupId, clazz);
    }


    // 方法重载二：传入配置文件和数据类型
    public static <T> DataStream<T> createKafkaDataStream(ParameterTool parameters, String topics,
                                                          Class<? extends DeserializationSchema<T>> clazz) throws Exception {
        String groupId = parameters.getRequired("group.id");
        return createKafkaDataStream(parameters, topics, groupId, clazz);
    }


    // 方法重载一：传入配置文件和数据类型
    public static <T> DataStream<T> createKafkaDataStream(ParameterTool parameters, String topics, String groupId,
                                                          Class<? extends DeserializationSchema<T>> clazz) throws Exception {

        // 将配置文件设定为全局配置文件
        env.getConfig().setGlobalJobParameters(parameters);


	   //  KafkaSink 需要配置这个
      //parameters.getProperties().setProperty("transaction.timeout.ms", 1000 * 60 * 5 + "");

        //开启checkpoint
        env.enableCheckpointing(parameters.getLong("checkpoint.interval", 10000L),
                CheckpointingMode.EXACTLY_ONCE);

        //设定重启策略
        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(
                parameters.getInt("restart.times", 10), Time.seconds(3)));

        //设置statebackend
        String path = parameters.get("state.backend.path");
        if (path != null) {
            //最好的方式将setStateBackend配置到Flink的全局配置文件中flink-conf.yaml
            env.setStateBackend(new FsStateBackend(path));
        }

        //设置cancel任务不自动删除checkpoint
        env.getCheckpointConfig().enableExternalizedCheckpoints(
                CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
                

        //设定最大的并行度
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(4);

        //当出现多个topic时，放在list集合中
        List<String> topicList = Arrays.asList(topics.split(","));


        Properties properties = parameters.getProperties();

        properties.setProperty("group.id", groupId);

        //创建FlinkKafkaConsumer
        FlinkKafkaConsumer<T> kafkaConsumer = new FlinkKafkaConsumer<T>(
                topicList,
                clazz.newInstance(),
                properties
        );

        //在Checkpoint的时候将Kafka的偏移量保存到Kafka特殊的Topic中，默认是true
        kafkaConsumer.setCommitOffsetsOnCheckpoints(false);

        // 返回kafkaDataStream (lines)
        return env.addSource(kafkaConsumer);
    }

    public static StreamExecutionEnvironment getEnv() {
        return env;
    }
}
2、OrderMainBean 订单主表类
import java.util.Date;

public class OrderMainBean {
    private Long oid;
    private Date create_time;
    private Double total_money;
    private int status;
    private Date update_time;
    private String province;
    private String uid;
    //对数据库的操作类型：INSERT、UPDATE
    private String type;

    public OrderMainBean() {
    }

    public OrderMainBean(Long oid, Date create_time, Double total_money, int status, Date update_time,
                         String province, String uid, String type) {
        this.oid = oid;
        this.create_time = create_time;
        this.total_money = total_money;
        this.status = status;
        this.update_time = update_time;
        this.province = province;
        this.uid = uid;
        this.type = type;
    }

    @Override
    public String toString() {
        return "OrderMainBean{" +
                "oid=" + oid +
                ", create_time=" + create_time +
                ", total_money=" + total_money +
                ", status=" + status +
                ", update_time=" + update_time +
                ", province='" + province + '\'' +
                ", uid='" + uid + '\'' +
                ", type='" + type + '\'' +
                '}';
    }
    public Long getOid() {
        return oid;
    }
    public void setOid(Long oid) {
        this.oid = oid;
    }
    public Date getCreate_time() {
        return create_time;
    }
    public void setCreate_time(Date create_time) {
        this.create_time = create_time;
    }
    public Double getTotal_money() {
        return total_money;
    }
    public void setTotal_money(Double total_money) {
        this.total_money = total_money;
    }
    public int getStatus() {
        return status;
    }
    public void setStatus(int status) {
        this.status = status;
    }
    public Date getUpdate_time() {
        return update_time;
    }
    public void setUpdate_time(Date update_time) {
        this.update_time = update_time;
    }
    public String getProvince() {
        return province;
    }
    public void setProvince(String province) {
        this.province = province;
    }
    public String getUid() {
        return uid;
    }
    public void setUid(String uid) {
        this.uid = uid;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}
3、OrderDetailBean 订单明细表类
import java.util.Date;

public class OrderDetailBean {

    private Long id;
    private Long order_id;
    private int category_id;
    private Long sku;
    private Double money;
    private int amount;
    private Date create_time;
    private Date update_time;

    //对数据库的操作类型：INSERT、UPDATE
    private String type;

    public OrderDetailBean() {
    }

    public OrderDetailBean(Long id, Long order_id, int category_id, Long sku, Double money, int amount,
                           Date create_time, Date update_time, String type) {
        this.id = id;
        this.order_id = order_id;
        this.category_id = category_id;
        this.sku = sku;
        this.money = money;
        this.amount = amount;
        this.create_time = create_time;
        this.update_time = update_time;
        this.type = type;
    }

    @Override
    public String toString() {
        return "OrderDetailBean{" +
                "id=" + id +
                ", order_id=" + order_id +
                ", category_id=" + category_id +
                ", sku=" + sku +
                ", money=" + money +
                ", amount=" + amount +
                ", create_time=" + create_time +
                ", update_time=" + update_time +
                ", type='" + type + '\'' +
                '}';
    }

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public Long getOrder_id() {
        return order_id;
    }
    public void setOrder_id(Long order_id) {
        this.order_id = order_id;
    }
    public int getCategory_id() {
        return category_id;
    }
    public void setCategory_id(int category_id) {
        this.category_id = category_id;
    }
    public Long getSku() {
        return sku;
    }
    public void setSku(Long sku) {
        this.sku = sku;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    public int getAmount() {
        return amount;
    }
    public void setAmount(int amount) {
        this.amount = amount;
    }
    public Date getCreate_time() {
        return create_time;
    }
    public void setCreate_time(Date create_time) {
        this.create_time = create_time;
    }
    public Date getUpdate_time() {
        return update_time;
    }
    public void setUpdate_time(Date update_time) {
        this.update_time = update_time;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}

六、主线代码

  • 配置文件
checkpoint.interval=30000
restart.times=3
state.backend.path=file:///D:\\doit12logs

bootstrap.servers=linux01:9092,linux02:9092,linux03:9092
group.id=g22
auto.offset.reset=earliest
1、从kafka中加载数据源
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.functions.CoGroupFunction;
import org.apache.flink.api.common.functions.RichMapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.functions.windowing.AllWindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
import java.sql.*;

/**
 * @date: 2020/3/16 21:22
 * @site: www.ianlou.cn
 * @author: lekko 六水
 * @qq: 496208110
 * @description:
 */
public class OrderJoinAdv {
    public static void main(String[] args) throws Exception {
        //获取配置文件
        ParameterTool propertiesFile = ParameterTool.fromPropertiesFile(args[0]);

        StreamExecutionEnvironment env = FlinkUtilsV2.getEnv();

        // 使用EventTime作为时间标准
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        // 一、从kafka中加载数据源
        DataStream<String> orderMainLines = FlinkUtilsV2.createKafkaDataStream(propertiesFile, "ordermain",
                "g011", SimpleStringSchema.class);

        DataStream<String> orderDetailLines = FlinkUtilsV2.createKafkaDataStream(propertiesFile, "orderdetail",
                "g011", SimpleStringSchema.class);
2、对从kafka拉取到的json数据，进行解析
        //  二、对从kafka拉取到的json数据，进行解析

        // 加载OrderMain中数据
        SingleOutputStreamOperator<OrderMainBean> orderMainBeanDS = orderMainLines.process(new ProcessFunction<String,
                OrderMainBean>() {
            @Override
            public void processElement(String input, Context ctx, Collector<OrderMainBean> out) throws Exception {

                try {
                    JSONObject jsonObject = JSON.parseObject(input);
                    String type = jsonObject.getString("type");
                    if (type.equals("INSERT") || type.equals("UPDATE")) {

                        //将data[]数组的{}中内容取出来
                        JSONArray jsonArray = jsonObject.getJSONArray("data");
                        for (int i = 0; i < jsonArray.size(); i++) {
                            OrderMainBean orderMain = jsonArray.getObject(i, OrderMainBean.class);
                            orderMain.setType(type); //设置操作类型
                            out.collect(orderMain);
                        }
                    }
                } catch (Exception e) {
                    //e.printStackTrace();
                    //TODO 记录错误数据
                }
            }
        });


        //加载OrderDetail中数据
        SingleOutputStreamOperator<OrderDetailBean> orderDetailBeanDS =
                orderDetailLines.process(new ProcessFunction<String,
                        OrderDetailBean>() {
                    @Override
                    public void processElement(String input, Context ctx, Collector<OrderDetailBean> out) throws Exception {

                        try {
                            JSONObject jsonObject = JSON.parseObject(input);
                            String type = jsonObject.getString("type");
                            if (type.equals("INSERT") || type.equals("UPDATE")) {
                                JSONArray jsonArray = jsonObject.getJSONArray("data");
                                for (int i = 0; i < jsonArray.size(); i++) {
                                    OrderDetailBean orderDetail = jsonArray.getObject(i, OrderDetailBean.class);
                                    orderDetail.setType(type); //设置操作类型
                                    out.collect(orderDetail);
                                }
                            }
                        } catch (Exception e) {
                            //e.printStackTrace();
                            //记录错误的数据
                        }
                    }
                });
3、提取EventTime 生成WaterMark
        int delaySeconds = 2;
        int windowSize = 5;

       SingleOutputStreamOperator<OrderMainBean> orderMainWithWaterMark =
                orderMainBeanDS.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor
                        <OrderMainBean>(Time.seconds(delaySeconds)) {
                    @Override
                    public long extractTimestamp(OrderMainBean element) {
                        return element.getCreate_time().getTime();
                    }
                });

        SingleOutputStreamOperator<OrderDetailBean> orderDetailWithWaterMark
                =
                orderDetailBeanDS.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor
                        <OrderDetailBean>(Time.seconds(delaySeconds)) {
                    @Override
                    public long extractTimestamp(OrderDetailBean element) {
                        return element.getCreate_time().getTime();
                    }
                });
4、Left Out JOIN，并且将订单明细表orderDetail作为左表
      DataStream<Tuple2<OrderDetailBean, OrderMainBean>> joined =
                orderDetailWithWaterMark.coGroup(orderMainWithWaterMark)
                        .where(new KeySelector<OrderDetailBean, Long>() {
                            @Override
                            public Long getKey(OrderDetailBean value) throws Exception {
                                return value.getOrder_id();
                            }
                        })
                        .equalTo(new KeySelector<OrderMainBean, Long>() {
                            @Override
                            public Long getKey(OrderMainBean value) throws Exception {
                                return value.getOid();
                            }
                        })
                        .window(TumblingEventTimeWindows.of(Time.seconds(windowSize)))
                        .apply(new CoGroupFunction<OrderDetailBean, OrderMainBean, Tuple2<OrderDetailBean,
                                OrderMainBean>>() {

                            // 做join之后，输出的结果
                            @Override
                            public void coGroup(Iterable<OrderDetailBean> first, Iterable<OrderMainBean> second,
                                                Collector<Tuple2<OrderDetailBean, OrderMainBean>> out) throws Exception {
                                for (OrderDetailBean orderDetailBean : first) {

                                    boolean isJoined = false;
                                    for (OrderMainBean orderMainBean : second) {
                                        out.collect(Tuple2.of(orderDetailBean, orderMainBean));

                                        isJoined = true;
                                    }

                                    if (!isJoined) {
                                        out.collect(Tuple2.of(orderDetailBean, null));
                                    }
                                }
                            }
                        });
5、处理会发生的特殊情况：没有join上的

没有join上的分两种情况：

  • （1）左表数据迟到
    -> 使用测流输出，单独捞出来，然后查订单主表（右表）的数据库，关联上主表（右表）数据
  • （2）右边数据迟到
    -> 根据左表的查询条件，查询右表的信息，查数据库或api接口
  • 然后，把这两种数据union在一起写出
5.1、处理左表（orderDetailWithWaterMark）迟到的数据
 OutputTag<OrderDetailBean> outputTag = new OutputTag<OrderDetailBean>("leftLate-date") {
        };

        // 划分窗口，和上面join的窗口大小和类型保持一致
        SingleOutputStreamOperator<OrderDetailBean> orderDetailLateData =
                orderDetailWithWaterMark.windowAll(TumblingEventTimeWindows.of(Time.seconds(windowSize)))
                        .sideOutputLateData(outputTag)
                        .apply(new AllWindowFunction<OrderDetailBean, OrderDetailBean, TimeWindow>() {
                            @Override
                            public void apply(TimeWindow window, Iterable<OrderDetailBean> values,
                                              Collector<OrderDetailBean> out) throws Exception {
                                //什么都不用操作，只是为迟到的数据打上标签
                                // 之所以用apply，因为要在窗口内的全量数据做操作
                            }
                        });

        // 拿出左表迟到数据
        DataStream<OrderDetailBean> leftLateDate = orderDetailLateData.getSideOutput(outputTag);


        // 查库，关联右表（OrderMain）数据
        SingleOutputStreamOperator<Tuple2<OrderDetailBean, OrderMainBean>> lateOrderDetailAndOrderMain =
                leftLateDate.map(new RichMapFunction<OrderDetailBean, Tuple2<OrderDetailBean, OrderMainBean>>() {

            private transient Connection conn = null;

            // 创建JDBC连接
            @Override
            public void open(Configuration parameters) throws Exception {
                conn = DriverManager.getConnection(
                        "jdbc:mysql://linux04:3306/doit12?characterEncoding=utf8",
                        "root",
                        "123456"
                );
            }

            //查询数据库
            @Override
            public Tuple2<OrderDetailBean, OrderMainBean> map(OrderDetailBean value) throws Exception {
                Long order_id = value.getOrder_id();
                String type = value.getType();
                OrderMainBean orderMainB = queryOrderMainFromMySQL(order_id, type, conn);

                return Tuple2.of(value, orderMainB);
            }

            // 关闭JDBC连接
            @Override
            public void close() throws Exception {
                conn.close();
            }
        });
5.2、处理右表迟到的数据 -> 即join后右表为null的数据
       SingleOutputStreamOperator<Tuple2<OrderDetailBean, OrderMainBean>> lateOrderMainAndOrderMain =
                joined.map(new RichMapFunction<Tuple2<OrderDetailBean, OrderMainBean>, Tuple2<OrderDetailBean,
                        OrderMainBean>>() {

            private transient Connection conn = null;

            @Override
            public void open(Configuration parameters) throws Exception {
                conn = DriverManager.getConnection(
                        "jdbc:mysql://linux04:3306/doit12?characterEncoding=utf8",
                        "root",
                        "123456"
                );
            }

            //查询数据库  根据左表（orderDetail）的查询条件，查询右表（orderMain）的数据
            @Override
            public Tuple2<OrderDetailBean, OrderMainBean> map(Tuple2<OrderDetailBean, OrderMainBean> value) throws Exception {
                OrderMainBean orderMainB = null;
                if (value.f1 == null) {
                    Long order_id = value.f0.getOrder_id();
                    String type = value.f0.getType();
                  orderMainB = queryOrderMainFromMySQL(order_id, type, conn);
                }
                return Tuple2.of(value.f0, orderMainB);
            }

            @Override
            public void close() throws Exception {
                conn.close();
            }
        });
5.3、将数据union到一起
  DataStream<Tuple2<OrderDetailBean, OrderMainBean>> allOrderStream =
                lateOrderMainAndOrderMain.union(lateOrderDetailAndOrderMain);


        allOrderStream.print();

        FlinkUtilsV2.getEnv().execute("OrderJoinAdv");
    }
6、查询MySql数据库的工具类
   private static OrderMainBean queryOrderMainFromMySQL(Long order_id, String type, Connection conn) throws Exception {

        ResultSet resultSet = null;
        PreparedStatement preparedStatement = null;

        String sql = "select oid, create_time, total_money, status, update_time, province, uid from ordermain" +
                    " where oid = ?";
        preparedStatement = conn.prepareStatement(sql);
        preparedStatement.setLong(1, order_id);
        resultSet = preparedStatement.executeQuery();

        long oid = resultSet.getLong("oid");
        Date create_time = resultSet.getDate("create_time");
        double total_money1 = resultSet.getDouble("total_money");
        int status = resultSet.getInt("status");
        Date update_time = resultSet.getDate("update_time");
        String province = resultSet.getString("province");
        String uid = resultSet.getString("uid");

        OrderMainBean orderMain = new OrderMainBean(oid, create_time, total_money1, status, update_time,
                province, uid, type);

        return orderMain;
    }
}
IT但丁
关注
  • 4
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
Flink如何做维表关联
微信搜：import_bigdata，大数据领域硬核原创作者
01-17 1042
声明：本系列博客为原创，最先发表在拉勾教育，其中一部分为免费阅读部分。被读者各种搬运至各大网站。所有其他的来源均为抄袭。 《2021年最新版大数据面试题全面开启更新》 在实际生产中，我们经常会有这样的需求，需要以原始数据流作为基础，然后关联大量的外部表来补充一些属性。例如：在订单数据中，希望能得到订单收货人所在省的名称，一般来说订单中会记录一个省的ID，那么需要根据ID去查询外部的维度表补充省名称属性。 在Flink流式计算中，一些维度表属性一般存储在MySQL/HBase/...
Flink 双流join之left join详解，附demo工程
qq_38363255的博客
11-18 2233
join+window+eventtime 如果使用eventtime需要注意的事情比较多,否则会出现十分诡异的不触发计算的情况,直接看如下示例代码 public class People { String age; long eventTime; String eventTimeStr; String id; String name; public People(String age, long eventTime, String id, Str
FlinkSQL Regular Join之 Left Join
最新发布
实践出真知
07-08 1017
基本同样的代码，离线计算数据结果皆一致，但是流式Join中差距为何如此大，我的看法是V1中进行left join的主从表本质虽然是一张源表，但都是在筛选之后才进行的关联，筛选条件完全不同，就相当于生成2张完全不一样的临时表，左表是驱动表。
Flink 维表关联方案
猫猫爱吃小鱼粮
01-03 1885
Flink 维表关联方案
mysql主从表关联
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
11-17 267
mysql主从同步 不锁表 能同步吗？ 第一次的时候，锁表和停服务是必须的，否则热备份很容易使数据被破坏。 所以为了以防万一还是需要的。 MYSQL主从同步，新增的表会不会自动在从服务器同步 当然会，mysql主从复制是通过binlog日志来进行了。master会生成binlog日志，slave会开启2个线程，...
Msql 主表从表 主外键关联
weixin_42290648的博客
08-18 410
项目场景： 准备整合一个来源的数据，前提是要把表的关联关系整理好，本以为简单的主表从表设置主、外键，没想到期间也出现几个小插曲。总结下来，以防下次再次遇到~ 问题描述： 1.主表的主键仍然是id自增，不是业务里面的CPID作为主键。 2.给一批从表中的一张表设置外键时报错。 alter table leads_abnormal_operation add constraint CPID foreign key(CPID) references leads_company_baseinfo(id) >
中电金信：技术实践｜Flink维度表关联方案解析
zhongdianjinxin的博客
03-15 1106
实时lookup数据库关联的特点是实现简单，但数据库压力较大，无法支撑大数据量的维度数据查询，并且在查询时只能根据当时的维度表数据查询，如果事实表数据重放或延迟，查询结果的正确性无法得到保证，且多次查询结果可能不一致。广播维度表方案是将维度表数据用流的方式接入Flink Job 程序，并将维度表数据进行广播，再与事件流数据进行关联，此种方式可以及时获取维度表的数据变更，但因数据保存在内存中，因此支持的维度表数据量较小。每条事实表数据都会根据关联键，到存储维度表的数据库中查询一次。
flink流处理
weixin_43705952的博客
12-07 1866
<?xml version="1.0" encoding="UTF-8"?> -<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"&gt
Flink
小道的博客
12-11 1860
Flink知识点
Flink面试题
qq_34936033的博客
05-17 4883
关于spark和flink我可能会问这20个问题,当然并不是说简单回答一下就可以了,每一个题都可以引申很多问题,拿第一个问题来说,里面还有很多东西,比如spark的依赖关系是存在什么地方?RDD的宽窄依赖划分等? 因为你如果什么问题都问,问三天三夜都问不完,所以一定有针对性,而且后面一定会有模拟场景现场编程的问题,因为上面的问题都是偏原理的,你不会你也可以背下来,但是编程就考验你的真实水平了,比如给你一个实时计算的场景,让你写出主要的代码实现.这也是为什么我在星球里面很少分享原理性的东西,更多的怎么解决真实
flink_01
qq_43027968的博客
05-05 644
尚硅谷大数据项目之Flink (作者：尚硅谷大数据研发部) 版本：V1.12.0 Flink简介 初识Flink Flink起源于Stratosphere项目，Stratosphere是在2010~2014年由3所地处柏林的大学和欧洲的一些其他的大学共同进行的研究项目，2014年4月Stratosphere的代码被复制并捐赠给了Apache软件基金会，参加这个孵化项目的初始成员是Stratosphere系统的核心开发人员，2014年12月，Flink一跃成为Apache软件基金会的顶级项目。 在德语中，F
数据中台建设方案-基于大数据平台
2301_76549664的博客
03-14 2344
通过对客户大数据应用平台服务需求的理解，根据建设目标、设计原则的多方面考虑，建议采用星环科技Transwarp Data Hub（TDH）大数据基础平台的架构方案，基于Transwarp Operating System（简称TOS）云平台方式部署构建。 通过建立大数据集成平台、大数据计算平台、大数据开发平台及大数据运维平台来满足客户大数据应用平台服务建设的要求。
Flink SQL 双表 JOIN 介绍与原理简析
cloudbigdata的博客
04-15 8228
带你探究各类 Flink SQL 语法和实现细节
Flink 如何处理离线数据关联（例如和离线数据的关联）
止于终老的博客
06-29 632
在asyncInvoke方法中，我们通过订单中的productId从缓存中获取对应的产品信息，并将产品名称关联到订单数据中。在processElement方法中，我们通过订单的productId从状态中获取离线数据，并将其关联到订单中。这些案例展示了在Flink中处理离线数据关联的不同方法，您可以根据实际情况选择最适合您的场景的方法，并根据需求进行相应的调优和扩展。步骤1：在任务的Open方法中读取离线的产品信息，并将其存储在本地状态中。步骤3：将关联后的订单流进行后续处理，例如计算、过滤或输出等操作。
Flink 1.11.1:flink sql多表join
高矮
10-09 1693
从kafka读取3个topic,join后写数据到clickhouse 代码示例： val createTable = """ |CREATE TABLE nt_sale_order ( | id VARCHAR, | write_date BIGINT, | create_uid INT, | name VARCHAR, | op VARCHAR |) |WITH ( | 'connector'
主表和附表的关联关系，普通字段就可以实现为什么还要有主键外键？之间有什么关系
单炒饭
11-19 4603
主键和外键是把多个表组织为一个有效的关系数据库的粘合剂。主键和外键的设计对物理数据库的性能和可用性都有着决定性的影响。必须将数据库模式从理论上的逻辑设计转换为实际的物理设计。而主键和外键的结构是这个设计过程的症结所在。一旦将所设计的数据库用于了生产环境，就很难对这些键进行修改，所以在开发阶段就设计好主键和外键就是非常必要和值得的。 外键 　外键（FK）是用于建立或加强两个表数据之间的链接的一列...
Flink JDBC Connector：Flink 与数据库集成最佳实践
SmartSi
08-26 2699
Dialect (方言)对各个数据库来说，Dialect 体现各个数据库的特性，比如语法、数据类型等。如果需要查看详细的差异，可以点击这里[6]查看详细差异。下面通过对比 MySQL 和 Postgres 的一些常见场景举例：在数据类型上面，Flink SQL 的数据类型目前映射规则如下：Flink 目前支持三种 Dialect: Derby、MySQL、PostgreSQL，Derby 主要用于测试，更多的类型映射可以点击下方链接前往官方文档查看。......
springboot + flink 抽取 3000万左右的mysql 表到另外一张表
qaz__01的博客
10-10 1069
springboot + flink 抽取 3000万左右的mysql 表到另外一张表
FLINK关联维表方式三之二：异步关联外部数据（MYSQL）数据库
jzy1210的专栏
08-27 559
主类: package quickstart.stream; import org.apache.flink.streaming.api.datastream.AsyncDataStream; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator; import org.apache.
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值