Flink自定义format，实现解析kafka自定义格式的cdc数据

最新推荐文章于 2024-01-15 16:56:01 发布
最新推荐文章于 2024-01-15 16:56:01 发布
阅读量3.4k 收藏 9
点赞数
分类专栏： flink 文章标签： flink java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40498209/article/details/109531087
版权

根据业务需求，kafka的数据为cdc数据，而数据格式是公司自定义的，非json类型数据，而Flink的kafka source已经支持format接口，因此只需开发自己的format即可。

OggDeserializationFactory

package cn.com.xx.cdc.connectors.deserialize;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.configuration.ConfigOptions;
import org.apache.flink.configuration.ReadableConfig;
import org.apache.flink.table.connector.ChangelogMode;
import org.apache.flink.table.connector.format.DecodingFormat;
import org.apache.flink.table.connector.source.DynamicTableSource;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.factories.DeserializationFormatFactory;
import org.apache.flink.table.factories.DynamicTableFactory;
import org.apache.flink.table.factories.FactoryUtil;
import org.apache.flink.table.types.DataType;
import org.apache.flink.table.types.logical.RowType;
import org.apache.flink.types.RowKind;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

public class OggDeserializationFactory implements DeserializationFormatFactory {

	private static final ConfigOption<String> DELIMITER = ConfigOptions.key("delimiter")
			.stringType()
			.defaultValue(",")
			.withDescription("Delimiter of the ogg data");

	@Override
	public String factoryIdentifier() {
		return "ogg";
	}

	@Override
	public Set<ConfigOption<?>> requiredOptions() {
		return Collections.emptySet();
	}

	@Override
	public Set<ConfigOption<?>> optionalOptions() {
		Set<ConfigOption<?>> options = new HashSet<>();
		options.add(DELIMITER);
		return options;
	}

	@Override
	public DecodingFormat<DeserializationSchema<RowData>> createDecodingFormat(DynamicTableFactory.Context context, ReadableConfig formatOptions) {
		FactoryUtil.validateFactoryOptions(this,formatOptions);
		final String delimiter = formatOptions.get(DELIMITER);
//		return new OggFormat(first_delimiter,second_delimiter);
		return new DecodingFormat<DeserializationSchema<RowData>>() {
			@SuppressWarnings("unchecked")
			@Override
			public DeserializationSchema<RowData> createRuntimeDecoder(
					DynamicTableSource.Context context, DataType producedDataType) {
				final RowType rowType = (RowType) producedDataType.getLogicalType();
				final TypeInformation<RowData> rowDataTypeInfo =
						(TypeInformation<RowData>) context.createTypeInformation(producedDataType);
				return new OggDeserialization(
						producedDataType.getLogicalType().getChildren(),
						context.createDataStructureConverter(producedDataType),
						rowDataTypeInfo,
						delimiter);
			}

			@Override
			public ChangelogMode getChangelogMode() {
				return ChangelogMode.newBuilder()
						.addContainedKind(RowKind.INSERT)
						.addContainedKind(RowKind.UPDATE_BEFORE)
						.addContainedKind(RowKind.UPDATE_AFTER)
						.addContainedKind(RowKind.DELETE)
						.build();
			}
		};
	}
}

OggDeserialization

package cn.com.xxx.cdc.connectors.deserialize;

import org.apache.commons.lang.StringUtils;
import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.table.connector.RuntimeConverter;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.types.logical.LogicalType;
import org.apache.flink.table.connector.source.DynamicTableSource.DataStructureConverter;
import org.apache.flink.table.types.logical.LogicalTypeRoot;
import org.apache.flink.types.Row;
import org.apache.flink.types.RowKind;
import org.apache.flink.util.Collector;

import java.io.IOException;
import java.util.List;


public class OggDeserialization implements DeserializationSchema<RowData> {
	private static final long serialVersionUID = 34225227829409419L;

	private final List<LogicalType> parsingTypes;

	private final DataStructureConverter converter;

	private final TypeInformation<RowData> producedTypeInfo;

	private final String delimiter;


	public OggDeserialization(List<LogicalType> parsingTypes,
							  DataStructureConverter converter,
							  TypeInformation<RowData> producedTypeInfo,
							  String delimiter) {
		this.parsingTypes = parsingTypes;
		this.converter = converter;
		this.producedTypeInfo = producedTypeInfo;
		this.delimiter = delimiter;

	}



	@Override
	public boolean isEndOfStream(RowData nextElement) {
		return false;
	}

	@Override
	public TypeInformation<RowData> getProducedType() {
		// return the type information required by Flink's core interfaces
		return producedTypeInfo;
	}

	@Override
	public void open(InitializationContext context) throws Exception {
		converter.open(RuntimeConverter.Context.create(OggDeserialization.class.getClassLoader()));
	}

	@Override
	public RowData deserialize(byte[] message) throws IOException {
		throw new RuntimeException(
				"Please invoke DeserializationSchema#deserialize(byte[], Collector<RowData>) instead.");
	}


	@Override
	public void deserialize(byte[] message, Collector<RowData> out) throws IOException {
	//这部分逻辑自己写，这里只是写出了怎么把row转成rowdata
		final String[] columns = StringUtils.splitPreserveAllTokens(new String(message),"delimiter");
			RowKind kind = parseRowKind(columns[0]);
			Row row = new Row(kind, parsingTypes.size());
			for(int i = 1; i < columns.length; i++){
	row.setField(i,parse(parsingTypes.get(Integer.parseInt(i)).getTypeRoot(),columns[i]));
			}
			out.collect((RowData) converter.toInternal(row));
	}


	private static Object parse(LogicalTypeRoot root, String value) {
		switch (root) {
			case INTEGER:
				return Integer.parseInt(value);
			case VARCHAR:
				return value;
			case BIGINT:
				return Long.valueOf(value);
			default:
				throw new IllegalArgumentException();
		}
	}

	private static RowKind parseRowKind(String op) {
		switch (op) {
			case "I":
				return RowKind.INSERT;
			case "U":
				return RowKind.UPDATE_AFTER;
			case "D":
				return RowKind.DELETE;
			default:
				throw new UnsupportedOperationException("Unsupported operation '" + op + "' for row kind.");
		}
	}
}

pom如下，因为不止是这个程序所需要的依赖，所以自己取舍

    <properties>
        <flink.version>1.11.2</flink.version>
        <debezium.version>1.3.0.Final</debezium.version>
        <scala.binary.version>2.11</scala.binary.version>
        <hadoop.version>2.7.7</hadoop.version>
    </properties>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-connector-kafka -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.12</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <!-- Debezium dependencies -->
        <dependency>
            <groupId>com.alibaba.ververica</groupId>
            <artifactId>flink-connector-debezium</artifactId>
            <version>1.1.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>kafka-log4j-appender</artifactId>
                    <groupId>org.apache.kafka</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-json -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-json</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>io.debezium</groupId>
            <artifactId>debezium-connector-mysql</artifactId>
            <version>${debezium.version}</version>
        </dependency>
        <dependency>
            <groupId>io.debezium</groupId>
            <artifactId>debezium-connector-oracle</artifactId>
            <version>${debezium.version}</version>
            <type>pom</type>
        </dependency>




        <dependency>
            <groupId>io.debezium</groupId>
            <artifactId>debezium-core</artifactId>
            <version>${debezium.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>




        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-test-utils_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-core</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-common</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-tests</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <type>test-jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.ververica</groupId>
            <artifactId>flink-connector-test-util</artifactId>
            <version>1.1.0</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-common</artifactId>
            <version>${flink.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.12</artifactId>
            <version>${flink.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-json</artifactId>
            <version>${flink.version}</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>commons-logging</artifactId>
                    <groupId>commons-logging</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>


    </dependencies>
啃骨头的代码狗
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CDC 实时入湖方案：MySQL＞Flink CDC＞Kafka ＆ Schema Registry＞Hudi ( HoodieMultiTableStreamer )
Laurence的技术博客
05-19 1434
本方案的技术链路为：使用 Flink CDC 将 MySQL 的 CDC 数据 （Avro 格式）接入到 Kafka ，然后通过 Hudi 的 HoodieMultiTableStreamer 将摄取的 CDC 数据写入到 Hudi 表中。整个链路由 Confluent Schema Registry 控制 Schema 的变更。本文和《CDC 实时入湖方案：MySQL > Flink CDC > Kafka ＆ Schema Registry > Hudi ( Flink Connector ) 》介绍的
Flink实战之自定义TableFormat
weixin_41608066的博客
07-29 1269
自定义TableFormat主要包含如下步骤： 实现TableFormatFactory接口 实现SerializationSchemaFactory、DeserializationSchemaFactory 序列化和反序列化接口 两个工厂接口用于创建Schema的序（反）列化对象类。 实现SerializationSchema、DeserializationSchema 在source或sink Function的invoke方法中对数据使用SerializationSchema的seri
flink sql 知其所以然（五）| 自定义 protobuf format
qq_34608620的博客
08-25 1322
感谢您的关注  +  点赞 + 再看，对博主的肯定，会督促博主持续的输出更多的优质实战内容！！！1.序篇-本文结构 大数据羊说 用数据提升美好事物发生的概率~
Flink cdc自定义format格式数据源
从大数据到人工智能的博客
10-22 2085
总览 变更数据捕获 (CDC) 已成为一种流行的模式，用于从数据库捕获已提交的变更并将这些变更传播给下游消费者，例如保持多个数据存储同步并避免常见的陷阱，例如双重写入。 能够轻松地将这些变更日志摄取和解释到 Table API/SQL 中一直是 Flink 社区的一个非常需要的功能，现在 Flink 1.11 可以实现。 为了将 Table API/SQL 的范围扩展到 CDC 等用例，Flink 1.11 引入了具有变更日志模式的新表源和接收器接口（请参阅新的 TableSource 和 TableSin
flink table api 自定义数据格式解析
微溪
02-21 6519
&amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;nbsp;flink table api目前支持的数据格式(https://ci.apache.org/projects/flink/flink-docs-release-1.7/dev/table/tableApi.html ）除基础数据格式外还支持pojo,但毕竟支持有限，我们希望通过固定的解析，就能直
Flink SQL 自定义 Source format
shengjk1的博客
10-20 1575
1. 背景 2. 步骤 3.自定义 Format 4. 使用自定义 Format 1.背景 由于 kafka 中的 json 属于嵌套，又不想二次序列化再把它展开，故自定义 format。 2.步骤 1.自定义 Factory 实现 DeserializationFormatFactory 2.自定义 DeserializationSchema 实现 DeserializationSchema 3. 自定义 Factory 中 createDecodingFormat 方法返回 createDeco.
自定义flink sql format
最新发布
Flake
01-15 386
举例格式为（key:value,key:value）key有两种 带B_为before列。
Flink入门：读取Kafka实时数据流，实现WordCount
01-07
本文主要介绍Flink接收一个Kafka文本数据流，进行WordCount词频统计，然后输出到标准输出上。通过本文你可以了解如何编写和运行Flink程序。 代码拆解 首先要设置Flink的执行环境： // 创建Flink执行环境 ...
java实现flink订阅Kerberos认证的Kafka消息示例源码
04-16
在Java中实现Flink订阅Kerberos认证的Kafka消息是一项关键任务，特别是在处理安全敏感的数据流时。本文将深入探讨这一主题，介绍如何利用Apache Flink与Kafka的集成，以及如何通过Kerberos进行身份验证。 首先，...
flink自定义数据源源码
02-07
在Flink流处理框架中，自定义数据源是实现特定数据接入或数据生成的关键步骤。本文将深入探讨如何在Flink中创建自定义数据源，包括理解Flink的数据摄入机制、自定义SourceFunction的实现以及如何整合到Flink作业中。...
Flink消费Kafka数据1
08-03
Flink消费Kafka数据 Flink 是一种大数据处理引擎，可以消费 Kafka 数据。本文将介绍如何使用 Flink 消费 Kafka 数据，并提供了实验环境的配置和资源购买的详细步骤。 一、实验环境配置 在本实验中，我们将使用...
flume+kafka+flink+mysql数据统计
04-20
在大数据处理领域，Flume、Kafka、Flink 和 MySQL 是四个非常重要的组件，它们各自承担着不同的职责，共同构建了一套高效的数据流处理系统。本文将深入探讨这些技术及其在"flume+kafka+flink+mysql数据统计"中的应用...
【源码解读】Flink-Kafka连接器自定义序列器和分区器
欢迎来到李奇峰的数据世界
01-19 2995
通过阅读源码得知，目前Flink官方不推荐通过分区器来进行数据的分区操作，可以通过序列化器实现。 同时KeyedSerializationSchema分区器已经不推荐使用，推荐使用KafkaSerializationSchema
flinkSQL解析kafka数据源格式
qq_42422698的博客
05-26 347
flinksql kafka json
自定义Flink消费和生产Kafka消息（消费时Schema、生产时Key&Value&分区）
为一个人走几座城
04-13 1520
当我们在消费Kafka数据时，比较常用的是SimpleStringSchema，我个人比较喜欢用的是JSONKeyValueDeserializationSchema。上述两个API可以完成绝大多数的开发场景，但是但遇到个别的特殊场景时，我们需要自定义数据格式，此时我们就需要自定义xxSchema了，这里我们需要实现KafkaDeserializationSchema，从而来完成重定义消费时Kafka的数据格式。 以下是基本的模板，需要什么样的数据格式，只需要做简单的修改即可。 package com
Flink 读写Kafka总结
主要分享大数据相关的知识，如Spark、Hudi
07-05 1920
总结Flink读写Kafka。
Flink ＜--＞Kafka的使用介绍+with参数
Samooyou的博客
05-31 1607
Kafka数据管道是流计算系统中最常用的数据源（Source）和数据目的（Sink）。用户可以把流数据导入到Kafka的某个 Topic 中，通过 Flink 算子进行处理后，输出到相同或不同Kafka示例的另一个 Topic。 Kafka支持同一个 Topic 多分区读写，数据可以从多个分区读入，也可以写入到多个分区，以提供更高的吞吐量，减少数据倾斜和热点。 使用范围 Kafka支持用作数据源表（Source），也可以作为 Tuple 数据流的目的表（Sink），暂不支持 Upsert...
转载---Flink 如何将聚合结果写入kafka ——读写canal-json
qq_31866793的博客
09-11 1343
概述 1.11版本最重要的特性Hive Streaming在之前的博客，包括Flink中文社区的微信公众号上，都和大家聊过不少次了。那么除此之外，还有什么特性值得大家关注呢？ CDC数据的解析：可以解析canal、debezium推到kafka中的binlog；如果在binlog中是个DELETE的操作，那么会自动解析成撤回流，将之前那条下发过的数据撤回；美中不足的是，只支持读，不支持写，这也就以为着无法将撤回流写入kafka Postgres Catalog：如果要用Postgres中的表，不需要
flink自定义kafka sink
10-09
要自定义 Flink 的 Kafka Sink，您可以通过实现 `org.apache.flink.streaming.connectors.kafka.KafkaSerializationSchema` 接口来实现自定义的序列化逻辑。以下是一个简单的示例： ```java import org.apache....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值