kafka实践-分区器-拦截器-消费者-生产者-kafakStream

最新推荐文章于 2024-07-15 10:53:41 发布
最新推荐文章于 2024-07-15 10:53:41 发布
阅读量366 收藏 1
点赞数
分类专栏： 工作后
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44698610/article/details/104782141
版权

模拟消费者组

三台机器中选择两台设置相同的消费者组

  • 设置相同的组id给两台机器
group.id=nove
  • 开启一个生产者
bin/kafka-console-producer.sh \
--broker-list hadoop101:9092 --topic second
  • 指定配置文件开启两个消费者
bin/kafka-console-consumer.sh --bootstrap-server hadoop101:9092 --topic second --from-beginning --consumer.config config/consumer.properties
  • 此时：对于生产者产生的信息只有一个客户端可以接受到

生产者api

send方法中存在了不掉用回调函数与调用回调函数的情况。

  • 调用回调函数
    查看源码，模拟使用。
package com.uu.kafkaProject;

import com.sun.xml.internal.ws.wsdl.writer.document.Import;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;

/**
 * Created by IBM on 2020/3/11.
 */
public class KafkaProducter {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "hadoop103:9092");
        // 等待所有副本节点的应答
        props.put("acks", "all");
        // 消息发送最大尝试次数
        props.put("retries", 0);
        // 一批消息处理大小
        props.put("batch.size", 16384);
        // 请求延时
        props.put("linger.ms", 1);
        // 发送缓存区内存大小
        props.put("buffer.memory", 33554432);
        // key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value序列化
        props.put("value.serializer", "org.apache.kafka.common.serialization.IntegerSerializer");

        Producer<String, Integer> producer = new KafkaProducer(props);
        //创建回调对象
        Callback callback = new Callback() {
            public void onCompletion(RecordMetadata metadata, Exception exception) {
                    System.out.println("偏移量"+metadata.offset());
                    if(exception != null){
                        System.out.println(exception.getMessage());
                    }

            }
        };
        for (int i = 0; i < 50; i++) {
            //主题，key，value，对应的类型
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            producer.send(new ProducerRecord<String, Integer>("second",Integer.toString(i), new Integer(i)),callback);
        }


        producer.close();


    }

}

分区器的使用

核心在于：实现Partitioner接口。
实现分区的方法。
在生产者代码中进行配置的引入

分区器
package com.uu.kafkaProject;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

/**
 * Created by IBM on 2020/3/11.
 */
public class MyKafkaPartition implements Partitioner {

    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        return 0;
    }

    public void close() {

    }

    public void configure(Map<String, ?> configs) {

    }
}
生产者

配置中添加属性

props.put("partitioner.class", "com.uu.kafkaProject.MyKafkaPartition");

消费者

此代码指定了两个topic来进行消费

package com.uu.kafkaProject;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.List;
import java.util.Properties;

/**
 * Created by IBM on 2020/3/11.
 */
public class KafkaConsumerExe {
    public static void main(String[] args) {
        Properties props = new Properties();
        // 定义kakfa 服务的地址，不需要将所有broker指定上
        props.put("bootstrap.servers", "hadoop102:9092");
        // 制定consumer group
        props.put("group.id", "test");
        // 是否自动确认offset
        props.put("enable.auto.commit", "true");
        // 自动确认offset的时间间隔
        props.put("auto.commit.interval.ms", "1000");
        // key的序列化类
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // value的序列化类
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // 定义consumer
        KafkaConsumer kafkaConsumer = new KafkaConsumer(props);

        List<String> strings = Arrays.asList("first", "second");

        kafkaConsumer.subscribe(strings);

        while (true) {
            // 读取数据，读取超时时间为100ms
            ConsumerRecords<String, String> records = kafkaConsumer.poll(100);

            for (ConsumerRecord<String, String> record : records)
                System.out.println("偏移量:" + record.offset() + "key:" + record.key() + "value:" + record.value()+"topic"+record.topic());

        }
    }
}

拦截器

其实就是新建了一个发送的对象
新写了一个回调逻辑
新写了关闭方法

package com.uu.kafkaProject;

import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Map;

/**
 * Created by IBM on 2020/3/12.
 */
public class KafkaInterocter implements ProducerInterceptor {

    public ProducerRecord onSend(ProducerRecord record) {

        // 此处可以对发送的对象进行修改
        ProducerRecord producerRecord = new ProducerRecord(record.topic(), record.partition(), record.timestamp(), record.key(),
                System.currentTimeMillis() + "," + record.value().toString());


        return producerRecord;
    }
    //回调方法
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }
    //关闭的方法
    public void close() {

    }

    public void configure(Map<String, ?> configs) {

    }
}
使用

新建数组进行添加

		List<String> interceptors = new ArrayList<>();
		interceptors.add("com.uu.kafkaProject.KafkaInterocter"); 
		interceptors.add("com.uu.kafkaProject.KafkaInterocter1"); 
		props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);

kafakStream

从Stream入手，需要一个拓扑模型与kafak配置
拓扑模型将sink与source连接
channel重新写一个处理流程

依赖

注意版本与kafka版本统一

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <version>0.11.0.0</version>
        </dependency>
Stream类
package com.uu.kafkaProject;

import java.util.Properties;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorSupplier;
import org.apache.kafka.streams.processor.TopologyBuilder;

/**
 * Created by IBM on 2020/3/12.
 */
public class KafkaStreamApp {
    public static void main(String[] args) {
        // 定义输入的topic
        String from = "first";
        // 定义输出的topic
        String to = "second";

        // 设置参数
        Properties settings = new Properties();
        settings.put(StreamsConfig.APPLICATION_ID_CONFIG, "myKakfaStream");
        settings.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");

        StreamsConfig config = new StreamsConfig(settings);

        TopologyBuilder topologyBuilder = new TopologyBuilder();

        ProcessorSupplier processorSupplier = new ProcessorSupplier<byte[], byte[]>() {
            public Processor<byte[], byte[]> get() {
                return new KafakCleaner();
            }
        };


        //添加kafak的source
        topologyBuilder.addSource("SOURCE", from);
        //处理流程
        topologyBuilder.addProcessor("pro",processorSupplier,"SOURCE");

        //添加sink
        topologyBuilder.addSink("sink",to,"pro");

        // 创建kafka stream
        KafkaStreams streams = new KafkaStreams(topologyBuilder, config);
        streams.start();


    }
}
重写的处理流程类
package com.uu.kafkaProject;

import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorContext;

/**
 * Created by IBM on 2020/3/12.
 */
public class KafakCleaner implements Processor<byte[], byte[]> {

    private ProcessorContext context;


    public void init(ProcessorContext context) {
        this.context = context;

    }

    public void process(byte[] key, byte[] value) {
        String s = key.toString()+"拦截";
        String s1 = value.toString()+"拦截";

        System.out.println(s + "..." + s1);
        context.forward(s.getBytes(),s1.getBytes());


    }

    public void punctuate(long timestamp) {

    }

    public void close() {

    }
}
小nove
关注
专栏目录
Kafka序列化器，分区器，拦截器，消息累加器
ThreeAspects的博客
08-20 1885
目录拦截器序列化器分区器消息累加器   整个Kafka生产者客户端由两条线程协调运行。这两条线程分别为主线程和sender线程（发送线程）。主线程的作用就是：由KafkaProducer创建消息，然后通过可能的拦截器，序列化器，分区器的作用之后缓存到消息累加器。send线程的作用就是：负责将消息累加器中的消息发送到kafka中。 拦截器   拦截器是在Kafka0.10.0.0版本中就已经引入的一个功能，Kafka一共有两种拦截器。生产者拦截器和消费者拦截器。 生产者拦截器   生产者拦截器可以用来在消息发
kafka中的序列化器&分区器&拦截器
GuessHat的博客
03-14 1272
kafka中的序列化器&分区器&拦截器 1.序列化器 序列化器的作用是在进行网络传输中将数据序列化为字节流进行传输，保证数据不会丢失， kafka中的序列化器有： 字符串序列化器 StringSerializer 整形 IntegerSerializer 字节数组 ByteSerializer a.实现接口 org.apache.kafka.common.serialization.Serializer 设置序列化器的方式 //设置key和value的序列化 prope
kafka-Stream详解篇（附案例）
A的博客
06-29 1933
Kafka Stream是Apache Kafka从0.10版本引入的一个新Feature。它是提供了对存储于Kafka内的数据进行流式处理和分析的功能。Kafka Stream提供了一个非常简单而轻量的Library，它可以非常方便地嵌入任意Java应用中，也可以任意方式打包和部署除了Kafka外，无任何外部依赖充分利用Kafka分区机制实现水平扩展和顺序性保证通过可容错的state store实现高效的状态操作（如windowed join和aggregation）
序列化--分区器--拦截器（四）
用键盘与世界交流
11-09 309
序列化 生产者需要用序列化器（Serializer）把对象转换成字节数组才能通过网络发送给 Kafka。而在对侧，消费者需要用反序列化器（Deserializer）把从 Kafka 中收到的字节数组转换成相应的对象。在代码清单3-1中，为了方便，消息的 key 和 value 都使用了字符串，对应程序中的序列化器也使用了客户端自带的 org.apache.kafka.common.serialization.StringSerializer，除了用于 String 类型的序列化器，还有 ByteArray
Kafka的分区器、拦截器、序列化器
qq_45275284的博客
03-27 324
顺序：拦截器>序列化器>分区器。
kafka 序列化器，分区器，拦截器，消息累加器
weixin_40954192的博客
07-13 1029
目录 拦截器 生产者拦截器 自定义生产者拦截器 序列化器 反序列化器 分区器 消息累加器 前提了解： 整个kafka生产者客户端由两条线程协调运行。 这两条线程分别为主线程和sender线程（发送线程） 主线程的作用就是：由KafkaProducer创建消息，然后通过可能的拦截器，序列化器，分区器的作用之后缓存到消息累加器 send线程的作用就是：负责将消息累加器中的消息发送到kafka中。 拦截器 拦截器是在kafka0.10.0.0版本中就已经引...
一文搞懂kafka的序列化、分区器、拦截器
最新发布
神技圈子的博客
07-15 397
通过实例讲解了kafka的序列化器、分区器、拦截器
Kafka 入门到起飞系列 - 生产者发送消息流程解析
FightingITPanda的博客
07-16 2136
批次的概念很好理解，缓冲区就像一辆公交车，有两种发车方式，一是人满了就发车，一是等5分钟就发车，不管是人满了还是到5分钟了，发车，go~Producer 创建时，会创建一个Sender线程设置为守护线程。Producer 生产消息，内部是一个异步流程。Producer 创建时，会创建缓冲区。
Kafka学习(2)-----生产者
zh328271057的博客
05-27 184
思维导图： 引言 本文的主要内容是对Kafka生产者的介绍，包括以下三个部分： Kafka生产者的使用流程：包括如何创建实例，构建消息并发送 Kafka生产者的前处理：包括拦截器，序列化和分区器 Kafka生产者的原理：包括整体的架构，元数据等 一.Kafka生产者的使用流程 Kafka生产者的基本使用其实和上一节中没什么太大的差别，只是对其中的配置信息进行了...
kafka 系列 -- 3.1、生产者客户端基本使用
不能放弃治疗
08-05 630
文章目录必要的参数生产者拦截器序列化分区器与 RocketMQ 异同 必要的参数 bootstrap.servers 该参数为 broker 地址，不需要全部都填，因为 kafka 会从当前 broker 中获取其他 broker 信息。不过为了某个 broker 挂掉，一般填多个 broker 地址 key.serializer 消息 key 如何序列化 value.serializer 消息内容如何序列化 示例代码 Properties properties = new Properties();
Kafka学习--- Kafka Producer生产者
qq_36697880的博客
10-22 589
这里主要是记录学习使用，介绍Kafka Producer基本使用和基本原理。 从编程的角度而言， 生产者就是负责向 Kafka发送消息的应用程序。 一、基本概念 1.1、Kafka Producer 的执行过程 Kafka producer 的正常生产逻辑包含以下几个步骤： 配置生产者客户端参数常见生产者实例。 构建待发送的消息。 发送消息。 关闭生产者实例。 代码实现： public class Producer { public stat.
第三篇：深入剖析Kafka生产者的序列化器、分区器和拦截器
Gemini的博客
05-26 102
我们要探讨的是Kafka生产者的重要组件：序列化器、分区器和拦截器。这些组件在Kafka消息生产过程中扮演着至关重要的角色，它们决定了消息的编码方式、消息的分区策略以及消息发送前后的处理逻辑。本文将详细介绍这些组件的原理和作用，并提供自定义示例。希望通过这篇文章，你能全面理解Kafka生产者的这些核心功能。序列化器用于将对象转换为字节数组，以便消息能够在Kafka中传输。Kafka提供了默认的序列化器（如`StringSerializer`），但也允许用户自定义序列化器以满足特定需求。
Kafka--自定义分区器与拦截器
手提青灯觅佳人的博客
03-16 112
首先了解KafkaProduce发送消息流程 一、定义一个简单的生产者(不会写找源码抄--改) 代码： public static void main(String[] args) { //producer的配置信息 Properties props = new Properties();// 服务器的地址和端口 props.put(...
kafka—消费者拦截器
大树1993
07-03 909
自定义消费者拦截器 //可以在消费到消息或在提交消费位移时进行一些定制化的操作 public class ConsumerInterceptor implements org.apache.kafka.clients.consumer.ConsumerInterceptor { @Override public void configure(Map<String, ?> configs) {} /** * 提交位移之后调用 */ @Override
Kafka系列——生产者的分区，序列化，自定义拦截器以及头部信息
zekser的博客
03-18 1093
kafka的分区，序列化，自定义序列化源码示例；自定义拦截器，头部信息的作用
Kafka-之Producer生产者（含拦截器、分区器、序列化器及异步消息发送模式）
shufangreal的博客
12-04 789
Kafka-之Producer生产者（含拦截器、分区器、序列化器及异步消息发送模式） Kafka生产者是整个Kafka架构中的一个角色，可以是不同集成了Kafka的组件，KafkaProducer是线程安全的，可以同时给多个线程使用。 1 如何构建一个KafkaProducer 构建一个KafkaProducer的构造方法有2种： //首先配置Producer必要配置 Properties properties = new Properties(); properties.put(ProducerConfi
疫情分析--数据清洗(kafka消费者拦截器)
weixin_45389898的博客
07-17 1874
^^
kafka系列之Consumer 拦截器(9)
热门推荐
03-11 6万+
Consumer 拦截器 前面我们详细介绍了拦截器的原理，可以参考kafka系列之Producer 拦截器(06),其实拦截器的在很多技术中都有，关于拦截器的应用场景我们在前面一节中也介绍过了，这一节我们直接看一下消费者端拦截器的使用。我觉得为了学习kafka ，你可以打开kafka 的源码包，看看都有什么，你可以从kafka-client 包开始 我们今天要介绍的ConsumerInterceptor 就是在consumer 包下面，我么前面介绍的很多东西你都可以在这里看到响应的代码，例如分区的分配策略
Kafka拦截器应用
Faker_Wang的博客
12-13 262
一、Kafka拦截器  Kafka 拦截器分为生产者拦截器和消费者拦截器。生产者拦截器允许你在发送消息前以及消息提交成功后植入你的拦截器逻辑；而消费者拦截器支持在消费消息前以及提交位移后编写特定逻辑。值得一提的是，这两种拦截器都支持链的方式，即你可以将一组拦截器串连成一个大的拦截器，Kafka 会按照添加顺序依次执行拦截器逻辑。 如果需要加AddTimestampInterceptor和UpdateCounterInterceptor两个拦截器，可以这样配置 Properties props = new
Kafka Producer拦截器实战与Kafka Streams应用
在第12单元中，我们将深入探讨Kafka生产者拦截器（Producer Interceptor）及其在Kafka Streams框架中的应用。Kafka 0.10版本引入了生产者拦截器，旨在提供客户端级别的定制化控制逻辑，允许开发者在消息发送过程中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值