Flink自定义Table Source

最新推荐文章于 2024-12-03 21:15:00 发布
最新推荐文章于 2024-12-03 21:15:00 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： Flink 文章标签： big data
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haixing1994/article/details/120043422
版权

基于官方文档 User-defined Sources & Sinks 实现，该实现完成了一个自定义Socket Table Source来将Socket传入的数据转为Table。

Flink版本:1.12.1

maven依赖在最后，出现问题首先排查依赖版本是否正确。

在这里插入图片描述

一、TableSource实现

Dynamic Table Factory

在使用Table source时，首先需要建表：

CREATE TABLE UserScores (name STRING, score INT)
WITH (
  'connector' = 'socket',
  'hostname' = 'localhost',
  'port' = '9999',
  'byte-delimiter' = '10',
  'format' = 'changelog-csv',
  'changelog-csv.column-delimiter' = '|'
);

在建表语句中会对数据源进行设置。

而设置语句则是可以进行自定义的，而对其中的设置进行解析需要在DynamicTableFactory实现。

package test.SocketSourceSql;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.configuration.ConfigOptions;
import org.apache.flink.configuration.ReadableConfig;
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.DynamicTableSourceFactory;
import org.apache.flink.table.factories.FactoryUtil;
import org.apache.flink.table.types.DataType;

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

/**
 * @ClassName SocketSqlFactory
 * @Date 2021/8/27 17:41
 * @Version 1.0
 * @Description
 **/
public class SocketSqlFactory implements DynamicTableSourceFactory {

    public static final ConfigOption<String> HOSTNAME = ConfigOptions.key("hostname").stringType().noDefaultValue();

    public static final ConfigOption<Integer> PORT = ConfigOptions.key("port").intType().noDefaultValue();

    public static final ConfigOption<Integer> BYTE_DELIMITER = ConfigOptions.key("byte-delimiter")
            .intType()
            .defaultValue(10);


    /**
     *  用于 'connector' = '...'
     * @return socket
     */
    @Override
    public String factoryIdentifier() {
        return "socket";
    }

    @Override
    public Set<ConfigOption<?>> requiredOptions() {
        final Set<ConfigOption<?>> options = new HashSet<>();
        options.add(HOSTNAME);
        options.add(PORT);
        options.add(FactoryUtil.FORMAT);    // use pre-defined option for format
        return options;
    }

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

    public DynamicTableSource createDynamicTableSource(Context context) {
        final FactoryUtil.TableFactoryHelper helper = FactoryUtil.createTableFactoryHelper(this, context);

        final DecodingFormat<DeserializationSchema<RowData>> decodingFormat = helper.discoverDecodingFormat(
                DeserializationFormatFactory.class, FactoryUtil.FORMAT);

        helper.validate();

        final ReadableConfig options = helper.getOptions();
        final String hostname = options.get(HOSTNAME);
        final int port = options.get(PORT);
        final byte byteDelimiter = (byte) (int)options.get(BYTE_DELIMITER);

        final DataType producedDataType = context.getCatalogTable().getSchema().toPersistedRowDataType();

        return new SocketDynamicTableSource(hostname, port, byteDelimiter, decodingFormat, producedDataType);
    }
}

其中factoryIdentifier负责’connector’字段的解析，requredOptions中设置必须字段，optionalOptions中设置可选的字段。

createDynamicTableSource则根据传入的参数，返回一个Dynamic Table Source

Dynamic Table Source

Dynamic Table Source需要实现ScanTableSource或LookupTableSource

在实现方法中，核心实现在getScanRuntimeProvider方法中创建一个运行时类SourceFunction，该类中实现了具体的数据来源

package test.SocketSourceSql;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
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.connector.source.ScanTableSource;
import org.apache.flink.table.connector.source.SourceFunctionProvider;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.types.DataType;

/**
 * @ClassName SocketDynamicTableSource
 * @Date 2021/8/30 9:38
 * @Version 1.0
 * @Description
 **/
public class SocketDynamicTableSource implements ScanTableSource {

    private final String hostname;
    private final int port;
    private final byte byteDelimiter;
    private final DecodingFormat<DeserializationSchema<RowData>> decodingFormat;
    private final DataType producedDataType;

    public SocketDynamicTableSource(
            String hostname,
            int port,
            byte byteDelimiter,
            DecodingFormat<DeserializationSchema<RowData>> decodingFormat,
            DataType producedDataType) {
        this.hostname = hostname;
        this.port = port;
        this.byteDelimiter = byteDelimiter;
        this.decodingFormat = decodingFormat;
        this.producedDataType = producedDataType;
    }

    @Override
    public ChangelogMode getChangelogMode() {
        return decodingFormat.getChangelogMode();
    }

    @Override
    public ScanRuntimeProvider getScanRuntimeProvider(ScanContext runtimeProviderContext) {
        final DeserializationSchema<RowData> deserializer = decodingFormat.createRuntimeDecoder(
                runtimeProviderContext,
                producedDataType);

        final SourceFunction<RowData> sourceFunction = new ESSourceFunction(
                hostname,
                port,
                byteDelimiter,
                deserializer);

        return SourceFunctionProvider.of(sourceFunction, false);
    }

    @Override
    public DynamicTableSource copy() {
        return new SocketDynamicTableSource(hostname, port, byteDelimiter, decodingFormat, producedDataType);
    }

    @Override
    public String asSummaryString() {
        return "elastic Table Source";
    }
}
Source Function

到SourceFunction这一步就和自定义DataStream一样了，在run()方法中实现数据来源并添加到上下文SourceContext中。

package test.SocketSourceSql;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.typeutils.ResultTypeQueryable;
import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.streaming.api.functions.source.RichSourceFunction;
import org.apache.flink.table.data.RowData;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * @ClassName SocketSourceFunction
 * @Date 2021/8/30 9:56
 * @Version 1.0
 * @Description
 **/
public class SocketSourceFunction extends RichSourceFunction<RowData> implements ResultTypeQueryable<RowData> {

    private final String hostname;
    private final int port;
    private final byte byteDelimiter;
    private final DeserializationSchema<RowData> deserializer;

    private volatile boolean isRunning = true;
    private Socket currentSocket;

    public SocketSourceFunction(String hostname, int port, byte byteDelimiter, DeserializationSchema<RowData> deserializer) {
        this.hostname = hostname;
        this.port = port;
        this.byteDelimiter = byteDelimiter;
        this.deserializer = deserializer;
    }

    @Override
    public TypeInformation<RowData> getProducedType() {
        return deserializer.getProducedType();
    }

    @Override
    public void run(SourceContext<RowData> ctx) throws Exception {
        while (isRunning) {
            // open and consume from socket
            try (final Socket socket = new Socket()) {
                currentSocket = socket;
                socket.connect(new InetSocketAddress(hostname, port), 0);
                try (InputStream stream = socket.getInputStream()) {
                    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
                    int b;
                    while ((b = stream.read()) >= 0) {
                        // buffer until delimiter
                        if (b != byteDelimiter) {
                            buffer.write(b);
                        }
                        // decode and emit record
                        else {
                            ctx.collect(deserializer.deserialize(buffer.toByteArray()));
                            buffer.reset();
                        }
                    }
                }
            } catch (Throwable t) {
                t.printStackTrace(); // print and continue
            }
            Thread.sleep(1000);
        }
    }

    @Override
    public void cancel() {
        isRunning = false;
        try {
            currentSocket.close();
        } catch (Throwable t) {
            // ignore
        }
    }
}

二、数据格式处理

和DynamicTableSource一样，数据格式需要在工厂类中解析建表的参数

ChangelogCsvFormatFactory
package test.SocketSourceSql;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.configuration.ConfigOptions;
import org.apache.flink.configuration.ReadableConfig;
import org.apache.flink.table.connector.format.DecodingFormat;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.factories.FactoryUtil;
import org.apache.flink.table.factories.DeserializationFormatFactory;
import org.apache.flink.table.factories.DynamicTableFactory;

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

public class ChangelogCsvFormatFactory implements DeserializationFormatFactory {

  // define all options statically
  public static final ConfigOption<String> COLUMN_DELIMITER = ConfigOptions.key("column-delimiter")
    .stringType()
    .defaultValue("|");

  @Override
  public String factoryIdentifier() {
    return "changelog-csv";
  }

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

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

  @Override
  public DecodingFormat<DeserializationSchema<RowData>> createDecodingFormat(
      DynamicTableFactory.Context context,
      ReadableConfig formatOptions) {
    // either implement your custom validation logic here ...
    // or use the provided helper method
    FactoryUtil.validateFactoryOptions(this, formatOptions);

    // get the validated options
    final String columnDelimiter = formatOptions.get(COLUMN_DELIMITER);

    // create and return the format
    return new ChangelogCsvFormat(columnDelimiter);
  }
}
ChangelogCsvFormat
package test.SocketSourceSql;

import org.apache.flink.api.common.serialization.DeserializationSchema;
import org.apache.flink.api.common.typeinfo.TypeInformation;
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.connector.source.DynamicTableSource.DataStructureConverter;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.types.DataType;
import org.apache.flink.table.types.logical.LogicalType;
import org.apache.flink.types.RowKind;

import java.util.List;

public class ChangelogCsvFormat implements DecodingFormat<DeserializationSchema<RowData>> {

  private final String columnDelimiter;

  public ChangelogCsvFormat(String columnDelimiter) {
    this.columnDelimiter = columnDelimiter;
  }

  @Override
  @SuppressWarnings("unchecked")
  public DeserializationSchema<RowData> createRuntimeDecoder(
      DynamicTableSource.Context context,
      DataType producedDataType) {
    // create type information for the DeserializationSchema
    final TypeInformation<RowData> producedTypeInfo = context.createTypeInformation(
      producedDataType);

    // most of the code in DeserializationSchema will not work on internal data structures
    // create a converter for conversion at the end
    final DataStructureConverter converter = context.createDataStructureConverter(producedDataType);

    // use logical types during runtime for parsing
    final List<LogicalType> parsingTypes = producedDataType.getLogicalType().getChildren();

    // create runtime class
    return new ChangelogCsvDeserializer(parsingTypes, converter, producedTypeInfo, columnDelimiter);
  }

  @Override
  public ChangelogMode getChangelogMode() {
    // define that this format can produce INSERT and DELETE rows
    return ChangelogMode.newBuilder()
      .addContainedKind(RowKind.INSERT)
      .addContainedKind(RowKind.DELETE)
      .build();
  }
}
ChangelogCsvDeserializer
package test.SocketSourceSql;

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

import java.util.List;
import java.util.regex.Pattern;

public class ChangelogCsvDeserializer implements DeserializationSchema<RowData> {

  private final List<LogicalType> parsingTypes;
  private final DataStructureConverter converter;
  private final TypeInformation<RowData> producedTypeInfo;
  private final String columnDelimiter;

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

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

  @Override
  public void open(InitializationContext context) {
    // converters must be open
    converter.open(Context.create(ChangelogCsvDeserializer.class.getClassLoader()));
  }

  @Override
  public RowData deserialize(byte[] message) {
    // parse the columns including a changelog flag
    final String[] columns = new String(message).split(Pattern.quote(columnDelimiter));
    final RowKind kind = RowKind.valueOf(columns[0]);
    final Row row = new Row(kind, parsingTypes.size());
    for (int i = 0; i < parsingTypes.size(); i++) {
      row.setField(i, parse(parsingTypes.get(i).getTypeRoot(), columns[i + 1]));
    }
    // convert to internal data structure
    return (RowData) converter.toInternal(row);
  }

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

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

三、主程序

package test.SocketSourceSql;

import lombok.extern.slf4j.Slf4j;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.types.Row;

/**
 * @Date 2021/8/30 10:52
 * @Version 1.0
 * @Description
 **/
@Slf4j
public class SocketReader {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

        String CreateTable = "CREATE TABLE UserScores (name STRING, score INT) \n" +
                "WITH( \n" +
                "   'connector'='Socket',\n" +
                "   'hostname'='192.168.51.113',\n" +
                "   'port'='9999',\n" +
                "   'byte-delimiter'='10',\n" +
                "   'format'='changelog-csv',\n" +
                "   'changelog-csv.column-delimiter' = '|'\n" +
                ")";

        tableEnv.executeSql(CreateTable);

        String view = "SELECT name, SUM(score) FROM UserScores GROUP BY name";
        tableEnv.executeSql(view).print();
//        DataStream stream = tableEnv.toRetractStream(table, Row.class);
//        stream.print();
    }
}
结果：

在这里插入图片描述

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-java</artifactId>
    <version>${flink.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
    <version>${flink.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-streaming-scala_2.11</artifactId>
    <version>1.12.1</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-avro</artifactId>
    <version>1.13.0</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-connector-kafka_2.11</artifactId>
    <version>1.13.0</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-clients_2.11</artifactId>
    <version>${flink.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-core</artifactId>
    <version>1.12.1</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-table-common</artifactId>
    <version>1.12.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.ibm.icu/icu4j -->
<dependency>
    <groupId>com.ibm.icu</groupId>
    <artifactId>icu4j</artifactId>
    <version>4.6.1</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.7</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-table-api-java</artifactId>
    <version>1.12.1</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-table-uber-blink_2.11</artifactId>
    <version>1.12.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1.1-jre</version>
</dependency>
flink实战--flinksql自定义table source
阿华田的博客
07-24 1103
自定义FlinkSQL流程总结与案例
如何自定义 Flink Connectors（Source 和 Sink）？
http://www.54tianzhisheng.cn/
09-22 453
在前面文章 3.6 节中讲解了 Flink 中的 Data Source 和 Data Sink，然后介绍了 Flink 中自带的一些 Source 和 Sink 的 Connector，接着我们还有几篇实战会讲解了如何从 Kafka 处理数据写入到 Kafka、ElasticSearch 等，当然 Flink 还有一些其他的 Connector，我们这里就不一一介绍了，大家如果感兴趣的话可以去官...
Flink Sql-用户自定义 Sources & Sinks
bigdatakenan的博客
06-13 1488
在许多情况下，开发人员不需要从头开始创建新的连接器，而是希望稍微修改现有的连接器或 hook 到现有的 stack。在其他情况下，开发人员希望创建专门的连接器。本节对这两种用例都有帮助。它解释了表连接器的一般体系结构，从 API 中的纯粹声明到在集群上执行的运行时代码实心箭头展示了在转换过程中对象如何从一个阶段到下一个阶段转换为其他对象。
flink 流式表自定义StreamTableSource、RetractStreamSink，并使用flink kafkaDataStream.pdf
05-14
本文件是自己根据flink1.8官网文档https://ci.apache.org/projects/flink/flink-docs-release-1.8/dev/table/streaming/time_attributes.html#using-a-tablesource里实现的自定义StreamTableSource，并且输入流也用的是kafkaStream(更贴近实际应用)，由于官网的文档过于简单，并且有漏洞，你如果按照官网文档编写是会运行不成功的。附件文档的代码是亲测完全可以运行的，里面也自己实现了RetractStreamSink，可以供大家参考。
【Flink】Flink 作业执行大致流程
最新发布
HHoao的博客
12-03 1281
下游任务这时是正常处理上游发送过来的数据的，但是上游正在进行 Checkpoint，数据也是被发送过来的 CheckpointBarrier 分割开了，处理到后面会接收到上游的 CheckpointBarrier，也就表示着当前 Checkpoint 上游快照数据已经处理完，下游也开始进行 Checkpoint 了，下游进行 Checkpoint 的过程也是和上面的一样，继续调用 SubtaskCheckpointCoordinatorImpl 开始进行 Checkpoint。
聊聊flink的CsvTableSource
weixin_33795743的博客
02-05 251
序 本文主要研究一下flink的CsvTableSource TableSource flink-table_2.11-1.7.1-sources.jar!/org/apache/flink/table/sources/TableSource.scala trait TableSource[T] { /** Returns the ...
Flink自定义TableSink TableSource
knowfarhhy
10-14 3980
基本知识 TableSource提供了从外部系统（消息队列，KV存储，数据库，文件系统等）接入数据，之后注册到TableEnvironment中，然后可以通过Table API或者SQL进行查询。 TableSink提供了将flink内部注册的Table中的数据写出到外部系统（Es ,Hbase ,消息队列数据库，文件系统等）。 TableFactory用来创建TableSource 、Table...
Flink-Table-SQL系列之source
热门推荐
VinoYang的专栏
06-12 1万+
source作为Table&SQL API的数据源，同时也是程序的入口。当前Flink的Table&SQL API整体而言支持三种source：Table source、DataSet以及DataStream，它们都通过特定的API注册到Table环境对象。
Flink Table & SQL 自定义TableSource、TableSink
王佩的CSDN博客
04-19 5763
Flink Table & SQL中提供了非常丰富的接口来让我们自定义TableSource、TableSink。 自定义TableSource或TableSink，需要将以下两点结合起来: 了解不同TableSource接口、TableSink接口、TableFactory接口提供的功能以及适用的场景。 看JDBCTableSource、JDBCUpsertTableSink源码...
Flink自定义kafkaSource 和Sink
流风雨情的博客
04-01 3539
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=...
flink 自定义多并发度 elasticsearch source连接器
m0_37592814的博客
11-15 4380
前言 参考 1.官网:https://nightlies.apache.org/flink/flink-docs-release-1.13/docs/dev/table/sourcessinks/ 2.博客：https://blog.csdn.net/haixing1994/article/details/120223870?spm=1001.2014.3001.5501 flink1.13 elasticsearch 7.5.1
flink-connector-kudu:基于Apache-bahir-kudu-connector的flink-connector-kudu，支持Flink1.11.x DynamicTableSourceSink，支持范围分区等
03-04
Kudu连接器 基于Apache-Bahir-Kudu连接器改造而来的满足公司内部使用的Kudu连接器，支持特性范围分区，定义哈希分桶数，支持Flink1.11.x动态数据源等，改造后已贡献部分功能给社区。 使用姿势 clone代码后，改造pom项目坐标后上传公司私服使用 Kudu目录使用 创建目录 StreamExecutionEnvironment env = StreamExecutionEnvironment . getExecutionEnvironment(); catalog = new KuduCatalog ( " cdh01:7051,cdh02:7051,cdh03:7051 " ); tableEnv = KuduTableTestUtils . createTableEnvWithBlinkPlannerStreamingMode(env); tableEnv .
Flink Table/SQL自定义Sources和Sinks全解析（附代码）
从大数据到人工智能的博客
01-20 4543
动态表是Flink Table和SQL API处理有界和无界数据的核心概念。 在Flink中，动态表只是逻辑概念，其本身并不存储数据，而是将表的具体数据存储在外部系统（比如说数据库、键值对存储系统、消息队列）或者文件中。 动态源和动态写可以从外部系统读写数据。在下面的描述中，动态源和动态写可以归结为connector。接下来我们来看看如何自定义connector。 代码地址：https://git.lrting.top/xiaozhch5/flink-table-sql-connectors.git 总览
Flink自定义Connector
阿甘兄
04-12 3327
文章目录01 引言02 Connector概述2.1 Metadata - 元数据模块2.2 Planning - 规划模块2.3 Runtime - 运行时模块03 Connector相关API3.1 Dynamic Table Factories - 动态表工厂3.2 Dynamic Table Source - 动态表源3.2.1 Scan Table Source - 扫描表源3.2.2 Lookup Table Source - 查找表源3.3 Dynamic Table Sink - 动态表接
Flink Table & SQL LookableTableSource
王佩的CSDN博客
12-15 5556
在DataStream中，要实现流维Join，可以用Function，如MapFunction、FlatMapFunction、ProcessFunction等等; 或通过Async I/O实现。 从Flink 1.9.0开始，提供了LookableTableSource，只需将Lookup数据源(如Mysql、HBase表)注册成LookableTableSource，即可用SQL的方式，实现流...
flink table & sql（一）table基础概念、环境搭建、source、sink
mojolang
01-21 1164
一、concepts 1、表 表可以是虚拟（VIEWS）或常规（TABLES）。VIEWS可以从现有Table对象创建，通常是Table API或SQL查询的结果。TABLES描述外部数据，例如文件，数据库表或消息队列。 表三部分标识符：目录、数据库、表名。其中，目录、数据库是可选的。 tEnv.useCatalog("custom_catalog"); tEnv.useDatabase("custom_database"); 1.1 临时表与永久表 表可以是临时的，并与单个Flink会话的生命周期.
Flink DataStream转Table 使用SQL：join
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
01-06 1426
inner join 相当于全局窗口，之前的消息也一直保存着，来了一条能关联上的消息，则输出所有的笛卡尔积！ package SQL; import org.apache.flink.streaming.api.datastream.DataStreamSource; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.flink.streaming.api.fu
Flink DataStream与Table之间的相互转换
search-lemon的博客
04-02 1万+
Flink DataStream与Table之间的相互转换1. 一个简单的例子2. DataStream转换为Table3. Table转换为Datastream 1. 一个简单的例子 import org.apache.flink.streaming.api.CheckpointingMode; import org.apache.flink.streaming.api.datastream.D...
Flink 自定义数据源Connector
tianhouquan的专栏
05-13 5278
flink自定义数据源
flink自定义addsource为mysql
10-17
Flink (Apache Flink) 是一个开源的流处理框架，它允许你在实时数据和批处理之间无缝切换。如果你想要在 Flink 中自定义添加一个从 MySQL 数据库读取数据的 Source（源），你需要编写一个 SQL 或者使用 Flink 的 JDBC 接口。 步骤如下： 1. **添加依赖**：首先，确保你的项目依赖包含了 Flink 对 MySQL 连接的支持，你可以通过 Maven 或 Gradle 加入对应的 JDBC 驱动依赖。 2. **创建 JdbcSource**：Flink 提供了 `org.apache.flink.streaming.connectors.jdbc.JdbcInputFormat` 类，你可以实例化这个类并配置连接信息，如数据库 URL、用户名、密码以及 SQL 查询语句（作为表名）。 ```java JdbcSource jdbcSource = new JdbcSource( "jdbc:mysql://localhost:3306/mydatabase", // 数据库URL "username", // 用户名 "password", // 密码 "SELECT * FROM mytable", // SQL查询 Types.STRING, // 返回字段的数据类型 new TableSchema() // 表结构，如果可用 ); ``` 3. **将源添加到DataStream**：然后，你可以将这个自定义的 JdbcSource 添加到 Flink 的 DataStream API 中，例如，作为 StreamExecutionEnvironment 的 source。 ```java StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); DataStream<String> stream = env.addSource(jdbcSource); // 然后对stream进行进一步处理... ``` 4. **运行作业**：最后，提交你的 Flink 作业到集群或者本地运行环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值