Kafka入门

最新推荐文章于 2024-07-01 23:08:24 发布
最新推荐文章于 2024-07-01 23:08:24 发布
阅读量148 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011342403/article/details/115889460
版权

Kafka生产者消费者，拦截器，分区器，序列化以及反序列化器

直接上代码 pom文件

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>1.0.2</version>
        </dependency>
                    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
    </dependencies>

发送消息的实体化数据

public class User {
    private Integer userId;
    private String username;

    public User() {
    }

    public User(Integer userId, String username) {
        this.userId = userId;
        this.username = username;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", username='" + username + '\'' +
                '}';
    }
}

生产者,其中包含了自定义序列化器和分区器以及生产者拦截器的一些配置，采用了异步发送的 模式

public class MyProducer {
    public static void main(String[] args) {
        Map<String, Object> configs = new HashMap<>();
        configs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "115.159.150.169:9092");
        configs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 设置自定义的序列化器
        configs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, UserSerializer.class);
        configs.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, Kafkapartitioner.class);
        configs.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, ProducerInteceptor.class.getName());
        KafkaProducer<String, User> producer = new KafkaProducer<String, User>(configs);

        for (int i=1;i<5;i++){
            User user = new User();
            user.setUserId(400+i);
            user.setUsername("赵四"+i);

            ProducerRecord<String, User> record = new ProducerRecord<String, User>(
                    "tp_user_03",   // topic
                    user.getUsername(),   // key
                    user                  // value
            );


            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception != null) {
                        System.out.println("消息发送异常");
                    } else {
//                        System.out.println("主题：" + metadata.topic() + "\t"
//                                + "分区：" + metadata.partition() + "\t"
//                                + "生产者偏移量：" + metadata.offset());
                        System.out.println(
                               "分区：" + metadata.partition());
                    }
                }
            });
        }


        // 关闭生产者
        producer.close();

    }
}

消费者,消费者中也加入反序列化和消费端的配置

public class UserConsumer {

    public static void main(String[] args) {
        Map<String, Object> configs = new HashMap<>();
        configs.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "115.159.150.169:9092");
        configs.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        // 设置自定义的反序列化器
        configs.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, UserDeserializer.class);

        configs.put(ConsumerConfig.GROUP_ID_CONFIG, "user_consumer");
        configs.put(ConsumerConfig.CLIENT_ID_CONFIG, "consumer_id");
        configs.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        configs.put(ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG, UserIdConsumerInteceptor.class.getName()
                +","+ UsernameConsumerInteceptor.class.getName());
        KafkaConsumer<String, User> consumer = new KafkaConsumer<String, User>(configs);

        // 订阅主题
        consumer.subscribe(Collections.singleton("tp_user_03"));

        final ConsumerRecords<String, User> records = consumer.poll(Long.MAX_VALUE);

        records.forEach(new Consumer<ConsumerRecord<String, User>>() {
            @Override
            public void accept(ConsumerRecord<String, User> record) {
                System.out.println(record.headers());
                System.out.println(record.value());
            }
        });

        // 关闭消费者
        consumer.close();

    }

}

接下来是序列化和反序列化的配置

public class UserSerializer implements Serializer<User> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        // do nothing
        // 用于接收对序列化器的配置参数，并对当前序列化器进行配置和初始化的
    }

    @Override
    public byte[] serialize(String topic, User data) {
        System.out.println("username "+data.getUsername());
        //data.setUserId(401);
        data.setUsername(data.getUsername()+"在学习kafka");
        return JSON.toJSONBytes(data);
//        try {
//            if (data == null) {
//                return null;
//            } else {
//                final Integer userId = data.getUserId();
//                final String username = data.getUsername();
//
//                if (userId != null) {
//                    if (username != null) {
//                        final byte[] bytes = username.getBytes("UTF-8");
//                        int length = bytes.length;
//                        // 第一个4个字节用于存储userId的值
//                        // 第二个4个字节用于存储username字节数组的长度int值
//                        // 第三个长度，用于存放username序列化之后的字节数组
//                        ByteBuffer buffer = ByteBuffer.allocate(4 + 4 + length);
//                        // 设置userId
//                        buffer.putInt(userId);
//                        // 设置username字节数组长度
//                        buffer.putInt(length);
//                        // 设置username字节数组
//                        buffer.put(bytes);
//                        // 以字节数组形式返回user对象的值
//                        return buffer.array();
//                    }
//                }
//            }
//        } catch (Exception e) {
//            throw new SerializationException("数据序列化失败");
//        }
//        return null;
    }

    @Override
    public void close() {
        // do nothing
        // 用于关闭资源等操作。需要幂等，即多次调用，效果是一样的。
    }
}

可以看到，实际上在序列化的过程中，只要我们按照要求将数据转化为字节就可以了，同时我们可以在反序列化的过程中对数据进行修改或者处理

public class UserDeserializer implements Deserializer<User> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {

    }

    @Override
    public User deserialize(String topic, byte[] data) {
//        ByteBuffer buffer = ByteBuffer.allocate(data.length);
//
//        buffer.put(data);
//        buffer.flip();
//
//        final int userId = buffer.getInt();
//        final int usernameLength = buffer.getInt();
//
//        String username = new String(data, 8, usernameLength);
//
//        return new User(userId, username);
        System.out.println("执行反序列化");
        return JSON.parseObject(data,User.class);
    }

    @Override
    public void close() {

    }
}

同样的在反序列化过程中需要对数据做对等的反序列化处理 生产者端拦截器,虽然我在代码中设置了重置分区，但是该设置并没有实现，可以确定的是拦截器是在分区器之前进行的操作

public class ProducerInteceptor implements ProducerInterceptor<String, User> {
    @Override
    public ProducerRecord<String, User> onSend(ProducerRecord<String, User> record) {
        System.out.println("拦截器1");
        Integer partition = record.partition();
        System.out.println("拦截器之前的partition是"+partition);
        String topic = record.topic();
        long timestamp = record.timestamp();
        String key = record.key();
        User user = record.value();
        Headers headers = record.headers();
        headers.add("patition inteceptor","partiton".getBytes());
        //拦截器partition重置所有的分区为2
        partition=2;
        ProducerRecord<String,User> producerRecord = new ProducerRecord<>(topic,partition,timestamp,key,user,headers);
        return producerRecord;
    }

    //发送成功回调的拦截器方法
    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        System.out.println("回调成功拦截器");
    }

    @Override
    public void close() {

    }

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

    }
}

消费者端拦截器

//第一个拦截器
public class UserIdConsumerInteceptor implements ConsumerInterceptor<String, User> {
    @Override
    public ConsumerRecords<String, User> onConsume(ConsumerRecords<String, User> records) {
        records.forEach(record->{
            record.value().setUserId(record.value().getUserId()+10);
        });
        return records;
    }

    @Override
    public void onCommit(Map<TopicPartition, OffsetAndMetadata> offsets) {
        System.out.println("userId消费者拦截器提交偏移量了");
    }

    @Override
    public void close() {

    }

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

    }
}

//第二个拦截器
public class UsernameConsumerInteceptor implements ConsumerInterceptor<String, User> {
    @Override
    public ConsumerRecords<String, User> onConsume(ConsumerRecords<String, User> records) {
        records.forEach(record->{
            record.value().setUsername(record.value().getUsername()+record.key());
        });
        return records;
    }

    //消费者提交偏移量时调用
    @Override
    public void onCommit(Map<TopicPartition, OffsetAndMetadata> offsets) {
        System.out.println(offsets.entrySet());
        System.out.println("提交偏移量了");
    }

    @Override
    public void close() {

    }

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

    }
}

分区器，我们实现的时候是以数据的ID为分区的要素

public class Kafkapartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
       User user = JSON.parseObject(valueBytes, User.class);
        System.out.println(user.getUserId());
       int partition = user.getUserId()%3;
        System.out.println("分区器分区时的分区key"+user.getUsername()+"   分区"+partition);
        return partition;
    }

    @Override
    public void close() {

    }

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

    }
}

最后实现的生产者端的结果，可以表明，执行顺序为。拦截器，序列化器，分区器 file

消费者端执行结果，可以看到反序列化器先执行，消费者拦截器后执行，消费者拦截器实际上是在回调的accept方法之后执行的，另外需要注意的一个参数是消费者拦截器和生产者拦截器都需要配置的是拦截器的全路径字符串的集合，且配置在前面的先执行 file

欢迎搜索关注本人的公众号【微瞰技术】,以及总结的分类面试题https://github.com/zhendiao/JavaInterview

file

微瞰技术
关注
Kafka入门教程
不古的博客
04-10 3175
Kafka入门消息队列的流派什么是 MQ有 Broker 的 MQ重 Topic轻 Topic无 Broker 的 MQ一、Kafka介绍1.Kafka的使用场景2.Kafka基本概念二、kafka基本使用1.安装前的环境准备2.启动kafka服务器3.创建主题topic4.发送消息5.消费消息几个注意点：三、Kafka中的关键细节1.消息的顺序存储2. 单播消息的实现3.多播消息的实现在一些业务场景中需要让一条消息被多个消费者消费，那么就可以使用多播模式。4.查看消费组及信息四、主题、分区的概念1.主题T
Kafka入门到精通
shuai_h的博客
07-10 3508
Kafka是由Apache软件基金会开发的一个开源流平台，由Scala和Java编写。Kafka的Apache官网是这样介绍Kakfa的。Apache Kafka是一个分布式流平台。发布和订阅流数据流，类似于消息队列或者是企业消息传递系统以容错的持久化方式存储数据流处理数据流Publish and subscribe：发布与订阅Store：存储Process：处理特性。
Kafka 入门指南
power_9的博客
07-01 979
Kafka 是一个功能强大的分布式消息队列系统，具有高吞吐量、可扩展性和高可用性。通过本指南的介绍，您应该已经了解了 Kafka 的基本概念、安装和配置方法，以及一些高级主题和实践案例。希望这篇文章能够帮助您快速入门 Kafka，并在实际项目中应用它。# Kafka 入门指南## 简介Kafka 是一个由 Apache 软件基金会开发的开源流处理平台。它最初由 LinkedIn 开发，并在 2011 年作为开源项目发布。
Kafka 入门
weixin_43117449的博客
03-21 2303
一、定义 Kafka是一个分布式的基于发布/订阅模式的消息队列（message Queue），主要用于大数据实时处理领域。 发布订阅模式：消息的发布者不会将消息直接发送给特定的订阅者，而是将消息分为特定的类别，订阅者只接受感兴趣的消息。 最新定义：Kafka是一个开源的分布式事件流平台（Event Streaming Platform），被数千家公司用于高性能数据管道、流分析、数据集成和关键任务应用。 1.1 、应用场景 传统的消息队列的主要应用场景有：缓存/消峰、解耦、异步通信。 缓存/消峰:控制和
Kafka入门使用教程
qq_42322158的博客
04-23 2968
消息队列（MQ）是消息传递中间件解决方案的一个组件，旨在支持独立的应用和服务之间的信息交换。消息队列按发送顺序存储“消息”（由应用所创建、供其他应用使用的数据包），直到使用方应用能够处理它们为止。这些消息安全地等待接收方应用做好准备，因此，即使网络或接收方应用出现问题，消息队列中的消息也不会丢失。系统可用性在某种程度上说是降低了的，为什么这样说呢？在引入Kafka之后，就需要考虑Kafka的稳定性，如果突然挂了要如何处理，如何避免Kafka挂掉等问题。
kafka入门到精通
User_bie的博客
02-24 1917
kafka，java，zk
kafka入门
xwh041213的博客
02-26 752
Kafka是一个由Apache软件基金会开发的开源流式数据处理平台。它最初是LinkedIn开发的分布式发布/订阅消息系统，用于处理大规模的实时数据。Kafka具有高吞吐量、可持久化存储、水平扩展性和容错性等特点，被广泛应用于日志收集、数据传输、指标收集等场景中。它提供了生产者和消费者API，以及流处理API，使得用户能够方便地构建实时数据处理应用程序。
一.Kafka入门到精通-Kafka快速入门
墨家巨子@俏如来
05-25 5993
前言 在内卷严重的程序员圈子中，原地踏步就是退步，所以不能再躺平啦，赶紧爬起来学习，接下来博主将推出《Kafka入门到精通》系列文章，让你可以在企业中玩起Kafka来得心应手，此乃升职加薪必备呀。 Kafka认识 Kafka 是由Linkedin公司开发的，支持多分区、多副本，基于 Zookeeper 的分布式消息流平台，是一款基于发布订阅模式的开源消息引擎系统。相对于其他的消息组件来说Kafka拥有更好的吞吐量、内置分区、具有复制和容错的功能，这使它成为一个非常理想的大型消息处理应用。使用场景如：网页浏览
Kafka入门实例
mry6的博客
07-07 1011
Kafka入门实例kafka安装过程工程目录合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 kafka安装过程 kafka安装过程参考：Windows系统下搭建Kafka 工程目录 合理的创建标题，有助于目录的生成 直接输入1次#，并按下s
Kafka入门、介绍、使用及部署
06-30
### Kafka入门、介绍、使用及部署 #### 一、Kafka简介 Kafka是由LinkedIn于2010年12月开源的一款强大的消息系统，它主要用于处理活跃的流式数据，如网站的PV（页面浏览量）、用户行为数据等。传统日志分析系统虽然...
Apache Kafka入门介绍.zip
03-10
**Apache Kafka 入门介绍** Apache Kafka 是一个分布式流处理平台，由 LinkedIn 开发并贡献给了 Apache 软件基金会。Kafka 设计用于构建实时数据管道和流应用，能够高效地处理大量实时数据。它结合了消息队列和日志...
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
09-22
1727008980062_36899042-cccb-455e-a366-ade300382e2a.mp3
基于Java和Lua的美食社交APP设计源码
09-22
本项目是基于Java和Lua开发的美食社交APP，包含92个文件，其中包括80个Java源代码文件、4个XML配置文件、2个PNG图像文件、2个Lua脚本文件、1个LICENSE文件、1个Markdown文档文件和1个YAML配置文件。此外，还有1个SQL文件。该项目旨在为用户提供一个便捷、高效的美食社交平台，支持美食分享、社交互动、活动组织等功能，以提升用户体验和社区活跃度。
模数转换器(ADC)技术解析及应用指南
09-22
内容概要：本文全面介绍了模数转换器(ADC)的相关知识和技术，包括ADC的基本原理、关键技术参数、不同类型ADC的工作方式及其应用领域。并通过生动的比喻解释ADC的概念，强调其在日常生活中的实际应用，并提供了选型指南以及对未来发展方向进行了预测。 适用人群：具备一定模拟电子基础知识的研发人员及电子工程专业师生。 使用场景及目标：指导相关人员正确理解和选用ADC，并提升对最新发展的认知。适用于工业、消费电子、汽车电子、通讯和医疗器械等行业。 阅读建议：读者应重点学习ADC的关键指标及各参数间的关联性，并尝试联系具体的应用场景来加深理解。此外还推荐读者扩展学习相关设计实例和技术文章，以更好地吸收和运用知识内容。
基于微信小程序的碎片化驾考论文.docx
09-22
基于微信小程序的碎片化驾考论文
R语言入门指南_r-book.zip
最新发布
09-22
R语言入门指南_r-book
Kafka入门详解：功能、设计与集群构建
Kafka入门指南深入解析了这个强大的分布式流处理平台的基础知识。首先，Kafka是一种分布式、分区和复制的持久化日志服务，它不遵循JMS规范，而是提供了一种类似的服务。在Kafka架构中，核心组件包括Producer（生产者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值