Flink操作Kafka教程

已于 2023-10-20 10:11:21 修改
阅读量502 收藏 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
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Flink入门：读取Kafka实时数据流，实现WordCount
01-07
本文主要介绍Flink接收一个Kafka文本数据流，进行WordCount词频统计，然后输出到标准输出上。通过本文你可以了解如何编写和运行Flink程序。 代码拆解 首先要设置Flink的执行环境： // 创建Flink执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 设置Kafka相关参数，连接对应的服务器和端口号，读取名为Shakespeare的Topic中的数据源，将数据源命名为stream： // Kafka参数 Properties propert
Flink消费Kafka数据1
08-03
1. 实验环境 2. 资源购买 3. 开始实验
Flink借助Kafka实现端到端精准一次_flink 如何保障数据一致性(1)
2401_84160361的博客
04-15 870
那么在检查点保存的时候，系统故障，保存检查点失败，那么恢复检查点的时候，恢复的是上次成功保存检查点的数据偏移量，如果不对新数据进行保护，可能就会把之前有可能。
flink读取kafka数据存储iceberg
MY博客
08-08 969
使用flink实时的读取kafka的数据，并且实时的存储到iceberg中。
Flink入门，flink接入kafka数据源，消费数据并处理数据
最新发布
荒野拖拉机
05-23 421
构建时会提示找不到类，在idea中勾选如图选项，或者在pom文件中修改scope的值为compile。消费者可以收到消息，kafka安装完成，如果没有收到可以检查topic是否一致，ip是否正确。首先先下载kafka的linux版本，可以搜索阿里云的镜像进行下载，速度很快。将文件中的listeners注释去掉，并修改值为你虚拟机的ip，如下图。最后运行新的消费者，消费处理后的数据，只需修改topic。然后运行代码，在生产者生产一条数据进行查看。启动生产者服务，bin目录下。安装过程可自行搜索。
流批一体计算引擎-4-[Flink]消费kafka实时数据
qq_20466211的博客
01-23 2748
flink消费kafka
Flink、Kafka梳理
xiaochen_bigdata的博客
02-16 7669
flink和kafka梳理
flink与kafka结合示例
热门推荐
feinifi的博客
11-15 2万+
flink作为实时流处理平台，可以与kafka很好地结合。 因为flink流处理的特点，需要source和sink作为流处理的源头和终端。与kafka的结合，可以让flink作为生产者，不断的向kafka消息队列中产生消息。这个作为今天的第一个示例。对应下图的场景。 还有一种情况，让flink作为kafka的消费者，读取消息队列中的消息，然后做处理。这时候flink的与kafka的角色发生了变化，对应下图的场景。 根据以上的两种情况，我们来编写相...
flink+kafka实例
whandgdh的博客
07-05 1471
1、kafka集群搭建2、java工程部署3、创建主类 FlinkReadKafka4、启动 zk5、启动 kafka 集群6、创建topic7、运行代码8、创建生产者和消费者 1、kafka集群搭建 zookeeper集群以及kafka集群搭建详见博客：kafka集群搭建。只是本文将kafka版本升级为0.11.0.3。 2、java工程部署 java maven 工程大部署详见基于flink实现的worldcount，本位只需要讲maven 工程pom配置文件增加 kafka 连接器 3、创建主类 .
kafka和flink的入门到精通 2 系统架构，实时数仓架构，Kafka
水w的博客
09-19 1329
kafka和flink的入门到精通 2 系统架构，实时数仓架构，Kafka
6.2、Flink数据写入到Kafka
向热爱自己一样，热爱这个世界。
09-13 2062
Flink数据写入到Kafka
flink消费kafka到greenplum
05-06
flink消费kafka到greenplum， 以及flink datastream,dataset 使用等，实时数据库读取，存储到greenplum，应用窗口等实战例子
Flink+Kafka的JavaAPI应用
05-30
此案例使用的是IDEA开发工具，项目...使用JavaAPI操作Flink的流处理，Flink从Kafka中获取数据，执行处理后再执行输出。 根据（《Flink入门与实战》徐葳著）教材最后的综合案例改变，适合没有学习不会使用Flume的人使用
flink-kafka-connector
03-26
DataStream API目前支持设定kafka的结束消费位置setBounded(setUnbounded)，我使用的是Table API,目前并不支持设置结束位置，只能自定义的flink-kafka连接器，可设定消费kafka的开始和结束位置，可以在批任务的情况...
Flink+Kafka搭建流式处理框架（内涵docker部署脚本和k8s多副本部署脚本）
11-03
flink搭配kafka，构建流式采集框架，提供了docker部署方式脚本和k8s多副本方式部署脚本
Flink Java操作Kafka
技术札记
06-21 3052
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...
Flink流式处理集成kafka
chongfa2008的博客
07-13 1796
1：引言 对于实时处理当中，我们实际工作当中的数据源一般都是使用kafka，所以我们一起来看看如何通过Flink来集成kafka Flink提供了一个特有的kafka connector去读写kafka topic的数据。flink消费kafka数据，并不是完全通过跟踪kafka消费组的offset来实现去保证exactly-once的语义，而是flink内部去跟踪offset和做checkpoint去实现exactly-once的语义，而且对于kafka的partiti...
轻松通关Flink第24讲：Flink 消费 Kafka 数据业务开发
sucaiwa的博客
03-28 4429
这一课时介绍了 Flink 消费 Kafka 的方式，比如从常用的指定单个或者多个 Topic、消息的序列化、分区的动态发现等，还从源码上介绍了 Flink 消费 Kafka 的原理。通过本课时的学习，相信你可以对 Flink 消费 Kafka 有一个较为全面地了解，根据业务场景可以正确选择消费的方式和配置。
【FLINK】Kafka数据源通过Flink-cdc进行实时数据同步
weixin_37788200的博客
06-11 2414
通过flink-cdc实现kafka数据源的数据实时同步到目标数据库，并对目标库进行增删改操作
flink sink kafka
03-31
Flink Sink Kafka is a connector provided by Apache Flink that allows Flink to write data to Apache Kafka. Apache Kafka is a distributed streaming platform that is used for building real-time data pipelines and streaming applications. Using Flink Sink Kafka, one can easily write data from Flink to Kafka topics. Flink Sink Kafka provides various features such as configurable producer properties, support for serializing data using different formats such as Avro, JSON, and Protobuf, and support for writing data to multiple topics within a Kafka cluster. Using Flink Sink Kafka, one can build a real-time streaming application that processes data and writes it to Kafka topics, which can then be consumed by other applications or services. This allows for building complex data processing pipelines that can handle large volumes of data in real-time.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值