FlinkCDC Java DataStream API 的异源双流 JOIN

最新推荐文章于 2024-05-25 02:11:57 发布
最新推荐文章于 2024-05-25 02:11:57 发布
阅读量1.6k 收藏 10
点赞数 9
分类专栏： # Flink 文章标签： java postgresql mysql flink 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yh_1480870055_zy/article/details/125361546
版权

1 说明

1.1 案例说明

本文使用 Flink CDC 2.2 最新版本及 Flink 1.14 版本通过 DataStream API 做双表（产品表/订单表）流 Join 操作案例。

产品表： 在 MySQL 数据源中。
订单表： 在 PostgreSQL 数据源中。

双流Join大致流程：
异源双流Join流程图

案例具体划分有：

  • 抽取 PostgreSQL 单表案例
    • 抽取订单表 JsonDebezium 格式打印控制台
    • 抽取订单表 JsonObjectDebezium 格式打印控制台
  • 处理时间窗口 Join 联结
    • 处理时间窗口 内联结 案例
    • 处理时间窗口 外联结 案例

案例大致流程如下：
双流 ETL 流程

1.2 软件说明

软件说明如下：

软件版本
Flink1.14.4
Flink CDC2.2
MySQL8.0.24
PostgreSQL12.10

说明：

  • MySQL 服务器必须开启 binlog功能。
  • PostgreSQL 需要开启日志功能。
  • Flink 官网（https://flink.apache.org/）
  • Flink CDC 官网（https://github.com/ververica/flink-cdc-connectors）
  • PostgreSQL 官网（https://www.postgresql.org/）
  • MySQL 官网（https://www.mysql.com/）

1.3 数据表字段说明

产品表（products）字段说明：

[
    id int primary key COMMENT '主键',
    name varchar(255) not null COMMENT '产品名称',
]

订单表（orders）字段说明：

[
    order_id int4 primary key COMMENT '主键',
    order_name varchar(255) not null COMMENT '订单名称',
    order_date timestamp(3) not null COMMENT '订单时间',
    order_price numeric(10,2) not null COMMENT '订单价格',
    product_id int4 not null COMMENT '产品id'
]

1.4 数据流字段说明

产品表（products）数据流字段说明：

[
  id:  int,   // 主键id
  name: string, // 产品名称
  op: string, // 数据操作类型
  ts_ms: long // 毫秒时间戳
]

订单表（orders）数据流字段说明：

[
  order_id:  int,   // 订单主键id
  order_name: string, // 订单名称
  order_date: long,  // 订单时间，毫秒时间戳
  order_price: string,  // 订单价格
  product_id: int,  // 产品id
  op: string, // 数据操作类型
  ts_ms: long // 毫秒时间戳
]

2 准备工作

2.1 MySQL 数据准备

用 Navicat 连接 MySQL，建表及初始化数据 SQL 语句如下：

-- 创建数据库 flinkcdc_product_manage
create database flinkcdc_product_manage;

-- 使用数据库 flinkcdc_product_manage
use flinkcdc_product_manage;

-- 创建产品表
CREATE TABLE products (
  id INTEGER NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '主键' ,
  name VARCHAR(255) NOT NULL COMMENT '产品名称'
)AUTO_INCREMENT = 101 COMMENT = '产品表';

-- 插入两条数据
INSERT INTO products VALUES (default,"篮球"),(default,"乒乒球");

截图：
MySQL 数据准备

2.2 PostgreSQL 数据准备

用 Navicat 连接 PostgreSQL，建表及初始化数据 SQL 语句如下：

-- 创建数据库 flinkcdc_order_manage
create database flinkcdc_order_manage;

-- 使用数据库 flinkcdc_order_manage
use flinkcdc_order_manage;

-- 创建订单表
CREATE TABLE orders (
  order_id SERIAL NOT NULL PRIMARY KEY,
  order_name VARCHAR(255) NOT NULL,
  order_date TIMESTAMP(3) NOT NULL ,
  order_price DECIMAL(10, 2) NOT NULL,
  product_id INTEGER NOT NULL
);

-- 添加注释
COMMENT ON COLUMN "public"."orders"."order_id" IS '订单主键';
COMMENT ON COLUMN "public"."orders"."order_name" IS '订单名称';
COMMENT ON COLUMN "public"."orders"."order_date" IS '订单时间';
COMMENT ON COLUMN "public"."orders"."order_price" IS '订单价格';
COMMENT ON COLUMN "public"."orders"."product_id" IS '产品id';
COMMENT ON TABLE "public"."orders" IS '订单表';

ALTER SEQUENCE public.orders_order_id_seq RESTART WITH 1001;
ALTER TABLE public.orders REPLICA IDENTITY FULL;

-- 插入数据
INSERT INTO orders VALUES (default, '篮球订单', '2022-05-13 17:08:22', 88.88, 101);

截图：
PostgreSQL 数据准备
注意：

  • 这里的 order_date 的数据类型 timestamp(3)，目的是为了保证抓取时时间戳的为 毫秒格式，一般而言，基本上都是用毫秒。如果指定 timestamp(6)，则代表使用 微秒 格式时间戳。
  • 官网链接说明如下：
https://debezium.io/documentation/reference/1.9/connectors/postgresql.html#postgresql-temporal-values

Debezium 中时间戳问题说明

2.3 项目相关

2.3.1 项目结构

在 IDEA 中创建 maven 项目，项目结构截图如下：
异源双流 JOIN 项目工程图

2.3.2 项目依赖

父工程（datastream-etl-demo）的 pom.xml 文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.mfox</groupId>
    <artifactId>datastream-etl-demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>telephone-etl-demo</module>
        <module>teacher-course-etl-demo</module>
        <module>datastream-common</module>
        <module>product-orders-etl-demo</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <flink.version>1.14.4</flink.version>
        <scala.binary.version>2.12</scala.binary.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.12</artifactId>
            <version>1.12.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>

        <dependency>
            <groupId>com.ververica</groupId>
            <artifactId>flink-sql-connector-mysql-cdc</artifactId>
            <version>2.2.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.80</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

子工程（datastream-etl-demo）的 pom.xml 文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>datastream-etl-demo</artifactId>
        <groupId>cn.mfox</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>product-orders-etl-demo</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>cn.mfox</groupId>
            <artifactId>datastream-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.ververica</groupId>
            <artifactId>flink-sql-connector-postgres-cdc</artifactId>
            <version>2.2.0</version>
        </dependency>
    </dependencies>

</project>

2.3.3 基础类

  • OpEnum.java
  • TransformUtil.java
    common 包相关类
    OpEnum.java 枚举类内容如下：
package cn.mfox.common.enumeration;

/**
 * CDC 中 op类型
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/12 17:28
 */
public enum OpEnum {

    /**
     * 新增
     */
    CREATE("c", "create", "新增"),

    /**
     * 修改
     */
    UPDATA("u", "update", "更新"),

    /**
     * 删除
     */
    DELETE("d", "delete", "删除"),

    /**
     * 读
     */
    READ("r", "read", "读");

    /**
     * 字典码
     */
    private String dictCode;

    /**
     * 字典码翻译值
     */
    private String dictValue;

    /**
     * 字典码描述
     */
    private String description;

    OpEnum(String dictCode, String dictValue, String description) {
        this.dictCode = dictCode;
        this.dictValue = dictValue;
        this.description = description;
    }

    public String getDictCode() {
        return dictCode;
    }

    public String getDictValue() {
        return dictValue;
    }

    public String getDescription() {
        return description;
    }
}

TransformUtil.java 工具类内容如下：

package cn.mfox.common.utils;

import cn.mfox.common.enumeration.OpEnum;
import com.alibaba.fastjson.JSONObject;

/**
 * 转换工具类
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/12 16:25
 */
public class TransformUtil {

    /**
     * 格式化抽取数据格式
     * 去除before、after、source等冗余内容
     *
     * @param extractData 抽取的数据
     * @return
     */
    public static JSONObject formatResult(String extractData) {
        JSONObject formatDataObj = new JSONObject();
        JSONObject rawDataObj = JSONObject.parseObject(extractData);
        formatDataObj.putAll(rawDataObj);
        formatDataObj.remove("before");
        formatDataObj.remove("after");
        formatDataObj.remove("source");
        String op = rawDataObj.getString("op");
        if (OpEnum.DELETE.getDictCode().equals(op)) {
            // 新增取 before结构体数据
            formatDataObj.putAll(rawDataObj.getJSONObject("before"));
        } else {
            // 其余取 after结构体数据
            formatDataObj.putAll(rawDataObj.getJSONObject("after"));
        }
        return formatDataObj;
    }
}

2.3.4 数据流类

数据流类OrdersDataStream.java 内容如下：

package cn.mfox.datastream;

import cn.mfox.common.utils.TransformUtil;
import com.alibaba.fastjson.JSONObject;
import com.ververica.cdc.connectors.postgres.PostgreSQLSource;
import com.ververica.cdc.debezium.DebeziumSourceFunction;
import com.ververica.cdc.debezium.JsonDebeziumDeserializationSchema;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.util.Properties;

/**
 * 抽取 订单表 数据源流
 * 
 * @author hy
 * @version 1.0
 * @date 2022/5/13 14:33
 */
public class OrdersDataStream {

    /**
     * 获取数据流
     *
     * @param env
     * @return
     */
    public static DataStreamSource<String> getJsonDebeziumDataStreamSource(StreamExecutionEnvironment env) {
        // 1.创建Flink-PostgreSQL-CDC的Source
        Properties debeziumPropert = new Properties();
        debeziumPropert.setProperty("decimal.handling.mode", "double");
        DebeziumSourceFunction<String> postgresqlSource = PostgreSQLSource.<String>builder()
                .hostname("192.168.18.102")
                .port(5432)
                .username("postgres")
                .password("123456")
                .database("flinkcdc_order_manage")
                .schemaList("public")
                .tableList("public.orders")
                .deserializer(new JsonDebeziumDeserializationSchema())
                .debeziumProperties(debeziumPropert)
                .slotName("order")
                .build();
        // 2.使用CDC Source 读取数据
        return env.addSource(postgresqlSource, "Orders Source");
    }

    /**
     * 获取 JOSONObject 格式数据
     *
     * @param env
     * @return
     */
    public static DataStream<JSONObject> getJSONObjectDebeziumDataStream(StreamExecutionEnvironment env) {
        // 1. 抽取 Debzium格式 数据流
        DataStreamSource<String> debeziumDataStream = getJsonDebeziumDataStreamSource(env);
        // 2.转换为 JSONObject 格式
        return debeziumDataStream.map(rawData -> {
            return TransformUtil.formatResult(rawData);
        });
    }
}

说明：

  • debeziumPropert.setProperty(“decimal.handling.mode”, “double”) 主要是为了解决数据类型为 numeric 的问题，如果不设置该配置，数据库中的数据为 numeric 的数据，抽取数据后，自动变为 “Irg=”。
  • “未设置” 和 “设置” 的对比图如下：
    numeric 数据类型配置ProductDataStream.java 内容如下：
package cn.mfox.datastream;

import cn.mfox.common.utils.TransformUtil;
import com.alibaba.fastjson.JSONObject;
import com.ververica.cdc.connectors.mysql.source.MySqlSource;
import com.ververica.cdc.connectors.mysql.table.StartupOptions;
import com.ververica.cdc.debezium.JsonDebeziumDeserializationSchema;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

import java.time.Duration;

/**
 * 抽取 产品表 数据源流
 * <p>
 * 数据流分为：
 * 有水位线数据流，指定ts_ms为时间戳
 * 无水位线数据流
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/13 10:33
 */
public class ProductDataStream {

    /**
     * 带有水位线 数据流
     *
     * @param env
     * @return
     */
    public static DataStream<JSONObject> getDataStreamWithWatermark(StreamExecutionEnvironment env) {
        WatermarkStrategy<String> watermarkStrategy
                = WatermarkStrategy.<String>forBoundedOutOfOrderness(Duration.ofSeconds(1L))
                .withTimestampAssigner(
                        new SerializableTimestampAssigner<String>() {
                            @Override
                            public long extractTimestamp(String extractData, long l) {
                                return JSONObject.parseObject(extractData.toString()).getLong("ts_ms");
                            }
                        }
                );
        return getDataStream(env, watermarkStrategy);
    }

    /**
     * 无有水位线 数据流
     *
     * @param env
     * @return
     */
    public static DataStream<JSONObject> getDataStreamNoWatermark(StreamExecutionEnvironment env) {
        return getDataStream(env, WatermarkStrategy.noWatermarks());
    }

    /**
     * 获取数据流
     *
     * @param env
     * @return
     */
    public static DataStream<JSONObject> getDataStream(StreamExecutionEnvironment env, WatermarkStrategy watermark) {
        // 1.创建Flink-MySQL-CDC的Source
        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
                .hostname("192.168.18.101")
                .port(3306)
                .username("root")
                .password("123456")
                .databaseList("flinkcdc_product_manage")
                .tableList("flinkcdc_product_manage.products")
                .startupOptions(StartupOptions.initial())
                .deserializer(new JsonDebeziumDeserializationSchema())
                .serverTimeZone("Asia/Shanghai")
                .build();

        // 2.使用CDC Source 读取数据
        DataStreamSource<String> mysqlDataStreamSource = env.fromSource(
                mySqlSource, watermark,
                "ProductDataStream Source"
        );
        // 3.转换为指定格式
        DataStream<JSONObject> mapTransformDataStream = mysqlDataStreamSource.map(rawData -> {
            return TransformUtil.formatResult(rawData);
        });
        return mapTransformDataStream;
    }
}

3 抽取 PostgreSQL 订单表案例

3.1 抽取订单表表数据

3.1.1 JsonDebezium 序列化返回格式

创建 OrdersJsonDebeziumDataStreamTest.java 类文件，内容如下：

package cn.mfox.etl.v1;

import cn.mfox.datastream.OrdersDataStream;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * 抽取订单数据流测试
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/13 14:41
 */
public class OrdersJsonDebeziumDataStreamTest {
    public static void main(String[] args) throws Exception {
        // 1.获取流式执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2.读取 Orders订单表数据流
        DataStream<String> dataStream = OrdersDataStream.getJsonDebeziumDataStreamSource(env);
        // 3.打印
        dataStream.print();
        // 4.启动环境
        env.execute();
    }
}

运行截图：
订单表首次抽取
控制台输出结果：

{
	"before": null,
	"after": {
		"order_id": 1001,
		"order_name": "篮球订单",
		"order_date": 1652461702000,
		"order_price": 88.88,
		"product_id": 101
	},
	"source": {
		"version": "1.5.4.Final",
		"connector": "postgresql",
		"name": "postgres_cdc_source",
		"ts_ms": 1652690846192,
		"snapshot": "last",
		"db": "flinkcdc_order_manage",
		"sequence": "[null,\"39098752\"]",
		"schema": "public",
		"table": "orders",
		"txId": 576,
		"lsn": 39098752,
		"xmin": null
	},
	"op": "r",
	"ts_ms": 1652690846199,
	"transaction": null
}

结论：

  • 默认的 JsonDebezium 序列化返回结果存在很多冗余数据。

3.1.2 JsonDebezium 返回格式优化

创建 OrdersJsonObjectDebeziumDataStreamTest.java 类文件，内容如下：

package cn.mfox.etl.v1;

import cn.mfox.datastream.OrdersDataStream;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

/**
 * 抽取订单数据流测试，数据返回格式为 JSONObject
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/16 15:41
 */
public class OrdersJsonObjectDebeziumDataStreamTest {
    public static void main(String[] args) throws Exception {
        // 1.获取流式执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2.读取 Orders订单表数据流
        DataStream<JSONObject> dataStream = OrdersDataStream.getJSONObjectDebeziumDataStream(env);
        // 3.打印
        dataStream.print();
        // 4.启动环境
        env.execute();
    }
}

运行截图：
订单表优化数据返回格式
结论：

  • 格式转换后，可以去除冗余字段，保留想要数据。

3.1.3 数据返回格式对比

两者版本数据返回格式对比：
数据返回格式对比
结论：

  • 删除冗余字段版本较为整洁。

4 产品流 JOIN 订单流

产品与订单 窗口 Join 联结工程截图

4.1 处理时间窗口内联结

创建 ProductInnerJoinOrderByProcessTimeTest.java 类，内容如下：

package cn.mfox.etl.v2.join.window;

import cn.mfox.datastream.OrdersDataStream;
import cn.mfox.datastream.ProductDataStream;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * 产品与订单 的内联结
 * 基于 处理时间 的内联结，只输出关联数据
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/16 17:07
 */
public class ProductInnerJoinOrderByProcessTimeTest {

    public static void main(String[] args) throws Exception {
        // 1.创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2.获取两者数据流
        DataStream<JSONObject> productDataStream = ProductDataStream.getDataStreamNoWatermark(env);
        DataStream<JSONObject> orderDataStream = OrdersDataStream.getJSONObjectDebeziumDataStream(env);
        // 3.窗口内联结（产品流 和 订单表）打印输出
        windowInnerJoinAndPrint(productDataStream, orderDataStream);
        // 4.执行任务
        env.execute("ProductInnerJoinOrderTest Job");
    }

    /**
     * 窗口联结并打印输出
     * 只支持 inner join，即窗口内联关联到的才会下发，关联不到的则直接丢掉。
     * 如果想实现Window上的 outer join，需要使用coGroup算子
     *
     * @param productDataStream 产品表 数据流
     * @param orderDataStream   订单表 数据流
     */
    private static void windowInnerJoinAndPrint(DataStream<JSONObject> productDataStream,
                                                DataStream<JSONObject> orderDataStream) {
        DataStream<JSONObject> innerJoinDataStream = productDataStream
                .join(orderDataStream)
                .where(product -> product.getInteger("id"))
                .equalTo(order -> order.getInteger("product_id"))
                .window(TumblingProcessingTimeWindows.of(Time.seconds(3L)))
                .apply(
                        new JoinFunction<JSONObject, JSONObject, JSONObject>() {
                            @Override
                            public JSONObject join(JSONObject jsonObject,
                                                   JSONObject jsonObject2) {
                                // 拼接
                                jsonObject.putAll(jsonObject2);
                                return jsonObject;
                            }
                        }
                );
        innerJoinDataStream.print("Window Inner Join By Process Time");
    }
}

程序运行截图：
处理时间窗口内联结

程序运行截图：

Window Inner Join By Process Time> {"op":"r","order_date":1652461702000,"product_id":101,"name":"篮球","order_price":88.88,"id":101,"order_id":1001,"ts_ms":1652692946143,"order_name":"篮球订单"}

说明：

  • 窗口内联结：只输出关联的数据（产品id=101）。

4.2 处理时间窗口外联结

创建 ProductOuterJoinOrderByProcessTimeTest.java 类，内容如下：

package cn.mfox.etl.v2.join.window;

import cn.mfox.datastream.OrdersDataStream;
import cn.mfox.datastream.ProductDataStream;
import com.alibaba.fastjson.JSONObject;
import org.apache.flink.api.common.functions.CoGroupFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

/**
 * 产品与订单 的 外联结
 * 基于 处理时间 的外联结，输出关联数据和单边流非关联数据
 *
 * @author hy
 * @version 1.0
 * @date 2022/5/16 17:30
 */
public class ProductOuterJoinOrderByProcessTimeTest {

    public static void main(String[] args) throws Exception {
        // 1.创建执行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        // 2.获取两者数据流
        DataStream<JSONObject> productDataStream = ProductDataStream.getDataStreamNoWatermark(env);
        DataStream<JSONObject> orderDataStream = OrdersDataStream.getJSONObjectDebeziumDataStream(env);
        // 3.窗口外联结（产品表流 和 订单表流）打印输出
        windowOuterJoinAndPrint(productDataStream, orderDataStream);
        // 4.执行任务
        env.execute("WindowOuterJoinByProcessTimeTest Job");
    }

    /**
     * 窗口外联并打印输出
     * Window上的 outer join，使用coGroup算子，关联不到的数据也会下发
     *
     * @param productDataStream 产品表流
     * @param orderDataStream   订单表流
     */
    private static void windowOuterJoinAndPrint(DataStream<JSONObject> productDataStream,
                                                DataStream<JSONObject> orderDataStream) {
        DataStream<JSONObject> outerJoinDataStream = productDataStream
                .coGroup(orderDataStream)
                .where(product -> product.getInteger("id"))
                .equalTo(order -> order.getInteger("product_id"))
                .window(TumblingProcessingTimeWindows.of(Time.seconds(3L)))
                .apply(
                        new CoGroupFunction<JSONObject, JSONObject, JSONObject>() {
                            @Override
                            public void coGroup(Iterable<JSONObject> iterable,
                                                Iterable<JSONObject> iterable1,
                                                Collector<JSONObject> collector) {
                                JSONObject result = new JSONObject();
                                for (JSONObject jsonObject : iterable) {
                                    result.putAll(jsonObject);
                                }
                                for (JSONObject jsonObject : iterable1) {
                                    result.putAll(jsonObject);
                                }
                                collector.collect(result);
                            }
                        }
                );
        outerJoinDataStream.print("Window Outer Join By Process Time");
    }
}

程序运行截图：

Window Outer Join By Process Time> {"op":"r","order_date":1652461702000,"product_id":101,"name":"篮球","order_price":88.88,"id":101,"order_id":1001,"ts_ms":1652693277047,"order_name":"篮球订单"}
Window Outer Join By Process Time> {"op":"r","name":"乒乒球","id":102,"ts_ms":1652693276870}

说明：

  • 窗口外联结：输出关联的数据（产品id=101）和未关联的数据（产品id=102）。

4.3 处理时间窗口内外联结对比

处理时间窗口内外联结对比

为伊戏诸侯
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink cdc维表关联roadmap
u011624157的专栏
02-07 1056
时态表 Join 意味着对任意表（左输入/探针侧）去关联一个时态表（右输入/构建侧）的版本，时态表可以是一张跟踪所有变更记录的表（例如数据库表的 changelog，包含多个表快照），也可以是物化所有变更之后的表（例如数据库表，只有最新表快照）。 怎样将changelog转换为快照？ ...
Flink进阶篇-CDC 原理、实践和优化&采集到Doris中
S1124654的博客
03-24 5167
Flink进阶篇-CDC 原理、实践和优化&采集到Doris中
flink cdc例子
sasa527的专栏
06-28 4092
flinkcdc 例子
flink 双流join的简单demo验证（mysql --＞ print）_flink 双流join写入mysqldemo
最新发布
2401_85192497的博客
05-25 339
Flink CDC只是单纯的使用一下哈，非原理性讲解哈，原理性的话，可以看一下雪尽老师的解释哈，个人觉得这篇应该是最好的系统化学习资料了Flink CDC 2.x设计原理比较难理解的可能如何拉取数据，本质是select binlog语句拉取。关于双流join更深层次的知识，有需要的同学可以看一下这个文章这篇文章的博主从数据质量（发的数据应该是什么样子的）和数据时效性（关联到了后还是我想要的数据嘛）来讨论的，那这篇文章从另一个角度出发，各类join产生的各种结果，也会简单的描述一些适用的场景。
flink cdc数据同步，DataStream方式和SQL方式的简单使用
xiaobug_zs的博客
05-08 3848
flink cdc能感知数据库的所有修改、新增、删除操作，并以流的形式，进行实时的触发和反馈。
4.3.3 Flink-流处理框架-Flink CDC数据实时数据同步-Flink CDC实操-DataStream方式
敲代码的乔帮主
03-16 3568
目录 1.写在前面 2.相关依赖 3.代码实现 4.运行效果 1.写在前面 Flink CDC有两种实现方式，一种是DataStream方式，一种是FlinkSQL方式。 2.相关依赖 <dependencies> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-ja...
FlinkCDC Java DataStream API 的同源双流JOIN
微信搜：import_bigdata，大数据领域硬核原创作者
02-28 784
全网最全大数据面试提升手册！1 说明1.1 案例说明本文使用 Flink CDC 最新版本 2.2 及 Flink 1.14 版本通过 Java DataStream API 做 双流 Join 案例。双流 Join 大致流程：双流Join案例具体划分有：时间窗口联结处理事件窗口联结处理时间窗口 内联结 案例处理时间窗口 外联结 案例事件时间窗口联结事件时间窗口 内联结 案例事件时间窗口 外联结 ...
基于Flink CDC使用datastream方式全量增量同步mysql to mysql
03-04
基于Flink CDC使用datastream方式全量增量同步mysql to mysql 使用的是java语言，只需配置完源数据库和目标数据库信息，运行MysqlCDC中的main函数，即可实现多库多表同步。
Flink官网实例：基于DataStream API 实现欺诈检测，完整实现
02-07
本实例将详细讲解如何利用 Flink 的 DataStream API 实现欺诈检测，这是一个非常实用的应用场景，例如在金融交易、网络安全等领域。我们将探讨以下几个关键知识点： 1. **Flink DataStream API**：DataStream API ...
flink datastream api 示例大全
10-19
Flink DataStream API是Apache Flink流处理框架的核心部分，用于处理无界和有界数据流。这个API提供了丰富的操作符来构建复杂的数据处理管道。以下是对标题和描述中涉及的知识点的详细解释： 1. **异步IO...
通俗易懂之Flink DataStream API开发
02-07
《Flink DataStream API开发详解》 在大数据处理领域，Apache Flink以其高效实时处理能力备受关注，尤其在流处理方面，Flink的DataStream API提供了强大的工具。本篇将深入探讨流处理的基本概念，以及Flink ...
flinkcdc api
08-19
标题 "flinkcdc api" 指涉的是 Apache Flink 的 Change Data Capture (CDC) API。Flink 是一个流行的开源流处理框架，而 CDC 是一种技术，用于捕获数据库中的数据变化并实时传输到其他系统，如数据仓库、日志系统...
Flink CDC使用Java DataStream API写入Hudi，实时同步业务库
u014519384的博客
07-07 2679
需要源码或者进Flink微信交流群的请+V ：zoomake1024在上一篇文章介绍了使用Flink SQL消费Kafka实时入湖的方法，全程都是SQL实现的，但是当处理逻辑复杂时，SQL并不是那么灵活，此时通过编码的方式可以更好的驾驭整个框架。本篇介绍下，如何使用Java DataStream API以编码的方式，通过Flink CDC同步MySQL数据到Hudi，在整个过程中遇到了很多问题，会一并给出解决方案。主要是参考Hudi源码中的HoodieFlinkStreamer来实现的，首先说明POM文件.
4.3.2 Flink-流处理框架-Flink CDC数据实时数据同步-何为Flink CDC？
敲代码的乔帮主
03-16 3183
目录 1.写在前面 2.Flink CDC出现的动机 3.基于传统的CDC的ETL分析 4.基于Flink CDC的ETL分析 5.支持的版本和连接器 1.写在前面 CDC是一种可以捕获数据库变更的技术，用于数据同步、数据分发和数据采集等多个现实场景。像我们比较熟知的DataX、Canal、Sqoop等多个框架就是常见的CDC开源工具。 Flink CDC一开始只是阿里-云邪个人的一个兴趣孵化项目，于2020年7月提交了第一个commit，2020 年...
flinkcdc的lookup表详解（look.up.cache和buffer的理解）
weixin_51981189的博客
04-06 1653
在流式计算中，维表是一个很常见的概念，一般用于sql的join中，对流式数据进行数据补全，比如我们的source stream是来自日志的订单数据，但是日志中我们只是记录了订单商品的id，并没有其他的信息，但是我们把数据存入数仓进行数据分析的时候，却需要商品名称、价格等等其他的信息，这种问题我们可以在进行流处理的时候通过查询维表的方式对数据进行数据补全。首先查询的是缓存，缓存有数据就直接返回，缓存没有的话再去查询数据库，然后再将查询的结果返回并放入缓存，下次查询的时候直接查询缓存。具体的怎么开启缓存呢？
FlinkCDC之DataStream的反序列自定义
m0_48830183的博客
05-17 309
1、封装成JSON对象。反序列：CustomDebeziumDeserializationSchema。2.自定义反序列：CustomerDeserializationSchema。封装成JSON对象。3.自定义反序列3：CustomerDeserialization，封装成String。一、FlinkDataStream的优缺点就不做过多的累赘了。先来看三个简单的反序列例子吧，测试以MySQL数据源为主。自定义反序列的好处就是得到自己想要的数据格式。2.1 输出的数据格式。
Flink CDC使用详解
悦分享
01-17 121
*** Desc: 自定义序列化方式*///TODO 1.准备流处理环境//TODO 2.开启检查点 Flink-CDC将读取binlog的位置信息以状态的方式保存在CK,如果想要做到断点续传,// 需要从Checkpoint或者Savepoint启动程序//2.1 开启Checkpoint,每隔5秒钟做一次CK ,并指定CK的一致性语义//2.2 设置超时时间为1分钟//2.3 指定从CK自动重启策略。
flinkcdc介绍API使用 1.x与2.x的区别
weixin_43865381的博客
12-18 1116
flink flinkcdc
Flink CDC详细教程（介绍、原理、代码样例）
热门推荐
少说，多做
06-24 2万+
CDC 是变更数据捕获（Change Data Capture）技术的缩写，它可以将源数据库（Source）的增量变动记录，同步到一个或多个数据目的（Sink）。在同步过程中，还可以对数据进行一定的处理，例如分组（GROUP BY）、多表的关联（JOIN）等。例如对于电商平台，用户的订单会实时写入到某个源数据库；A 部门需要将每分钟的实时数据简单聚合处理后保存到 Redis 中以供查询，B 部门需要将当天的数据暂存到 Elasticsearch 一份来做报表展示，C 部门也需要一份数据到 ClickHous
flink双流join datastream
09-09
Flink双流join datastream是指使用Flink流处理框架对两个数据流进行连接操作。在Flink中，双流join是一种常用的操作，它允许我们将两个不同的数据流合并在一起，并在两个流中相关的事件匹配时执行自定义的操作。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值