Flink两阶段提交Mysql（连接池生产稳定运行版本）

最新推荐文章于 2025-03-04 21:18:01 发布
最新推荐文章于 2025-03-04 21:18:01 发布
阅读量2.1k 收藏 20
点赞数 7
文章标签： flink 大数据 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43403113/article/details/124278149
版权

Flink两阶段提交Mysql

前言

目前大多数网上能搜索到的关于flink两阶段提交的内容大多雷同，均为直接对连接进行序列化，并且由单一的直接连接的方式处理。本文章结合网上的部分代码进行优化，解决了使用连接池各种异常的问题，并且处理好了单纯序列化连接带来的弊端，经过笔者生产在线跑数稳定无异常。

一、关键代码

1.主类

package com.baidu.twoPhaseCommit.twoPC;

import com.baidu.twoPhaseCommit.sink.MysqlSinkPlus;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.runtime.state.filesystem.FsStateBackend;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.CheckpointConfig;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

/**
 * @author Mu
 * @ClassName MysqlTwoPhaseCommit
 * @Description flink to mysql 两阶段提交代码
 * @date 2022/4/14 10:01
 * @Version 1.0
 */
public class MysqlTwoPhaseCommit {
    //topic
    private static final String topic_ExactlyOnce = "TwoPhaseCommit";
    private static final String group_id = "TwoPhaseCommitConsumer";
    private static final String bootstrap_servers = "HM-DATA04:9092,HM-DATA05:9092,HM-DATA06:9092";
    private static final String statebackend_address = "file:///D:/code/wangmu/test/ckeckpoint";

    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置并行度,为了方便测试，查看消息的顺序，这里设置为1，可以更改为多并行度
        env.setParallelism(1);
        //checkpoint的设置
        //每隔10s进行启动一个检查点【设置checkpoint的周期】
        env.enableCheckpointing(10000);
        //设置模式为：exactly_one，仅一次语义
        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);
        //确保检查点之间有1s的时间间隔【checkpoint最小间隔】
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(1000);
        //检查点必须在10s之内完成，或者被丢弃【checkpoint超时时间】
        env.getCheckpointConfig().setCheckpointTimeout(10000);
        //同一时间只允许进行一次检查点
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);
        //表示一旦Flink程序被cancel后，会保留checkpoint数据，以便根据实际需要恢复到指定的checkpoint
        env.getCheckpointConfig().enableExternalizedCheckpoints(CheckpointConfig.ExternalizedCheckpointCleanup.RETAIN_ON_CANCELLATION);
        //设置statebackend,将检查点保存在hdfs上面，默认保存在内存中。这里先保存到本地
        env.setStateBackend(new FsStateBackend(statebackend_address));


        //设置kafka消费参数
        Properties properties = new Properties();
        properties.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrap_servers);
        properties.setProperty(ConsumerConfig.GROUP_ID_CONFIG, group_id);

        /*SimpleStringSchema可以获取到kafka消息，JSONKeyValueDeserializationSchema可以获取都消息的key,value，metadata:topic,partition，offset等信息*/
        FlinkKafkaConsumer<String> kafkaConsumer011 = new FlinkKafkaConsumer<>(
                topic_ExactlyOnce,
                new SimpleStringSchema(),
                properties);

        //加入kafka数据源
        DataStreamSource<String> streamSource = env.addSource(kafkaConsumer011);

        SingleOutputStreamOperator<Tuple2<String, Integer>> tupleStream = streamSource.map(str -> Tuple2.of(str, 1)).returns(Types.TUPLE(Types.STRING, Types.INT));

        tupleStream.print();
        //数据传输到下游
        tupleStream.addSink(new MysqlSinkPlus()).name("MySqlTwoPhaseCommitSink");
        //触发执行
        env.execute("Kafka2MysqlDemo");
    }
}

2.自定义sink

package com.baidu.twoPhaseCommit.sink;

import com.baidu.twoPhaseCommit.util.HikariUtil;
import org.apache.flink.api.common.ExecutionConfig;
import org.apache.flink.api.common.typeutils.base.VoidSerializer;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.typeutils.runtime.kryo.KryoSerializer;
import org.apache.flink.streaming.api.functions.sink.TwoPhaseCommitSinkFunction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.PreparedStatement;
import java.sql.Timestamp;

/**
 * @author Mu
 * @ClassName MysqlSinkPlus
 * @Description TODO
 * @date 2022/4/14 10:03
 * @Version 1.0
 */
public class MysqlSinkPlus extends TwoPhaseCommitSinkFunction<Tuple2<String,Integer>, HikariUtil,Void> {
    private static final Logger log = LoggerFactory.getLogger(MysqlSinkPlus.class);

    public MysqlSinkPlus() {
        super(new KryoSerializer<>(HikariUtil.class,new ExecutionConfig()), VoidSerializer.INSTANCE);
    }
    /**
     * 执行数据库入库操作  task初始化的时候调用
     * @param hikariUtil
     * @param tuple
     * @param context
     * @throws Exception
     */
    @Override
    protected void invoke(HikariUtil hikariUtil, Tuple2<String, Integer> tuple, Context context) throws Exception {
        log.info("start invoke...");
        String value = tuple.f0;
        Integer total = tuple.f1;
        String sql = "insert into `t_test` (`value`,`total`,`insert_time`) values (?,?,?)";
        log.info("====执行SQL:{}===",sql);
        PreparedStatement ps = hikariUtil.getconn().prepareStatement(sql);
        ps.setString(1, value);
        ps.setInt(2, total);
        ps.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
        log.info("要插入的数据:{}----{}",value,total);
        if (ps != null) {
            String sqlStr = ps.toString().substring(ps.toString().indexOf(":")+2);
            log.error("执行的SQL语句:{}",sqlStr);
        }
        //执行insert语句
        ps.execute();
    }
    /**
     * 获取连接，开启手动提交事物（getConnection方法中）
     * @return
     * @throws Exception
     */
    @Override
    protected HikariUtil beginTransaction() throws Exception {
        log.info("start beginTransaction.......");
        return new HikariUtil();
    }
    /**
     *预提交，这里预提交的逻辑在invoke方法中
     * @param hikariUtil
     * @throws Exception
     */
    @Override
    protected void preCommit(HikariUtil hikariUtil) throws Exception {
        log.info("start preCommit...");
    }
    /**
     * 如果invoke方法执行正常，则提交事务
     * @param hikariUtil
     */
    @Override
    protected void commit(HikariUtil hikariUtil) {
        log.info("start commit...");
        hikariUtil.commit();
    }
    /**
     * 如果invoke执行异常则回滚事物，下一次的checkpoint操作也不会执行
     * @param hikariUtil
     */
    @Override
    protected void abort(HikariUtil hikariUtil) {
        log.info("start abort rollback...");
        hikariUtil.rollback();
    }
}

3.连接池工具类

package com.baidu.twoPhaseCommit.util;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.sql.DataSource;
import java.io.FileReader;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Objects;
import java.util.Properties;

/**
 * @author Mu
 * @ClassName HikariUtil
 * @Description JDBC工具类，使用HikariCP做连接池
 * @date 2022/4/18 14:21
 * @Version 1.0
 */
public class HikariUtil {
    private static final Logger log = LoggerFactory.getLogger(HikariUtil.class);
    private final static HikariUtil HIKARI_CP_UTI = new HikariUtil();

    private static Properties properties = null;
    private static HikariDataSource dataSource = null;
    private static transient Connection conn = null;

    //1.单例模式中,应该创建私有构造方法
    public HikariUtil() {}

    /**
     * 1.配置和获取数据库连接配置信息
     * 2.扩展HikariCP功能,进行配置
     * 3.获取数据库连接,提供对外获取数据库资源的方法
     */
    private void initConfig() throws IOException {
        String filePath = Objects.requireNonNull(HikariUtil.class.getClassLoader().getResource("hikaricp.properties")).getFile();
        FileReader fileReader = new FileReader(filePath);
        properties = new Properties();
        properties.load(fileReader);
        properties.forEach((k, v) -> {
            log.debug(String.format("key:%s value:%S", k, v));
        });
        log.info("初始化配置文件成功.....");
    }

    /**
     * 注册HikariCP
     */
    private void registerHikariCP() {
        if (null != dataSource) {
            return;
        }
        HikariConfig config = new HikariConfig(properties);
        dataSource = new HikariDataSource(config);
    }

    /**
     * 提供对外 获取 HikariCPDatasource 的方法
     * @return
     */
    public static DataSource getHikariCPDataSource() {
        if (null != dataSource) {
            return dataSource;
        }
        try {
            HIKARI_CP_UTI.initConfig();
            HIKARI_CP_UTI.registerHikariCP();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

    /**
     * 提供对外链接
     */
    public static Connection getconn() {
        try {
            if(conn == null) {
                if (dataSource != null) {
                    conn = dataSource.getConnection();
                } else {
                    conn = getHikariCPDataSource().getConnection();
                }
            }
            //设置手动提交
            conn.setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 提交事务
     */
    public static void commit() {
        if (conn != null) {
            try {
                conn.commit();
            } catch (SQLException e) {
                log.error("提交事务失败,Connection:" + conn);
                e.printStackTrace();
            }
        }
    }

    /**
     * 事务回滚
     */
    public static void rollback() {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException e) {
                log.error("事务回滚失败,Connection:" + conn);
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭连接
     */
    public static void close() {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                log.error("关闭连接失败,Connection:" + conn);
                e.printStackTrace();
            }
        }
    }

}

二、配置文件

1.pom.xml

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <scala.binary.version>2.12</scala.binary.version>
        <flink.version>1.13.0</flink.version>
        <target.java.version>1.8</target.java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_2.12</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
            <exclusions>
                <exclusion>
                    <artifactId>log4j</artifactId>
                    <groupId>log4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>2.7.2</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>com.alibaba.ververica</groupId>
            <artifactId>flink-connector-mysql-cdc</artifactId>
            <version>1.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.ververica</groupId>
            <artifactId>flink-connector-oracle-cdc</artifactId>
            <version>2.1.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-jdbc_2.12</artifactId>
            <version>${flink.version}</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.12</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-scala-bridge_2.12</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-api-java-bridge_2.12</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- blink执行计划,1.11+默认的-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.12</artifactId>
            <version>1.12.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-common</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.15</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.15</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-nop</artifactId>
            <version>1.7.15</version>
            <type>jar</type>
        </dependency>

    </dependencies>

注意：由于我的项目中还还有其他程序代码，所以pom.xml配置文件有多余的依赖，自行排除即可

2.hikaricp.properties

driverClassName=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false&autoReconnect=true
username=root
password=123456

总结

文章主要根据网上已有的demo结合笔者自己的思考，生产测试运行稳定无异常。
文章主要参考如下：

1.https://www.jianshu.com/p/1df61bb6801e
2.https://blog.youkuaiyun.com/zc19921215/article/details/117934640

沐不木
关注
大数据Flink（一百二十三）：五分钟上手Flink MySQL连接器
Lansonli（蓝深李）的博客
09-21 1544
由于商品名称及商品价格数据存储在另一张维度表 dimension_table中，我们需要将结果视图和 dimension_table进行JOIN操作，并将「商品销售量」、「商品价格」相乘计算出「商品销售额」，并提取结果中的商品可读名称信息作为结果表。本场景将以阿里云实时计算Flink版为基础，使用Flink自带的MySQL Connector连接RDS云数据库实例，并以一个实时商品销售数据统计的例子尝试上手Connector的数据捕获、数据写入等功能。选中代码，点击调试，观察控制台的输出结果。
大数据Flink（一百二十二）：阿里云Flink MySQL连接器介绍
Lansonli（蓝深李）的博客
09-20 2020
MySQL CDC源表在正则匹配表名时，会将您填写的 database-name，table-name 通过字符串 \\.（VVR 8.0.1前使用字符.）连接成为一个全路径的正则表达式，然后使用该正则表达式和MySQL数据库中表的全限定名进行正则匹配。MySQL的CDC源表，即MySQL的流式源表，会先读取数据库的历史全量数据，并平滑切换到Binlog读取上，保证不多读一条也不少读一条数据。在读完chunk的数据之前，chunk的数据会先缓存在内存中，因此chunk 太大，可能导致内存OOM。
Flink两阶段提交
热门推荐
lisenyeahyeah的博客
05-17 1万+
文章目录两阶段提交 两阶段提交 何为EXACTLY_ONCE？ EXACTLY_ONCE简称EOS，每条输入消息只会影响最终结果一次，注意这里是影响一次，而非处理一次，Flink一直宣称自己支持EOS，实际上主要是对于Flink应用内部来说的，对于外部系统(端到端)则有比较强的限制 1.外部系统写入支持幂等性 2.外部系统支持以事务的方式写入 什么是两阶段提交？预提交+实际提交 flink里将两阶...
flink分布式事务 - 两阶段提交
最新发布
qq_41067796的博客
03-04 1504
两阶段提交协议是一种经典的分布式事务管理方案，在保证强一致性的同时也面临着性能和可靠性的挑战。通过深入理解其基础原理、实现流程、核心组件以及优化策略，我们可以更好地在实际应用中权衡一致性和性能的关系。尽管 2PC 存在一些局限性，但在要求严格一致性的场景中仍然是一个可靠的选择。未来的研究方向可能集中在如何进一步优化协议性能、减少阻塞性问题以及提高系统的可用性。
flink（八）两阶段提交（备份别人的）
李玉志的博客
12-23 1411
两阶段提交 在Flink的两阶段提交中，JobManager充当协调者，TaskManager中的Source、Operator、Sink充当参与者，他们之间的通信有Checkpoint触发，其中barrier是核心中的核心。两阶段提交是实现精确一次性语义的核心原理。其核心原理就是在Barrier对齐的情况下所有的算子都成功的完成了Checkpoint，就完成了真正的两阶段提交。 JobManager向Source发送Barrier，开始进入pre-Commit阶段，当只有内部状态时，pre-commit
flink的事务之两阶段提交
weixin_40809627的博客
04-14 4018
场景描述：两阶段提交（two-phase commit, 2PC）是最基础的分布式一致性协议，应用广泛。本文来介绍它的相关细节以及它在Flink中的典型应用场景。。
flink 两阶段提交协议 2pc
wppwpp1的专栏
12-31 760
1、pre-commit阶段：当checkpoint barrier在所有operator都传递了一遍且对应的快照也都成功完成之后，这个pre-commit阶段才算完成。该过程中所有创建的快照都被视为是checkpoint的一部分。此时我们说checkpoint就是整个应用的全局状态，当然也包含pre-commit阶段提交的外部状态。当出现崩溃时，我们可以回滚状态到最新已成功完成快照时的时间点。整个过程为预提交阶段 2、commit阶段：下一步就是通知所有的operator，告诉它们checkpoint已
flink二阶段提交mysql_flink-----实时项目---day07-----1.Flink的checkpoint原理分析 2. 自定义两阶段提交sink（MySQL） 3 将数据写入Hba...
weixin_32968105的博客
01-20 621
1.Flink中exactly once实现原理分析生产者从kafka拉取数据以及消费者往kafka写数据都需要保证exactly once。目前flink中支持exactly once的source不多，有kafka source；能实现exactly once的sink也不多，如kafka sink、streamingFileSink，其都要开启checkpoint才能实现exactly on...
flink连接hbase的连接池_Flink 异步IO访问外部数据（hbase、mysql篇）
weixin_39968760的博客
01-17 1063
最近看了大佬的博客，突然想起Async I/O方式是Blink 推给社区的一大重要功能，可以使用异步的方式获取外部数据，想着自己实现以下，项目上用的时候，可以不用现去找了。最开始想用scala 实现一个读取 hbase数据的demo，参照官网demo：/*** An implementation of the ‘AsyncFunction‘ that sends requests and sets...
Flink系列之：使用Flink Mysql CDC基于Flink SQL同步mysql数据到StarRocks数据库
zhengzaifeidelushang的博客
01-29 1582
Flink系列之：使用Flink Mysql CDC基于Flink SQL同步mysql数据到StarRocks数据库
Flink-MysqlTwoPhaseCommit.zip
02-27
Flink MySQL二阶提交代码，为了保证前一次 CheckPoint 成功后到这次 CheckPoint 成功之前这段时间内的数据不丢失，如果执行到一半过程任务失败了，从而导致前一次CheckPoint成功后到任务失败前的数据已经存储到了MySQL,然而这部分数据并没有写入到 CheckPoint。如果任务重启后，前一次CheckPoint成功后到任务失败前的数据便会再次写入MySQL,从而导致数据重复的问题。
Flink二阶段提交
liuwei0376的专栏
08-10 4377
XA（eXtended Architecture）是指由X/Open 组织提出的分布式交易处理的规范。XA 是一个分布式事务协议，由Tuxedo 提出，所以分布式事务也称为XA 事务。XA 协议主要定义了事务管理器TM（Transaction Manager，协调者）和资源管理器RM（Resource Manager，参与者）之间的接口。其中，资源管理器往往由数据库实现，如Oracle、DB2、MySQL，这些商业数据库都实现了XA 接口，而事务管理器作为全局的调度者，负责各个本地资源的提交和回滚。....
Flink 两阶段提交（Two-Phase Commit）协议
JustinMars的博客
08-08 2383
flink两阶段提交
Flink——Flink CheckPoint之两阶段提交协议（Two-Phase Commit Protocol）
aof
03-29 6173
参考 https://courses.cs.vt.edu/the-two-phase-commit-protocol https://www.geeksforgeeks.org/two-phase-commit-protocol-distributed-transaction-management/
【Flink】详解 Flink 的两阶段提交
在路上的专栏
09-06 1009
Flink的两阶段提交协议通过事务机制和checkpoint结合，确保数据在流处理作业中的一致性和Exactly Once语义。这种机制广泛应用于需要高可靠性、数据精确处理的场景，尽管存在一定的性能开销，但它在数据处理的准确性和安全性上提供了强有力的保障。
Flink的两阶段提交是什么
xxy1022_的博客
01-17 1187
两阶段提交 Two-Phase-Commit，简称 2PC，是很常用的解决分布式事务问题的方式，它可以保证在分布式事务中，要么所有参与进程都提交事务，要么都取消，即实现 ACID 中的 A （原子性）。如果协调者获取到的所有参与者节点返回的消息都为“同意”时，协调者向所有参与者节点发送“正式提交”的请求（成功情况）；反之，如果任意一个参与者节点预提交阶段返回的响应消息为“终止”，或者协调者询问阶段超时，导致没有收到所有的参与者节点的响应，那么，协调者向所有参与者节点发送“回滚提交”的请求（失败情况）。
Flink 内容分享(二十二)：Flink两阶段提交之关系型数据库
之乎者也·的博客
12-31 1067
最近在一边学习，一边将Flink流处理技术应用到公司的业务场景中。目前会通过采集方式将数据库的数据变更写入到Kafka，后面通过Flink处理后，落地到数仓中，因为目前数仓对外提供的是一些接口服务，所以目前还是以Oracle为主，其他的数据存放在Greenplum中。当前主要任务是将Kafka中的数据通过Flink落地到Oracle中。因为是一些交易数据，所以对数据的准确性非常敏感，Flink的强大之处就在于帮我们实现了方式来保证数据仅一次处理（Exactly-once）。
flink创建连接池
08-31
在Flink中创建连接池可以使用以下步骤： 1. 在Flink的open方法中创建连接池，可以使用阿里巴巴开源的数据库连接池实现Druid。Druid结合了C3P0、DBCP、PROXOOL等数据库连接池的优点，并且具有日志监控功能，可以监控连接池连接和SQL的执行情况。 2. 在open方法中，通过Druid提供的API获取数据库连接，可以使用getConnection方法来获取连接。 3. 在使用完连接之后，需要调用.close方法将连接归还给连接池，以便其他任务或线程可以继续使用该连接。 通过以上步骤，你可以在Flink中创建连接池并且正确地使用和管理连接。请注意，如果连接长时间不使用，某些数据库（例如MySQL）可能会自动回收连接，因此在适当的时候要及时将连接归还给连接池。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [flink配合druid连接池的使用](https://blog.youkuaiyun.com/qq_44962429/article/details/106406954)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值