Flink操作Kafka教程

已于 2023-10-20 10:11:21 修改
阅读量713 收藏 2
点赞数
文章标签： flink kafka 大数据
于 2023-10-18 20:40:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50753492/article/details/133911033
版权

1.创建kafka Topic

可以实现对KafkaTopic的新建操作

import avro.shaded.com.google.common.collect.Lists;
import org.apache.kafka.clients.admin.AdminClient;
import org.apache.kafka.clients.admin.CreateTopicsResult;
import org.apache.kafka.clients.admin.KafkaAdminClient;
import org.apache.kafka.clients.admin.NewTopic;

import java.util.Properties;
public class CreateKafkaTopic {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("bootstrap.servers", "124.222.201.62:9092");
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        AdminClient adminClient = null;
        try {
            adminClient = KafkaAdminClient.create(properties);
            NewTopic newTopic = new NewTopic("mytest001", 1, (short) 1);
            CreateTopicsResult createTopicsResult = adminClient.createTopics(Lists.newArrayList(newTopic));
            createTopicsResult.all().get();
            if (createTopicsResult.all().isDone()){
                System.out.println("done");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(adminClient != null){
                adminClient.close();
            }
        }

    }
}

使用命令查看Topic

./kafka-topics.sh --zookeeper 127.0.0.1:2181 --list

2.双流Join操作

package org.flink;


import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.connector.kafka.source.KafkaSource;
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.table.descriptors.Json;
import org.apache.flink.table.descriptors.Kafka;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;


/**
 * @author hanjiajun02
 * @date 2023/10/18 16:08
 */
public class DataSourceJoin {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "124.222.201.62:9092"); // Kafka服务器地址
        properties.setProperty("group.id", "test"); // 消费者组ID
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // 如何配置KafkaSource进行join
        KafkaSource<String> kafkaSource = KafkaSource.<String>builder()
                .setTopics("quick_start")
                .setValueOnlyDeserializer(new SimpleStringSchema())
                .setProperties(properties).build();


        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
        tableEnv.connect(new Kafka().version("universal").topic("quick_start").startFromLatest().property("bootstrap.servers", "124.222.201.62:9092"))
                .withFormat(new Json())
                .withSchema( new Schema()  // 定义表结构
                        .field("name", "STRING")
                        .field("sex", "INT")
                        .field("id", "INT"))
                .createTemporaryTable("MyKafkaTable1");

        ProducerRecord<String, String> record = new ProducerRecord<>("quick_start", "{\"name\":\"Shibo\", \"sex\":1, \"id\":1}");
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        producer.send(record);

        tableEnv.executeSql("SELECT * FROM MyKafkaTable1");

        tableEnv.connect(new Kafka().version("universal").topic("quick_start").startFromLatest().property("bootstrap.servers", "124.222.201.62:9092"))
                .withFormat(new Json())
                .withSchema( new Schema()  // 定义表结构
                        .field("name", "STRING")
                        .field("age", "INT")
                        .field("id", "INT"))
                .createTemporaryTable("MyKafkaTable2");
        ProducerRecord<String, String> record_back = new ProducerRecord<>("quick_start", "{\"name\":\"Shibo\", \"age\":1, \"id\":1}");
        KafkaProducer<String, String> producer_back = new KafkaProducer<>(properties);
        producer_back.send(record_back);

        //String sqlJoinQuery = "Select * from MyKafkaTable1, MyKafkaTable2 where MyKafkaTable1.id = MyKafkaTable2.id and MyKafkaTable1.ts between  MyKafkaTable2.ts and  MyKafkaTable2.ts + Interavl \'1\' minute";
        String sqlJoinQuery = "Select * from MyKafkaTable1, MyKafkaTable2 where MyKafkaTable1.id = MyKafkaTable2.id";
        Table joinResult = tableEnv.sqlQuery(sqlJoinQuery);
        DataStream<Row> resultStream = tableEnv.toAppendStream(joinResult, Row.class);
        resultStream.print();
        joinResult.printSchema();

        DataStream<String> stream = env.fromSource(kafkaSource, WatermarkStrategy.noWatermarks(), "KafkaSource" );
        DataStream<String> upperCaseStream = stream.map(new MapFunction<String, String>() {
            @Override
            public String map(String value) {
                System.out.println("Value : " + value);
                return value.toUpperCase();
            }
        });
        upperCaseStream.print();
        System.out.println("TEST");
        env.execute();
    }
}

3.insertData kafka数据源插入数据源

package org.flink;


import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.connector.kafka.source.KafkaSource;
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.table.descriptors.Json;
import org.apache.flink.table.descriptors.Kafka;
import org.apache.flink.table.descriptors.Schema;
import org.apache.flink.types.Row;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;


/**
 * @author hanjiajun02
 * @date 2023/10/18 16:08
 */
public class InsertData {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "124.222.201.62:9092"); // Kafka服务器地址
        properties.setProperty("group.id", "test"); // 消费者组ID
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // 如何配置KafkaSource进行join
        KafkaSource<String> kafkaSource = KafkaSource.<String>builder()
                .setTopics("quick_start")
                .setValueOnlyDeserializer(new SimpleStringSchema())
                .setProperties(properties).build();


        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
        tableEnv.connect(new Kafka().version("universal").topic("quick_start").startFromLatest().property("bootstrap.servers", "124.222.201.62:9092"))
                .withFormat(new Json())
                .withSchema( new Schema()  // 定义表结构
                        .field("name", "STRING")
                        .field("sex", "INT")
                        .field("id", "INT"))
                .createTemporaryTable("MyKafkaTable1");

        ProducerRecord<String, String> record = new ProducerRecord<>("quick_start", "{\"name\":\"Shibo\", \"sex\":1, \"id\":1}");
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        producer.send(record);

        tableEnv.executeSql("SELECT * FROM MyKafkaTable1");

        tableEnv.connect(new Kafka().version("universal").topic("quick_start").startFromLatest().property("bootstrap.servers", "124.222.201.62:9092"))
                .withFormat(new Json())
                .withSchema( new Schema()  // 定义表结构
                        .field("name", "STRING")
                        .field("age", "INT")
                        .field("id", "INT"))
                .createTemporaryTable("MyKafkaTable2");
        ProducerRecord<String, String> record_back = new ProducerRecord<>("quick_start", "{\"name\":\"xuchu\", \"age\":1, \"id\":1}");
        KafkaProducer<String, String> producer_back = new KafkaProducer<>(properties);
        producer_back.send(record_back);

        env.execute("insert into KafkaTable1");
    }
}

999.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>org.example</groupId>
    <artifactId>data-preprocess</artifactId>
    <version>1.0-SNAPSHOT</version>

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

    <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>1.1.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>jline</artifactId>
                    <groupId>jline</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>avro</artifactId>
                    <groupId>org.apache.avro</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>log4j</artifactId>
                    <groupId>log4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-compress</artifactId>
                    <groupId>org.apache.commons</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>avro</artifactId>
                    <groupId>org.apache.avro</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.1.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>antlr-runtime</artifactId>
                    <groupId>org.antlr</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-compress</artifactId>
                    <groupId>org.apache.commons</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-lang</artifactId>
                    <groupId>commons-lang</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-httpclient</artifactId>
                    <groupId>commons-httpclient</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.0.5</version>
            <exclusions>
                <exclusion>
                    <artifactId>zookeeper</artifactId>
                    <groupId>org.apache.zookeeper</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-codec</artifactId>
                    <groupId>commons-codec</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>commons-io</artifactId>
                    <groupId>commons-io</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>hadoop-auth</artifactId>
                    <groupId>org.apache.hadoop</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>hadoop-common</artifactId>
                    <groupId>org.apache.hadoop</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>2.0.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>

        <!--解析mysql binlog-->
        <dependency>
            <groupId>com.github.shyiko</groupId>
            <artifactId>mysql-binlog-connector-java</artifactId>
            <version>0.21.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.8.2</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>2.4.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>zookeeper</artifactId>
                    <groupId>org.apache.zookeeper</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>snappy-java</artifactId>
                    <groupId>org.xerial.snappy</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>  <!-- 请使用最新的版本 -->
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>1.13.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>1.13.2</version>
            <exclusions>
                <exclusion>
                    <artifactId>snappy-java</artifactId>
                    <groupId>org.xerial.snappy</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 如果你的项目使用了 Scala，你也需要添加 Scala 标准库的依赖 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>2.12.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-compress</artifactId>
            <version>1.21</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.12</artifactId>
            <!--替换成相应的flink版本-->
            <version>1.13.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.12</artifactId>
            <version>1.13.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.12</artifactId>
            <version>1.13.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.12</artifactId>
            <version>1.13.0</version>
        </dependency>

    </dependencies>


</project>
Big_Data_Record
关注
【大数据Flink系列】Flink 核心概念综述
weixin_54707168的博客
04-03 437
【大数据Flink系列】Flink 核心概念综述
Flink写入Kafka
weixin_45264992的博客
10-12 1885
Flink写入Kafka import org.apache.flink.api.common.serialization.SimpleStringSchema; import org.apache.flink.streaming.api.datastream.DataStreamSource; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.flink.strea
flink与kafka基础知识
最新发布
2403_83630621的博客
07-31 874
Flink是一个分布式实时计算框架。用于在无边界和有边界数据流上进行有状态的计算。Flink 能在所有常见集群环境中运行，并能以内存速度和任意规模进行计算。有状态：有状态计算是将当前批次结果加上上一批次计算的结果。无界流有定义流的开始，但没有定义流的结束(没有边界)。它们会无休止地产生数据。流处理。有界流有定义流的开始，也有定义流的结束。有界流(假如1000条数据)，即可批处理(一次处理一批)，也可以流处理(一条一条处理)。任意规模进行计算：指的是flink主从节点。jobmanager:driver端。
Flink入门，flink接入kafka数据源，消费数据并处理数据
荒野拖拉机
05-23 2778
构建时会提示找不到类，在idea中勾选如图选项，或者在pom文件中修改scope的值为compile。消费者可以收到消息，kafka安装完成，如果没有收到可以检查topic是否一致，ip是否正确。首先先下载kafka的linux版本，可以搜索阿里云的镜像进行下载，速度很快。将文件中的listeners注释去掉，并修改值为你虚拟机的ip，如下图。最后运行新的消费者，消费处理后的数据，只需修改topic。然后运行代码，在生产者生产一条数据进行查看。启动生产者服务，bin目录下。安装过程可自行搜索。
Flink Kafka
u012485099的博客
01-14 2755
如自定义 KafkaSerializationSchema。且调用 FlinkKafkaProducer(String defaultTopic,KafkaSerializationSchema serializationSchema,Properties producerConfig,FlinkKafkaProducer.Semantic semantic) 构造器。此时分区器为null。此时依次调用了方法。send方法为kafka的发送方法。
Flink Java操作Kafka
技术札记
06-21 3092
0.8 kafka版本 2.11 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka-0.8_2.11</artifactId> <version>1.8.0</version> </de...
kafka maven 依赖_Flink的sink实战之二：kafka
weixin_39692623的博客
11-22 491
本文是《Flink的sink实战》系列的第二篇，《Flink的sink实战之一：初探》对sink有了基本的了解，本章来体验将数据sink到kafka的操作；版本和环境准备本次实战的环境和版本如下：JDK：1.8.0_211Flink：1.9.2Maven：3.6.0操作系统：macOS Catalina 10.15.3 (MacBook Pro 13-inch, 2018)IDEA：2018.3....
Flink消费Kafka数据1
08-03
操作系统为 Centos 7.6，Hadoop 版本为 hadoop-2.7.7，JDK 版本为 jdk-1.8.0，Flink 版本为 flink-1.8.0，Zookeeper 版本为 zookeeper-3.4.12，Kafka 版本为 kafka_2.10-0.8.2.1。 二、资源购买 在本实验中，我们...
flink消费kafka到greenplum
05-06
2. **定义数据转换**：Flink的DataStream API提供了丰富的操作，如map、filter、keyBy和window，可以对数据进行清洗、过滤、聚合等处理。 3. **应用窗口**：在实时数据处理中，窗口是一种重要的概念，允许我们在...
Flink+Kafka的JavaAPI应用
05-30
此案例使用的是IDEA开发工具，项目...使用JavaAPI操作Flink的流处理，Flink从Kafka中获取数据，执行处理后再执行输出。 根据（《Flink入门与实战》徐葳著）教材最后的综合案例改变，适合没有学习不会使用Flume的人使用
Flink 读写Kafka总结
主要分享大数据相关的知识，如Spark、Hudi
07-05 2017
总结Flink读写Kafka。
flink读取kafka数据.zip
01-04
本项目涉及的关键技术包括Flink与Kafka的集成、数据计算后的存储以及流式数据导入MySQL。以下是这些技术的详细说明： 1. **Flink 读取 Kafka 数据**： Apache Kafka 是一个分布式流处理平台，用于构建实时数据管道...
flink 写kafka_Flink1.9整合Kafka实战
weixin_26841743的博客
12-27 2174
大数据技术与架构点击右侧关注，大数据开发领域最强公众号！暴走大数据点击右侧关注，暴走大数据！本文基于Flink1.9版本简述如何连接Kafka。流式连接器我们知道可以自己来开发Source 和 Sink ，但是一些比较基本的 Source 和 Sink 已经内置在 Flink 里。预定义的source支持从文件、目录、socket，以及 collections 和 iterators 中...
Flink Flink数据写入Kafka
文文x的博客
12-06 2276
flink官方集成了通用的 Kafka 连接器，使用时需要根据生产环境的版本引入相应的依赖。通过socket模拟数据写入Flink之后，Flink将数据写入Kafka。
flink将数据写入到kafka
congge_study的博客
01-15 4564
flink将数据写入到kafka
Flink流式处理集成kafka
chongfa2008的博客
07-13 1864
1：引言 对于实时处理当中，我们实际工作当中的数据源一般都是使用kafka，所以我们一起来看看如何通过Flink来集成kafka Flink提供了一个特有的kafka connector去读写kafka topic的数据。flink消费kafka数据，并不是完全通过跟踪kafka消费组的offset来实现去保证exactly-once的语义，而是flink内部去跟踪offset和做checkpoint去实现exactly-once的语义，而且对于kafka的partiti...
Flink（十九）—— Flink 写入数据到 Kafka
weixin_42073629的博客
10-15 3095
前言 之前文章—— Flink 写入数据到 ElasticSearch写了如何将 Kafka 中的数据存储到 ElasticSearch 中，里面其实就已经用到了 Flink 自带的 Kafka source connector（FlinkKafkaConsumer）。存入到 ES 只是其中一种情况，那么如果我们有多个地方需要这份通过 Flink 转换后的数据，是不是又要我们继续写个 sink 的插件呢？确实，所以 Flink 里面就默认支持了不少 sink，比如也支持 Kafka sink conn..
Flink与Kafka集成
AI天才研究院
01-18 3627
1.背景介绍 Flink与Kafka集成是一种常见的大数据处理技术，它可以帮助我们实现实时数据处理和分析。Flink是一个流处理框架，可以处理大量数据并提供实时分析功能。Kafka是一个分布式消息系统，可以用于构建实时数据流管道。在本文中，我们将深入了解Flink与Kafka集成的背景、核心概念、算法原理、代码实例等方面。 1.1 Flink的背景 Flink是一个开源的流处理框架，由Apa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值