kafka_10_生产端事务

最新推荐文章于 2024-01-06 17:25:04 发布
最新推荐文章于 2024-01-06 17:25:04 发布
阅读量157 收藏
点赞数
分类专栏： kafka 文章标签： kafka 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxczb/article/details/107902707
版权

consumer readcommit

package com.soul.kafka.level10;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

public class KafkaConsumerReadCommitted {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka01:9092,kafka02:9092,kafka03:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //与 KafkaConsumerReadUnCommitted 需不同组来验证
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "group02");
        //设置事务隔离级别, 读已提交(仅仅消费有提交标记的消息)
        props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_committed");

        //2.创建Topic消费者
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
        //3.订阅topic开头的消息队列
        consumer.subscribe(Pattern.compile("^topic.*$"));

        while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> recordIterator = consumerRecords.iterator();
            while (recordIterator.hasNext()) {
                ConsumerRecord<String, String> record = recordIterator.next();
                String key = record.key();
                String value = record.value();
                long offset = record.offset();
                int partition = record.partition();
                System.out.println("key:" + key + ", val:" + value
                        + ", partition:" + partition + ", offset:" + offset);
            }
        }
    }
}

consumer readuncommit

package com.soul.kafka.level10;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Pattern;

public class KafkaConsumerReadUnCommitted {
    public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka01:9092,kafka02:9092,kafka03:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //与 KafkaConsumerReadCommitted 需不同组来验证
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "group01");
        //设置事务隔离级别, 读未提交(默认级别, 消费已写入broker的消息, 不管提交标记)
        props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_uncommitted");

        //2.创建Topic消费者
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
        //3.订阅topic开头的消息队列
        consumer.subscribe(Pattern.compile("^topic.*$"));

        while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> recordIterator = consumerRecords.iterator();
            while (recordIterator.hasNext()) {
                ConsumerRecord<String, String> record = recordIterator.next();
                String key = record.key();
                String value = record.value();
                long offset = record.offset();
                int partition = record.partition();
                System.out.println("key:" + key + ", val:" + value
                        + ", partition:" + partition + ", offset:" + offset);
            }
        }
    }
}

producer

package com.soul.kafka.level10;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.*;

/**
 *
Kafka的幂等性，只能保证一条记录的在分区发送的原子性，
但是如果要保证多条记录（多分区）之间的完整性，这个时候就需要开启kafk的事务操作。

在Kafka0.11.0.0除了引入的幂等性的概念，同时也引入了事务的概念。
通常Kafka的事务分为 生产者事务Only、消费者&生产者事务。
一般来说默认消费者消费的消息的级别是read_uncommited数据，这有可能读取到事务失败的数据，
所有在开启生产者事务之后，需要用户设置消费者的事务隔离级别。

isolation.level	=  read_uncommitted 默认
该选项有两个值read_committed|read_uncommitted，如果开始事务控制，
消费端必须将事务的隔离级别设置为read_committed

开启的生产者事务的时候，只需要指定transactional.id属性即可，
一旦开启了事务，默认生产者就已经开启了幂等性。
但是要求"transactional.id"的取值必须是唯一的，
同一时刻只能有一个"transactional.id"存储在，其他的将会被关闭。

 *
 */
public class KafkaProducerTransactionsProducerOnly {
    //测试
    // 运行 KafkaConsumerReadCommitted 和 KafkaConsumerReadUnCommitted 消费端服务
    // 运行 KafkaProducerTransactionsProducerOnly 生产端服务
    // 发现 KafkaConsumerReadCommitted 无消费消息
    // 发现 KafkaConsumerReadUnCommitted 消费了 8 条消息
    // 可见 生产者对消息事务(是否提交)的标记, 影响设置了 ISOLATION_LEVEL_CONFIG 的消费端
    public static void main(String[] args) {

        //构建生产者
        KafkaProducer<String, String> producer = buildKafkaProducer();

        //初始化事务
        producer.initTransactions();

        try {
            //开启事务控制
            producer.beginTransaction();
            for (int i = 0; i < 10; i++) {
                //制造异常
                if (i == 8){
                    int gin = 8 / 0;
                }
                //创建Record
                ProducerRecord<String, String> producerRecord = new ProducerRecord<>("topic02",
                        "K" + i, "V" + i);
                producer.send(producerRecord);
                //为了测试使用, 每条都刷, 避免没有数据写入到kafka
                producer.flush();
            }
            //避免本地缓存数据, 将消息刷到kafka集群
            producer.flush();
            //提交事务
            producer.commitTransaction();
        } catch (Exception e) {
            System.out.println("error: " + e.getMessage());
            //终止事务
            producer.abortTransaction();
        } finally {
            producer.close();
        }
    }

    public static KafkaProducer<String, String> buildKafkaProducer() {
        //构建生产者配置信息
        Properties props = new Properties();
        //集群hostname:port
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka01:9092,kafka02:9092,kafka03:9092");
        //序列化 反序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //配置生产者端事务ID
        props.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,
                //避免重复, 拼接 UUID 来保证唯一
                "transaction-id" + ":" + UUID.randomUUID().toString());
        //配置批处理数量, 默认为16384字节, 测试时设置较小(多条数据缓冲到设定字节后, 打包一次发送)
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 1024);
        //为避免长时间未达到发送批次上线, 导致数据不发送, 设置必须发送的时间间隔, 毫秒, 5ms
        props.put(ProducerConfig.LINGER_MS_CONFIG, 5);

        //配置重试机制(all-至少一个副本写入数据, 20S未接收到应答则重复发送)
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        props.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG, 20000);
        //开启幂等机制
        props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);

        return new KafkaProducer<>(props);
    }

}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.soul</groupId>
    <artifactId>kafka</artifactId>
    <version>0.0.1</version>
    <name>kafka</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- kafka begin -->

        <!--https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients-->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.2.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

        <!-- kafka end -->
        
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

log4j.properties

log4j.rootLogger = info,console

log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern =  %p %d{yyyy-MM-dd HH:mm:ss} %c - %m%n
SOUL-GIN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
10、Kafka事务
java爱分享
12-15 210
只有Producer生产消息： 见生产者、消费者实战代码。 消费消息和生产消息并存： 这个是事务场景中最常用的情况，就是我们常说的“consume-transform-produce ”模式； 也应用到kafka stream应用中，从一个topic读取数据，处理数据，写回另一个 topic场景中。 见生产者、消费者实战代码。 只有消费者消费消息： 这种操作其实没有什么意义，跟使用手动提交效果一样...
kafka_2.13-2.7.0_1.rar
10-19
10. **Kafka Streams**：Kafka 自带的一个轻量级、分布式流处理库，允许开发者在 JVM 上构建实时数据处理应用程序，对流入 Kafka 的数据进行转换和聚合。 在提供的压缩包 "kafka_2.13-2.7.0_1" 中，很可能包含了 ...
Kafka生产者事务和幂等
ZERO
05-25 246
转载自：http://www.heartthinkdo.com/?p=2040     https://blog.csdn.net/mlljava1111/article/details/81180351    在Kafka 0.11.0.0引入了EOS（exactly once semantics，精确一次处理语义）的特性，这个特性包括kafka幂等性和kafka事务两个属性。 1 生产者幂等性   幂等性引入目的：生产者重复生产消息。生产者进行retry会产生重试时，会重复产生消息。有了幂等性之后，在进
kafka-稳定性-事务
小城我家
11-14 709
稳定性 事务 一、事务场景 如producer发的多条消息组成一个事务这些消息需要对consumer同时可见或者同时不可见 。 producer可能会给多个topic，多个partition发消息，这些消息也需要能放在一个事务里面，这就形成了一个典型的分布式事务。 kafka的应用场景经常是应用先消费一个topic，然后做处理再发到另一个topic，这个consume-transform-produce过程需要放到一个事务里面，比如在消息处理或者发送的过程中如果失败了，消费偏移量也不能提交。 produc
Kafka生产者事务
没有合适的昵称
08-17 2290
Kafka事务 说到事务，我们都知道传统数据库，比如Oracle和Mysql，都是支持事务的，在一个事务中的所有的数据库操作，要么全部成功，要么全部失败，先看一下下面的伪代码： begin transaction # 开启事务,然后进行表的各种操作 update table1; delete table2 where …; update table2; end transaction # 提...
Kafka：生产者事务
程序员无羡的博客
03-19 248
Kafka：生产者事务
spring-kafka-producer-consumer-example_java_springboot_kafka_
09-30
2. **Kafka生产者（Producer）**： - 生产者是向Kafka主题（topic）发布消息的组件。在Spring Boot中，可以创建一个实现了`KafkaTemplate`接口的bean，通过这个模板发送消息。 - `KafkaTemplate.send()`方法用于...
Python库 | confluent_kafka-1.5.0-cp36-cp36m-win_amd64.whl
02-15
此外，Confluent Kafka库还支持更高级的功能，如幂等性生产（Idempotent Production）和事务性生产（Transactional Production），这些特性确保了消息的一致性和零重复。对于大型分布式系统，这些特性是保证数据完整...
sprinbgoot整合kafka
08-11
消费者端，我们需要定义一个实现了 `org.springframework.kafka.listener.KafkaListener` 接口或者使用注解 `@KafkaListener` 的方法。这个方法会监听指定的主题，并在有新消息时被调用。此外，我们还需要配置消费...
Kafka-m.docx
最新发布
03-12
- **使用Kafka事务**：Kafka支持事务功能，可以利用这一特性来保证消息处理的原子性。事务提供了一种机制，使得消息的生产和消费可以作为一个整体进行处理，从而避免了消息的重复或遗漏。 #### 五、结论 综上所述...
Kafka（六）生产者事务
qq_41982570的博客
04-02 910
Kafka 生产者事务
「Kafka技术」Apache Kafka中的事务
全网:架构师研究会
02-19 204
在之前的一篇博客文章中，我们介绍了Apache Kafka®的一次语义。这篇文章介绍了各种消息传递语义，介绍了幂等生成器、事务和Kafka流的一次处理语义。现在，我们将继续上一节的内容，深入探讨Apache Kafka中的事务。该文档的目标是让读者熟悉有效使用Apache Kafka中的事务API所需的主要概念。我们将讨论设计事务API的主要用例、Kafka的事务语义、用...
kafka事务
xhdxhdxhd的博客
10-23 584
文章 权威来源: https://cwiki.apache.org/confluence/display/KAFKA/KIP-98±+Exactly+Once+Delivery+and+Transactional+Messaging 概述 生产者幂等 配置：enable.idempotence。 幂等机制：每个producer每次启动时，都会获得一个ProducerID和序列号。broker要求新收到的消息 序列号小于等于已确认的消息，这些消息被忽略 序列号恰好等于已确认的消息+1，这个消息会被记录为最新
Kafka生产者幂等性与事务
qq_63431773的博客
01-06 1004
Kafka事务是2017年Kafka 0.11.0.0引入的新特性。类似于数据库的事务。Kafka事务指的是生产者生产消息以及消费者提交offset的操作可以在一个原子操作中，要么都成功，要么都失败。尤其是在生产者、消费者并存时，事务的保障尤其重要。（consumer-transform-producer模式）事务操作APIinitTransactions（初始化事务）：要使用Kafka事务，必须先进行初始化操作beginTransaction（开始事务）：启动一个Kafka事务。
Kafka 事务
weixin_43497444的博客
03-19 288
Kafka 从 0.11 版本开始引入了事务支持。事务可以保证 Kafka 在 Exactly Once 语义的基 础上，生产和消费可以跨分区和会话，要么全部成功，要么全部失败。 1.Producer 事务 为了实现跨分区跨会话的事务，需要引入一个全局唯一的 Transaction ID，并将 Producer 获得的PID 和Transaction ID 绑定。这样当Producer 重启后就可...
kafka之事务
你的BoyZ的博客
06-21 6937
kafka学习之事务 前言 为了实现EOS(exactly once semantics,精确一次处理语义)karka从0.11.0.0版本开始引入了幂等性和事务两个特性来支撑。 场景 最简单的需求是producer发的多条消息组成一个事务这些消息需要对consumer同时可见或者同时不可见 。 producer可能会给多个topic，多个partition发消息，这些消息也需要能放在一个事务里面，这就形成了一个典型的分布式事务。 kafka的应用场景经常是应用先消费一个topic，然后做处理再发到另一个
Kafka的事务
qq_44469202的博客
04-18 286
Kafka的事务 使用事务的条件 必须提供唯一的transactionalId，这个transactionalId通过客户端参数transactional.id来显式设置。 要求生产者开启幂等特性。 transactionalId与PID一一对应，两者之间不同的是transactionalId由用户显式设置，而PID是由Kafka内部分配的。 另外，为了保证新的生产者启动后，具有相同transactionalId的旧生产者能够立即失效，每个生产者通过transactionalId获取PID的同时
kafka开启事务配置文件
06-07
要开启 Kafka 的事务机制，需要在 Kafka Broker 和生产者端都进行相应的配置。 1. Broker 配置 在 Kafka Broker 的配置文件 server.properties 中添加以下配置： ```properties transaction.state.log....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值