flink cdc 实现实时msyql字段统计

最新推荐文章于 2023-07-13 19:15:05 发布
最新推荐文章于 2023-07-13 19:15:05 发布
阅读量3.2k 收藏 3
点赞数 1
分类专栏： flink 文章标签： flink flink cdc mysql 实时统计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44745147/article/details/124131727
版权

需求描述

最近需要将mysql数据库的某个表中的一个状态信息统计结果并实时显示到数据大屏上

思路

首先使用flinkcdc监听mysql中的特定表
然后编写一定的处理逻辑得出结果数据
将结果数据通过flink写入到mysql的结果表中

技术选型

  • java 1.8
  • mysql 8.0.28
  • flink 1.11.3
  • flink cdc 1.1.0

实现

数据

order_info表（需要处理的数据）
在这里插入图片描述

flink_count表（结果数据）
在这里插入图片描述

java代码

pom文件
这里面没有必要这么多

<?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>com.antg</groupId>
    <artifactId>TestFlinkCDC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
        <flink.version>1.11.3</flink.version>
        <scala.binary.version>2.11</scala.binary.version>
        <log4j.version>2.17.0</log4j.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-jdbc_2.11</artifactId>
            <version>1.11.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.elasticsearch.client/transport -->


        <dependency>
            <groupId>com.alibaba.ververica</groupId>
            <!-- add the dependency matching your database -->
            <artifactId>flink-connector-mysql-cdc</artifactId>
            <version>1.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-common</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-core</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1-jre</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-hive_2.11</artifactId>
            <version>1.11.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-sql-connector-hive-1.2.2_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-parquet_2.11</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.2.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-jdbc</artifactId>
            <version>1.2.2</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.orc</groupId>
            <artifactId>orc-core</artifactId>
            <version>1.4.3</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-orc_2.11</artifactId>
            <version>1.11.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.1</version>
        </dependency>
    </dependencies>


</project>

目录结构
在这里插入图片描述

Demo01.java

package com.antg.main;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.ververica.cdc.connectors.mysql.MySQLSource;
import com.antg.entity.FlinkCount;
import com.antg.sink.OutputSkin;
import com.antg.deserialization.MyDeserialization;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.util.Collector;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        //创建监听的数据源
        SourceFunction<String> sourceFunction = MySQLSource.<String>builder()
                .hostname("127.0.0.1")
                .port(3306)
//                .databaseList("test") // 监听test数据库下的所有表
                .tableList("test.order_info") //这里一定要带库名，因为上面可以同时监听多个库，会有不同库相同表名的情况
                .username("root")
                .password("123456")
                .deserializer(new MyDeserialization()) // 将SourceRecord 转换成 String形式
                .build();
        //获取运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //开始监听数据,并将动态数据变化打印到屏幕中
        DataStreamSource<String> ds = env.addSource(sourceFunction);
        SingleOutputStreamOperator<FlinkCount> res = ds
                .flatMap(new FlatMapFunction<String, Tuple2<String, Long>>() {
                    @Override
                    public void flatMap(String line, Collector<Tuple2<String, Long>> out) throws Exception {
                        //将字符串转json
                        JSONObject item = (JSONObject) JSON.parse(line);
                        String before = item.getJSONObject("before").getString("order_state");
                        String after = item.getJSONObject("after").getString("order_state");
                        //创建和读取情况
                        if (item.getString("op").equals("create") || item.getString("op").equals("read")) {
                            out.collect(new Tuple2<String, Long>(after, 1L));
                        //更新情况
                        } else if (item.getString("op").equals("update")) {
                            //如果是别的字段做更新操作数据不变
                            if(before.equals(after)){
                                return;
                            }
                            if (after.equals("a")) {
                                out.collect(new Tuple2<String, Long>("a", 1L));
                                out.collect(new Tuple2<String, Long>("b", -1L));
                            } else {
                                out.collect(new Tuple2<String, Long>("a", -1L));
                                out.collect(new Tuple2<String, Long>("b", 1L));
                            }
                        //删除数据情况
                        } else if (item.getString("op").equals("delete")) {
                            out.collect(new Tuple2<String, Long>(before, -1L));
                        }
                        //还可以加别的情况，比如delete_flag标志做假删除
                    }
                })
                .keyBy(0)
                .sum(1)
                .map(new MapFunction<Tuple2<String, Long>, FlinkCount>() {
                    @Override
                    public FlinkCount map(Tuple2<String, Long> value) throws Exception {

                        FlinkCount res = new FlinkCount();
                        res.setOrderState(value.f0);
                        res.setCount(value.f1);
                        return res;
                    }
                });
        //向数据库输出数据
        res.addSink(new OutputSkin());
        //ds.print();

        //开始执行任务
        env.execute();
    }
}

MyDeserialization.java

package com.antg.deserialization;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.ververica.cdc.debezium.DebeziumDeserializationSchema;
import io.debezium.data.Envelope;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.util.Collector;
import org.apache.kafka.connect.data.Field;
import org.apache.kafka.connect.data.Struct;
import org.apache.kafka.connect.source.SourceRecord;

public class MyDeserialization implements DebeziumDeserializationSchema<String> {
    @Override
    public void deserialize(SourceRecord sourceRecord, Collector<String> collector) throws Exception {
        //获取主题信息,包含着数据库和表名
        String topic = sourceRecord.topic();
        String[] arr = topic.split("\\.");
        String db = arr[1];
        String tableName = arr[2];
        //获取操作类型 READ DELETE UPDATE CREATE
        Envelope.Operation operation =
                Envelope.operationFor(sourceRecord);
        //获取值信息并转换为 Struct 类型
        Struct value = (Struct) sourceRecord.value();

        //得到变化之前的数据
        Struct before = value.getStruct("before");
        JSONObject beforeJson = new JSONObject();
        if(before != null){
            for (Field field : before.schema().fields()) {
                Object o = before.get(field);
                beforeJson.put(field.name(), o);
            }

        }
        //得到变化后的数据
        Struct after = value.getStruct("after");
        //创建 JSON 格式的数据对象用于存储数据信息
        JSONObject afterJson = new JSONObject();
        if(after != null){
            for (Field field : after.schema().fields()) {
                Object o = after.get(field);
                afterJson.put(field.name(), o);
            }
        }
        //创建 JSON 格式的数据对象，用于封装最终返回值数据信息
        JSONObject result = new JSONObject();
        result.put("op", operation.toString().toLowerCase());
        result.put("before", beforeJson);
        result.put("after", afterJson);
        result.put("db", db);
        result.put("table", tableName);
        //发送数据给下游
        collector.collect(result.toJSONString());
    }

    @Override
    public TypeInformation<String> getProducedType() {
        return TypeInformation.of(String.class);
    }
}

OutputSkin.java

package com.antg.sink;

import com.antg.entity.FlinkCount;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class OutputSkin extends RichSinkFunction<FlinkCount> {
    Connection connection;
    PreparedStatement pstmt;

    //获取数据库链接信息
    private Connection getConnection(){
        Connection conn = null;
        try{
            Class.forName("com.mysql.jdbc.Driver");//将mysql驱动注册到DriverManager中去

            String url = "jdbc:mysql://localhost:3306/test";//数据库路径

            conn = DriverManager.getConnection(url,"root","123456");//数据库链接信息

        }catch (Exception e){
            e.printStackTrace();
        }
        return  conn;
    }


    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);

        connection = getConnection();
        String sql = "update flink_count set num=? where order_state=?";
        pstmt = connection.prepareStatement(sql);
    }

    //每条记录插入时调用一次
    @Override
    public void invoke(FlinkCount value, Context context) throws Exception {
        //为前面的占位符赋值
        pstmt.setString(2,value.getOrderState());
        pstmt.setLong(1,value.getCount());
        pstmt.executeUpdate();
    }

    @Override
    public void close() throws Exception {
        super.close();

        if(pstmt != null){
            pstmt.close();
        }

        if (connection != null){
            connection.close();
        }
    }
}

FlinkCount.java

package com.antg.entity;

import lombok.Data;

@Data
public class FlinkCount {
    private String orderState;
    private Long count;
}

实现效果

当order_info表中的order_state数据发送了变化的时候flink_count表中的数据会动态的变化
比如新加了一条数据，那么结果表中也会相应的累计到对于的状态上
如果删掉了一条数据，结果表会发生变化
如果是a状态变成了b或者b变成了a，结果表也会发送变化
但是如果是别的字段发生变化，结果表不变

总结

flinkcdc初体验，很厉害的一个组件，有空研究一下底层的实现逻辑
以上代码有问题欢迎评论区留言

Antgeek
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
Flink CDC 实时同步mysql
congge
03-23 3万+
Flink CDC 实时同步mysql数据
flink系列之：flink cdc实时从mysql数据库获取数据
zhengzaifeidelushang的博客
01-13 2679
flink系列之：flink cdc实时从mysql数据库获取数据一、flink cdc获取的数据格式二、pom.xml三、flink cdc完整程序代码 一、flink cdc获取的数据格式 二、pom.xml <dependencies> <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-java
FlinkSQL 实时采集Kafka内容到MySQL（实战记录）
阿甘兄
03-31 5841
文章目录01 引言02 实现2.1 添加依赖2.2 Flink SQL2.3 配置Kafka域名03 文末 01 引言 最近在做实时采集Kafka发布的内容到MySQL，本文记录一下关键的点，细节不再描述，希望能帮助到大家。 02 实现 2.1 添加依赖 在工程，除了添加基础的Flink环境依赖，还需要添加flink-connector-kafka的依赖： <dependency> <groupId>org.apache.flink</groupId> &
Flink1.14.3 Table读写MySQL做数据聚合(1)
大数据研习社
04-28 2635
摘要 使用JDBC SQL Connector，Source只支持批处理，Sink支持批处理和流处理。 Sink支持数据追加和更新，如果Flink Table API做聚合操作，使用Sink必须指定指定主键。 本案例独家使用Flink Table API（非SQL）方式读写MySQL，官网只讲解了SQL的使用方式。 1 需求 需求：Flink Table API从MySQL读取数据，然后做聚合操作，最后将聚合结果写入MySQL。 2 添加Maven依赖 FlinkTable集成My.
Flink CDC MySQL同步MySQL（一）
07-06
jdbc
flink mysql cdc 2.3 编译版本兼容flink1.4.x
09-01
只兼容mysql
mysql实时同步pg
最新发布
01-17
在这个场景中，我们将使用Flink CDC来实现MySQL到PostgreSQL的实时数据同步。 首先，我们需要配置源数据库和目标数据库的信息。在MySQL端，我们需要指定要同步的数据库和表，以及MySQL的连接信息。在PostgreSQL端，...
基于Flink CDC使用datastream方式全量增量同步mysql to mysql
03-04
基于Flink CDC使用datastream方式全量增量同步mysql to mysql 使用的是java语言，只需配置完源数据库和目标数据库信息，运行MysqlCDC中的main函数，即可实现多库多表同步。
利用Flink-CDC和flink-doris-connector技术实现Mysql数据全量或增量同步至Doris
weixin_43914798的博客
05-14 5739
简介 Flink CDC： ​ 解决了传统数据库实时同步的痛点， 该技术抛弃了其他第三方组件（例如Kafka等），能够实时读取Mysql master节点全量和增量数据，能够捕获所有数据的变化，同时它完全与业务解耦，运维也及其简单。具体介绍请参考：Flink_CDC搭建及简单使用 及 flink-cdc-connectors。 Apache Doris： 它是一个现代化的MPP分析型数据库产品。仅需亚秒级响应时间即可获得查询结果，有效地支持实时数据分析。Apache Doris的分布式架构非常
flink-cdc之读取mysql变化数据
cclovezbf的博客
07-13 1523
由于打印的日志太多 我们可以用fastjson稍微封装下 然后传给sink去处理，根据update delete insert实时更新下游数据。修改一条数据 age=1 ->age=2。
Flink系列之：使用Flink Mysql CDC基于Flink SQL同步mysql数据到StarRocks数据库
zhengzaifeidelushang的博客
01-29 1055
Flink系列之：使用Flink Mysql CDC基于Flink SQL同步mysql数据到StarRocks数据库
FlinkCDC-Hudi:Mysql数据实时入湖全攻略五：FlinkSQL同时输出到kafka与hudi的几种实现
m0_66705151的博客
02-22 3146
一文告诉你如何在FlinkSQL中实现一个作业多路输出。
Flink实时统计入MySQL
数据人生
01-14 3408
先上代码片段 import java.sql.Types import java.text.SimpleDateFormat import java.util.Date import org.apache.flink.api.java.io.jdbc.JDBCOutputFormat import org.apache.flink.api.scala._ import org.apache...
Flink 系例 之 TableAPI & SQL 与 MYSQL 分组统计
jilo88的博客
06-29 858
使用 Tbale&SQL 与 Flink JDBC 连接器读取 MYSQL 数据，并用 GROUP BY 语句根据一个或多个列对结果集进行分组。
Flink CDC 系列（3）—— Flink CDC MySQL Connector 与 Flink SQL 的结合使用案例Demo
修破立生
02-22 4934
本文以案例的形式演示了 Flink CDC MySQL Connector 的使用。包括 MySQL 测试数据的准备、Flink CDC 源码编译、Flink 集群启动、Flink CDC MySQL Connector 与 Flink SQL 的结合使用。
伴鱼基于 Flink 构建数据集成平台的设计与实现
Ververica的博客
12-07 483
▼ 关注「Apache Flink」，获取更多技术干货▼摘要：数据仓库有四个基本的特征：面向主题的、集成的、相对稳定的、反映历史变化的。其中数据集成是数据仓库构建的首要前提，指将多个分散...
java MySQL实时统计_java使用flink集成mybatis每五分钟实时计算小时内用户行为数据...
weixin_39903477的博客
02-07 1621
java使用flink集成mybatis每五分钟实时计算小时内用户行为数据目前在学习flink,写了一个比较常见的需求:每五分钟统计前一小时用户点击最多的商品,并且把源数据存入mysql.实现思路:使用滑动窗口 size 1h,间隔5分钟,使用商品作为keyby的分组,过滤掉不是点击的数据,aggregate函数来增量计算每一个商品被点击的数量 使用ProcessWindowFunction方法组...
[2] Flink大数据流式处理利剑: 用Flink进行统计的一个简单例子
超越梦想，一起飞！！！
12-27 2127
上面一节博客<<[1] Flink大数据流式处理利剑: 简介>>, 整体描述了Flink是什么，能做什么，其主要架构是什么，已经笔者也提供了一些经典案例的链接在案例参考章节，现在笔者就提供一个简单的用Flink来统计字符出现频率的例子。下面是具体的步骤。 第一步安装JDK环境： 请网上搜索 第二步，安装Maven 第三步，用archetype:generate 生成一个模板代码 mvn archetype:generate -DarchetypeGroupId=org.apa
Flink CDC 在易车的应用实践.pdf
03-21
在实时数据应用方面，Flink CDC被用于构建实时数仓，实现数据的实时集成和传输，包括线索、流量等关键业务指标的实时监控。此外，它还支持实时大屏展示，如818购车节等活动的数据实时展现，确保了业务决策的及时性和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Antgeek

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值