Flink实战 - 使用异步方式读取mysql数据

最新推荐文章于 2024-04-25 15:05:27 发布
最新推荐文章于 2024-04-25 15:05:27 发布
阅读量2.4k 收藏 16
点赞数 3
分类专栏： Flink实战 文章标签： flink mysql 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49826240/article/details/114053579
版权

Flink 是流计算引擎

文章原址：https://blog.csdn.net/m0_49826240/article/details/114053579

在Flink任务开发过程中经常会遇到从外部存储获取数据的场景，比如处理日志数据时，需要获取到用户的信息。

最近在做一个指标，用到了异步IO，借此来记录下Flink Async I/O 读取MySql的方式。

需求：用户的行为数据通过Stream进入flink计算引擎，需要知道每个用户的注册时间、最近一次登录时间。

用户注册时间和登录时间是存放在User表中

User 表

-- user table
CREATE TABLE `mall_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键',
  `userId` bigint(11) DEFAULT NULL,
  `registerTime` bigint(11) DEFAULT NULL,
  `lastLoadTime` bigint(11) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=armscii8


-- 数据写入
INSERT INTO `mall_user` VALUES (1, 10086, 1614009599, 1616860800);
INSERT INTO `mall_user` VALUES (2, 10010, 1614009600, 1616861600);

User 类

@Data
public class User {
    /**
     * userId
     */
    private Long userId;
    /**
     * 注册时间
     */
    private Long registerTime;
    /**
     * 上次登录时间
     */
    private Long lastLoadTime;
}

数据流，采用读取指定端口来获得。

直接上代码，根据代码来讲解

1.main方法：

从 9980 端口读取数据后，转为User对象，此时user对象中只有userid，没有两个时间的值

关联维表获取两个时间值，取数据这个过程不能太长，所以设置了异步读取数据的超时时间为3秒。

import com.zyx.bigdata.flink.streaming.asynio.entity.User;
import com.zyx.bigdata.flink.streaming.asynio.operator.GetUserInfoByUserIdAsyncFunction;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.streaming.api.datastream.AsyncDataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.util.concurrent.TimeUnit;

/**
 * @Author zyx
 * @Date 2020-10-20 15:23
 */
public class AsynGetUserInfoJon {

    public static void main(String[] args) throws Exception {

        // 获取 flink env
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 因为本地测试，并行度设置为1
        env.setParallelism(1);
        // 从 9980 端口读取数据，传入的数据为userid
        SingleOutputStreamOperator<User> localhost =
                env.socketTextStream("localhost", 9980, "\n")
                .flatMap(new FlatMapFunction<String, User>() {
                    @Override
                    public void flatMap(String value, Collector<User> out) throws Exception {
                        try {
                            long userId = Long.parseLong(value);
                            User user = new User();
                            user.setUserId(userId);
                            out.collect(user); // 此时吐出的数据中只有userid
                        } catch (Exception e) {
                            System.out.println("error "+ e);
                        }
                    }
                });

        // 关联维表 mall_user
        SingleOutputStreamOperator<User> dataEntitySingleOutputStreamOperator = AsyncDataStream
                // 3,TimeUnit.SECONDS 表示超时时间为3秒
                .unorderedWait(localhost, new GetUserInfoByUserIdAsyncFunction(), 3, TimeUnit.SECONDS);

        // 数据打印
        dataEntitySingleOutputStreamOperator.print();

        env.execute("Flink_Async_IO_Test");
    }
}

2.GetUserInfoByUserIdAsyncFunction 类，继承了 RichAsyncFunction 类。

这里需要添加两个依赖

<dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-sql-common</artifactId>
    <version>3.8.5</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-jdbc-client</artifactId>
    <version>3.8.5</version>
    <scope>compile</scope>
</dependency>

此处需要注意的点：

  • 缓存的设置可以减少读取外部存储的次数
  • 是否获取到外部数据，都需要将数据 out 出来，防止线程直占用
  • 出现异常、超时都需要将数据吐出来。
  • 从外部数据读取完后，记得 conn.close()
  • 不明白的可以留言。后续出异步IO的源码阅读
package com.zyx.bigdata.flink.streaming.asynio.operator;

import com.zyx.bigdata.flink.streaming.asynio.entity.User;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.jdbc.JDBCClient;
import io.vertx.ext.sql.ResultSet;
import io.vertx.ext.sql.SQLClient;
import io.vertx.ext.sql.SQLConnection;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.shaded.guava18.com.google.common.cache.Cache;
import org.apache.flink.shaded.guava18.com.google.common.cache.CacheBuilder;
import org.apache.flink.streaming.api.functions.async.ResultFuture;
import org.apache.flink.streaming.api.functions.async.RichAsyncFunction;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

/**
 * @Author axin
 * @Date 2020-10-20 15:29
 */

public class GetUserInfoByUserIdAsyncFunction extends RichAsyncFunction<User, User> {

    private transient SQLClient sqlClient;
    private transient volatile Cache<Long, User> userInfoCache;

    @Override
    public void open(Configuration parameters) {
        // 异步读取 mysql client
        Vertx vertx = Vertx.vertx(new VertxOptions().setWorkerPoolSize(10).setEventLoopPoolSize(5));
        JsonObject config = new JsonObject()
                .put("url", "jdbc:mysql://localhost:3306/bigdata?serverTimezone=UTC")
                .put("driver_class", "com.mysql.jdbc.Driver")
                .put("max_pool_size", 20)
                .put("user", "root")
                .put("password", "root");

        sqlClient = JDBCClient.createShared(vertx, config);
        // 做缓存，优先读取缓存中数据，没有读到时，再从mysql中获取
        userInfoCache = CacheBuilder.newBuilder()
                .initialCapacity(500)  // 初始化缓存池大小
                .maximumSize(1000) // 缓存池最大为1000
                .expireAfterWrite(5, TimeUnit.MINUTES).build(); // 写入的数据5分钟后过期，表示失效
    }

    @Override
    public void asyncInvoke(User inputUser, ResultFuture<User> resultFuture) {

        long userId = inputUser.getUserId();
        // 从缓存中读取该用户的信息
        User userFromCache = userInfoCache.getIfPresent(userId);
        // 判断读取是否成功
        if (userFromCache != null && userFromCache.getLastLoadTime()!=null && userFromCache.getRegisterTime()!=null) {
            // 从缓存中成功获取到数据，user 补充时间字段的值
            inputUser.setLastLoadTime(userFromCache.getLastLoadTime());
            inputUser.setRegisterTime(userFromCache.getRegisterTime());
            resultFuture.complete(Collections.singletonList(inputUser));
        } else {
            // 查询的sql，此处需要注意查询的条件尽量打在索引上，避免查询超时
            String sql = "select `lastLoadTime`,`registerTime` from `mall_user` where `userId` = '" + userId +  "'";
            sqlClient.getConnection(new Handler<AsyncResult<SQLConnection>>() {
                @Override
                public void handle(AsyncResult<SQLConnection> sqlConnectionAsyncResult) {
                    SQLConnection conn = sqlConnectionAsyncResult.result();
                    try {
                        conn.query(sql, resultSetAsyncResult -> {
                            if (resultSetAsyncResult.failed()) {
                                // 获取结果失败，重新执行。此处需要注意控制失败查询次数
                                asyncInvoke(inputUser, resultFuture);
                                return;
                            }
                            // 查询成功
                            ResultSet result = resultSetAsyncResult.result();
                            // 判断取到的值是否有记录
                            if (result.getRows() != null && result.getNumRows() > 0) {
                                User userFromDB = new User();
                                for (JsonObject userInfoFromDB : result.getRows()) {
                                    userFromDB.setUserId(userId);
                                    userFromDB.setRegisterTime(userInfoFromDB.getLong("registerTime"));
                                    userFromDB.setLastLoadTime(userInfoFromDB.getLong("lastLoadTime"));
                                }
                                // 存入 cache
                                userInfoCache.put(userId, userFromDB);
                                // user 补充时间字段的值
                                inputUser.setLastLoadTime(userFromDB.getLastLoadTime());
                                inputUser.setRegisterTime(userFromDB.getRegisterTime());
                            }
                            // 返回数据
                            resultFuture.complete(Collections.singletonList(inputUser));
                        });
                    } catch (Exception e) {
                        // 出现异常，也是需要将数据吐出的，不然会导致异步线程阻塞
                        resultFuture.complete(Collections.singletonList(inputUser));
                        System.out.println("数据查询异常 " + e.getMessage());
                    }
                    conn.close();
                }
            });
        }
    }

    @Override
    public void timeout( User input,  ResultFuture<User> resultFuture) {
        // 查询超时的数据，也需要返回出来，不然会导致数据丢失
        resultFuture.complete(Collections.singletonList(input));
    }

    @Override
    public void close() {
        sqlClient.close();
        userInfoCache.invalidateAll();
    }
}

数据测试：

Terminal 发送数据到9980端口

zyx@axindeMacBook-Pro ~ % nc -lk 9980
10000
10080
10010
10000
10086

控制台打印到数据：

只有userid = 10086和10010 到user在数据库中有数据，所以关联到时间属性值，10000和10080还是返回到null。

 

<?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>flink-demo</artifactId>
        <groupId>com.zyx.flink</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>module-flink-asynio</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <flink.version>1.10.1</flink.version>
        <java.version>1.8</java.version>
        <scala.binary.version>2.11</scala.binary.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- Apache Flink dependencies -->
        <!-- These dependencies are provided, because they should not be packaged into the JAR file. -->
        <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.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>

        <!-- vertx-jdbc -->
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-sql-common</artifactId>
            <version>3.8.5</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-jdbc-client</artifactId>
            <version>3.8.5</version>
            <scope>compile</scope>
        </dependency>
        <!-- mysql-connector -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>

            <!-- Java Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>

            <!-- We use the maven-shade plugin to create a fat jar that contains all necessary dependencies. -->
            <!-- Change the value of <mainClass>...</mainClass> if your program entry point changes. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.0.0</version>
                <executions>
                    <!-- Run shade goal on package phase -->
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <artifactSet>
                                <excludes>
                                    <exclude>org.apache.flink:force-shading</exclude>
                                    <exclude>com.google.code.findbugs:jsr305</exclude>
                                    <exclude>org.slf4j:*</exclude>
                                    <exclude>log4j:*</exclude>
                                </excludes>
                            </artifactSet>
                            <filters>
                                <filter>
                                    <!-- Do not copy the signatures in the META-INF folder.
									Otherwise, this might cause SecurityExceptions when using the JAR. -->
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.zyx.bigdata.DistinctDemo2</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>

        <pluginManagement>
            <plugins>

                <!-- This improves the out-of-the-box experience in Eclipse by resolving some warnings. -->
                <plugin>
                    <groupId>org.eclipse.m2e</groupId>
                    <artifactId>lifecycle-mapping</artifactId>
                    <version>1.0.0</version>
                    <configuration>
                        <lifecycleMappingMetadata>
                            <pluginExecutions>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>org.apache.maven.plugins</groupId>
                                        <artifactId>maven-shade-plugin</artifactId>
                                        <versionRange>[3.0.0,)</versionRange>
                                        <goals>
                                            <goal>shade</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore/>
                                    </action>
                                </pluginExecution>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>org.apache.maven.plugins</groupId>
                                        <artifactId>maven-compiler-plugin</artifactId>
                                        <versionRange>[3.1,)</versionRange>
                                        <goals>
                                            <goal>testCompile</goal>
                                            <goal>compile</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore/>
                                    </action>
                                </pluginExecution>
                            </pluginExecutions>
                        </lifecycleMappingMetadata>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

    <!-- This profile helps to make things run out of the box in IntelliJ -->
    <!-- Its adds Flink's core classes to the runtime class path. -->
    <!-- Otherwise they are missing in IntelliJ, because the dependency is 'provided' -->
    <profiles>
        <profile>
            <id>add-dependencies-for-IDEA</id>

            <activation>
                <property>
                    <name>idea.version</name>
                </property>
            </activation>

            <dependencies>
                <dependency>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-java</artifactId>
                    <version>${flink.version}</version>
                    <scope>compile</scope>
                </dependency>
                <dependency>
                    <groupId>org.apache.flink</groupId>
                    <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
                    <version>${flink.version}</version>
                    <scope>compile</scope>
                </dependency>
            </dependencies>
        </profile>
    </profiles>

</project>

 

axin1995
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
【Flink】维表关联之异步连接mysql
一杯咖啡半杯糖的博客
09-16 872
由于flink每个数据都要直接查询mysql会导致mysql压力很大，前一条数据没处理完后面的数据会阻塞，导致数据背压，此时可以考虑flink的异步IO机制，mysql的话和vertx结合实现异步维表关联，加快了效率 1、引入依赖 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifa...
Flink实时读取Kafka数据批量聚合（定时按数量）写入Mysql.rar
12-27
Flink实时读取Kafka数据批量聚合（定时/按数量）写入Mysql源码+kafka安装包+zookeeper安装包
Flink CDC 最佳实践（以 MySQL 为例）
lhyandlwl的博客
04-06 5295
可以看到，当有数据变更时，Flink CDC Job 会输出变更的表名、记录的主键以及变更的数据。例如，在这个示例中，有一行记录的年龄字段从25变成了27。在 MySQL 中，首先需要创建需要进行 CDC 的表和 CDC 表。CDC 表是一个系统表，它存储了需要捕获的更改数据。接下来，需要编写一个 Flink CDC 应用程序，以将 MySQL 表更改推送到 Kafka 主题中。首先，需要在本地或云端创建 MySQL 数据库，并添加一个具有读写权限的用户。为需要进行同步的 MySQL 表的名称。
一次打通FlinkCDC同步Mysql数据
最新发布
baily_ycl的博客
04-25 976
1、FlinkCDC 提供了对 Debezium 连接器的封装和集成，简化了配置和使用的过程，并提供了更高级的 API 和功能，例如数据格式转换、事件时间处理等。Flink CDC 使用 Debezium 连接器作为底层的实现，将其与 Flink 的数据处理能力结合起来。通过配置和使用 Flink CDC，您可以轻松地将数据库中的变化数据流转化为 Flink 的 DataStream 或 Table，并进行实时的数据处理、转换和分析。2、Flink的DataStream和SQL比较成熟和易用。
flink入门2-flink连接mysql完成读写操作
summon的博客
06-07 5545
本文将会实现flink连接MySQL，废话不多说，上代码。本文章中的数据库表名为token，只有两个字段code和state 2、读取数据源 3、更新和写入数据 4、启动类 5、source、sink介绍 sourcesink
flink定时读取mysql数据_flink时间系统系列之实例讲解：如何做定时输出
weixin_36384501的博客
02-23 2188
flink时间系统系列篇幅目录：六、实例讲解：如何做定时输出今天为大家带来flink时间系统系列最后一篇实战篇，同样也是查漏补缺篇：如何做定时输出，首先说一下定时输出的需求背景，在flink流处理中需要将任务处理的结果数据定时输出到外部存储中例如mysql/hbase等，如果我们单条输出就可能会造成对外部存储造成较大的压力，首先我们想到的批量输出，就是当需要输出的数据累计到一定大小然后批量写入外部...
Flink自定义并行读取Mysql数据
dinghua_xuexi的专栏
08-03 2593
自定义Source概述 自定义Source是Flink学习中非常重要的一环，一般实现一个Source，可以继承下面几个类之一 SourceFunction RichSourceFunction ParallelSourceFunction RichParallelSourceFunction 前两个是单并行度，后2个是多并行度，无论是否多并行度，我们一般选择带Rich的SourceFunction, 也就是RichSourceFunction和RichParallelSourceFunction，这
使用java、spark和flink连接各种数据集和mq
05-11
例如，Java JDBC（Java Database Connectivity）允许开发者与各种数据库（如MySQL、Oracle、SQL Server等）进行交互，实现数据的读取和写入。此外，Java还支持AMQP（Advanced Message Queuing Protocol）库，如...
基于 Flink CDC 的现代数据栈.pdf
03-21
基于 Flink CDC 的现代数据栈（Modern Data Stack）是指使用 Flink CDC 等技术或工具的组合，来构建现代化的数据栈。现代数据栈基于云上构建，具备传统数据栈很难具备的弹性和扩容优势，现代数据栈层次清晰有利于...
商业源码-编程源码-Ddas数据驱动应用程序开发范例.zip
06-14
源码可能包含使用流处理框架（如Apache Flink或Spark Streaming）的例子，展示如何处理实时数据流。 6. 数据存储：源码可能涵盖了多种数据存储技术，如关系型数据库（MySQL、PostgreSQL）、NoSQL数据库（MongoDB、...
数据中台之结构化大数据存储设计.pdf
10-02
4. **消息队列**：如Kafka或RabbitMQ，用于异步处理和数据传输，实现数据流的解耦，提高系统可扩展性。 5. **非结构化大数据存储**：如对象存储OSS，专为存储图片、视频等非结构化数据设计，同时支持在线查询和离线...
webapp:服务器向操作员提供传感器数据
03-11
9. **性能优化**：为了处理大量实时数据，可能需要使用数据流处理工具（如Apache Kafka）或流计算框架（如Apache Flink）。 10. **错误处理和日志记录**：确保在出现问题时能快速定位和修复，同时对操作员提供有...
4.5、Flink 自定义源算子之 读取MySQL
向热爱自己一样，热爱这个世界。
06-29 959
flink 读取 mysql (通过自定义源算子)
【Flink（Apache Flink）】Flink入门及获取数据、实现多并行度
qq_47450919的博客
08-14 622
Flink（Apache Flink）是一个流式处理和批处理的开源框架，用于高性能、可伸缩的数据流处理。它提供了强大的数据流处理能力，适用于实时数据分析、事件驱动应用和大规模数据处理。 本教程包括以下内容：Flink环境配置与运行、获取数据[自定义读取kafka数据/使用官方组件读取]、实现多并行度。
Flink SQL-Client 的使用
马斯特杨的博客
05-11 2462
flink sql client 介绍 The SQL Client aims to provide an easy way of writing, debugging, and submitting table programs to a Flink cluster without a single line of Java or Scala code. The SQL Client CLI allows for retrieving and visualizing real-time results
Flink通过异步流关联Mysql
Appreciate(欣赏)
02-17 1467
对于异步 I/O 操作的需求 在与外部系统交互（用数据库中的数据扩充流数据）的时候，需要考虑与外部系统的通信延迟对整个流处理应用的影响。 简单地访问外部数据库的数据，比如使用 MapFunction，通常意味着同步交互： MapFunction 向数据库发送一个请求然后一直等待，直到收到响应。在许多情况下，等待占据了函数运行的大部分时间。 与数据库异步交互是指一个并行函数实例可以并发地处理多个请求和接收多个响应。这样，函数在等待的时间可以发送其他请求和接收其他响应。至少等待的时间可以被多个请求摊分。大多数情
flink 异步io mysql 缓存_Flink实例（十九）:FLINK 异步IO （四）实例 (二) MySQL
weixin_39757040的博客
02-01 242
业务如下：接收kafka数据，转为user对象，调用async，使用user.id 查询对应的phone，放回user对象，输出主类：import com.alibaba.fastjson.JSON;import com.venn.common.Common;import org.apache.flink.formats.json.JsonNodeDeserializationSchema;imp...
Flink读写系列之-读mysql并写入mysql
热门推荐
A coder of life
10-19 2万+
在Flink文档中，提供connector读取源数据和把处理结果存储到外部系统中。但是没有提供数据库的connector，如果要读写数据库，官网给出了异步IO(Asynchronous I/O)专门用于访问外部数据，详细可看： https://ci.apache.org/projects/flink/flink-docs-release-1.6/dev/stream/operators/asyn...
flink读写MySQL的两种方式
ASN_forever的博客
05-09 4178
目前跑通的读写MySQL的方式有两种，一种是直接使用flink自带的JDBCInputFormat和JDBCOutputFormat，另一种是自定义source和sink。 方式一：使用自带的JDBCInputFormat和JDBCOutputFormat public class ReadWriteMysqlByJDBC { public static void main(String[] args) throws Exception { ExecutionEnvironme
flink实战--flinksql使用Streaming Sink将数据流写入文件系统
07-27
您好！对于使用Flink SQL将数据流写入文件系统，您可以通过以下步骤来实现： 1. 导入所需的依赖项 首先，您需要在您的项目中添加Flink SQL和所选文件系统的相关依赖项。例如，如果您想将数据写入HDFS文件系统，您需要添加相关的Hadoop依赖项。 2. 创建一个Flink StreamTableEnvironment 通过创建一个Flink StreamTableEnvironment，您可以使用Flink SQL来处理和操作流数据。 ```java StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env); ``` 3. 定义输入表和输出表 您需要定义一个输入表和一个输出表，以便在Flink SQL中引用它们。 ```java tableEnv.executeSql("CREATE TABLE inputTable (field1 INT, field2 STRING) WITH (...)"); tableEnv.executeSql("CREATE TABLE outputTable (field1 INT, field2 STRING) WITH (...)"); ``` 在上述代码中，您需要根据实际情况替换`WITH (...)`部分，并根据您的输入数据源和输出目标进行配置。 4. 将数据流写入输出表 使用Flink SQL的INSERT INTO语句，您可以将数据从输入表写入输出表。 ```java tableEnv.executeSql("INSERT INTO outputTable SELECT * FROM inputTable"); ``` 在上述代码中，我们使用SELECT *从输入表中选择所有字段，并将其插入输出表中。 5. 执行Flink程序 最后，使用`env.execute()`来触发Flink程序的执行。 ```java env.execute(); ``` 这将启动Flink作业并开始将数据流写入文件系统。 请注意，上述步骤是一个简单的示例，您需要根据实际情况进行适当的配置和调整。另外，根据您选择的文件系统，可能还需要进行额外的配置和设置。 希望以上信息对您有所帮助！如有任何进一步的问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值