Kafka入门之生产者消费者测试

最新推荐文章于 2024-07-25 11:32:18 发布
最新推荐文章于 2024-07-25 11:32:18 发布
阅读量108 收藏
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/zhangchao0515/p/9519151.html
版权

目录：

kafka启动脚本以及关闭脚本

1. 同一个生产者同一个Topic，两个相同的消费者相同的Group

2. 同一个生产者同一个Topic，两个消费者不同Group

 3. 两个生产者同一个Topic，生产不同的消息，一个消费者

 

运行的前提是有kafka，并启动kafka，这里我写了个kafka启动脚本：

#!/bin/sh
#创建启动脚本
#启动zookeeper
/user/kafka_2.11-2.0.0/bin/zookeeper-server-start.sh /user/kafka_2.11-2.0.0/config/zookeeper.properties &
sleep 3 #等3秒后执行

#启动kafka
/user/kafka_2.11-2.0.0/bin/kafka-server-start.sh /user/kafka_2.11-2.0.0/config/server.properties &

 kafka关闭脚本：

#!/bin/sh
#创建关闭脚本
#关闭kafka
/user/kafka_2.11-2.0.0/bin/kafka-server-stop.sh /user/kafka_2.11-2.0.0/config/server.properties &
sleep 3 #等3秒后执行

#关闭zookeeper
/user/kafka_2.11-2.0.0/bin/zookeeper-server-stop.sh /user/kafka_2.11-2.0.0/config/zookeeper.properties &

 

1. 同一个生产者同一个Topic，两个相同的消费者相同的Group

新建一个生产者TestKafkaProducer，需要引入kafka的lib中的jar包，主要包括两个类，如下所示：

kafka生产者：

package com.zc.kafka.producer.main;

import java.util.Properties;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

/**
 * Kafka生产者
 * 先启动生产者，发送消息到broker，这里简单发送了10条从0-9的消息，再启动消费者，控制台输出如下：
 */
public class SimpleKafkaProducer {

    private static long i = 0;
    
    public void send(String str) {
        // TODO Auto-generated method stub

        Properties props = new Properties();

        //broker地址
        props.put("bootstrap.servers", "localhost:9092");

        //请求时候需要验证
        props.put("acks", "all");

        //请求失败时候需要重试
        props.put("retries", 0);

        //内存缓存区大小
        props.put("buffer.memory", 33554432);

        //指定消息key序列化方式
        props.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");

        //指定消息本身的序列化方式
        props.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String, String> producer = new KafkaProducer<>(props);

        //for (int i = 0; i < 10; i++) {  //i < 10
            // 生产一条消息的时间有点长
            //producer.send(new ProducerRecord<>("test", Integer.toString(i), Integer.toString(i)));
            //System.out.println(i);
        //}
        // 这里的“test“是topic
        producer.send(new ProducerRecord<>("test", String.valueOf(i), str));
        i++;
        System.out.println("Message sent successfully");
        producer.close();
    }

}

生产数据：

package com.zc.kafka.producer.test;

import com.zc.kafka.producer.main.SimpleKafkaProducer;

public class TestSimpleKafkaProducer {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long i=0;
        SimpleKafkaProducer skp = new SimpleKafkaProducer();
        while(true) {
            skp.send("Hello: "+ String.valueOf(i));
            i++;
            try {
                Thread.sleep(10000);  //ms
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

新建两个消费者，引入kafka中lib中的jar包，分别是TestKafkaConsumer和TestKafkaConsumer2，他们有一个相同的类，如下所示：

消息消费者：

package com.zc.kafka.consumer.main;

import java.util.Collections;
import java.util.Properties;

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

/**
 * kafka消费者
 */
public class SimpleKafkaConsumer {

    @SuppressWarnings({ "deprecation", "resource" })
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Properties props = new Properties();

        props.put("bootstrap.servers", "localhost:9092");
        //每个消费者分配独立的组号，这里的“test”是group
        props.put("group.id", "test");

        //如果value合法，则自动提交偏移量
        props.put("enable.auto.commit", "true");

        //设置多久一次更新被消费消息的偏移量
        props.put("auto.commit.interval.ms", "1000");

        //设置会话响应的时间，超过这个时间kafka可以选择放弃消费或者消费下一条消息
        props.put("session.timeout.ms", "30000");
        
        //
        //props.put("auto.offset.reset", "earliest");

        props.put("key.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

        consumer.subscribe(Collections.singletonList("test"));  //核心函数1：订阅topic

        System.out.println("Subscribed to topic " + "test");
        //int i = 0;

        while (true) {
            //System.out.println(i++);
            //核心函数2：long poll，一次拉取回来多个消息
            /* 读取数据，读取超时时间为100ms */
            ConsumerRecords<String, String> records = consumer.poll(100);  
            //System.out.println(records.count());
            for (ConsumerRecord<String, String> record : records)
                // print the offset,key and value for the consumer records.
                System.out.printf("offset = %d, key = %s, value = %s\n",
                        record.offset(), record.key(), record.value());
        }
    }

}

启动生产者，并启动两个消费者。（我的生产者和两个消费者都在同一主机上）

结果是：

第一个启动的消费者消费消息，第二个消费者没有消费消息；我关闭掉第一个消费者，第二个消费者就会消费消息； （因为Group相同）

同时只会有一个消费者在消费消息，并且消费消息没有重叠。

消费者1：

Subscribed to topic test
offset = 4451, key = 25, value = Hello: 25
offset = 4452, key = 26, value = Hello: 26
offset = 4453, key = 27, value = Hello: 27
offset = 4454, key = 28, value = Hello: 28
offset = 4455, key = 29, value = Hello: 29
offset = 4456, key = 30, value = Hello: 30
offset = 4457, key = 31, value = Hello: 31
offset = 4458, key = 32, value = Hello: 32

消费者2：

Subscribed to topic test
offset = 4459, key = 33, value = Hello: 33
offset = 4460, key = 34, value = Hello: 34
offset = 4461, key = 35, value = Hello: 35
offset = 4462, key = 36, value = Hello: 36

 

2. 同一个生产者同一个Topic，两个消费者不同Group

这里只是修改了TestKafkaConsumer2的源码，修改了组，具体如下所示：

package com.zc.kafka.consumer.main;

import java.util.Collections;
import java.util.Properties;

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

/**
 * kafka消费者
 */
public class SimpleKafkaConsumer {

    @SuppressWarnings({ "deprecation", "resource" })
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Properties props = new Properties();

        props.put("bootstrap.servers", "localhost:9092");
        //每个消费者分配独立的组号
        props.put("group.id", "Consumer2");  //修改了组

        //如果value合法，则自动提交偏移量
        props.put("enable.auto.commit", "true");

        //设置多久一次更新被消费消息的偏移量
        props.put("auto.commit.interval.ms", "1000");

        //设置会话响应的时间，超过这个时间kafka可以选择放弃消费或者消费下一条消息
        props.put("session.timeout.ms", "30000");
        
        //
        //props.put("auto.offset.reset", "earliest");

        props.put("key.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

        consumer.subscribe(Collections.singletonList("test"));  //核心函数1：订阅topic

        System.out.println("Subscribed to topic " + "test");
        //int i = 0;

        while (true) {
            //System.out.println(i++);
            //核心函数2：long poll，一次拉取回来多个消息
            /* 读取数据，读取超时时间为100ms */
            ConsumerRecords<String, String> records = consumer.poll(100);  
            //System.out.println(records.count());
            for (ConsumerRecord<String, String> record : records)
                // print the offset,key and value for the consumer records.
                System.out.printf("offset = %d, key = %s, value = %s\n",
                        record.offset(), record.key(), record.value());
        }
    }

}

启动生产者，并启动两个消费者。（我的生产者和两个消费者都在同一主机上）

结果是：

第一个启动的消费者消费消息，第二个消费者也再消费消息；（因为Group不相同）

同时两个消费者都在消费消息，并且消费消息重叠。

消费者1：

Subscribed to topic test
offset = 4463, key = 0, value = Hello: 0
offset = 4464, key = 1, value = Hello: 1
offset = 4465, key = 2, value = Hello: 2
offset = 4466, key = 3, value = Hello: 3
offset = 4467, key = 4, value = Hello: 4
offset = 4468, key = 5, value = Hello: 5
offset = 4469, key = 6, value = Hello: 6
offset = 4470, key = 7, value = Hello: 7
offset = 4471, key = 8, value = Hello: 8
offset = 4472, key = 9, value = Hello: 9

消费者2：

Subscribed to topic test
offset = 4466, key = 3, value = Hello: 3
offset = 4467, key = 4, value = Hello: 4
offset = 4468, key = 5, value = Hello: 5
offset = 4469, key = 6, value = Hello: 6
offset = 4470, key = 7, value = Hello: 7
offset = 4471, key = 8, value = Hello: 8
offset = 4472, key = 9, value = Hello: 9

 

3. 两个生产者同一个Topic，生产不同的消息，一个消费者

生产的数据和第一个生产者不同：

package com.zc.kafka.producer.test;

import com.zc.kafka.producer.main.SimpleKafkaProducer;

public class TestSimpleKafkaProducer2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        long i=0;
        SimpleKafkaProducer skp = new SimpleKafkaProducer();
        while(true) {
            skp.send("Kafka: "+ String.valueOf(i));   //生产的数据不同
            i++;
            try {
                Thread.sleep(10000);  //ms
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

启动两个生产者，并启动消费者。（我的生产者和消费者都在同一主机上）

结果是：

消费者同时收到了两个生产者的消息； （因为Topic相同）

消费者：

Subscribed to topic test
offset = 4473, key = 0, value = Hello: 0
offset = 4474, key = 0, value = Kafka: 0
offset = 4475, key = 1, value = Hello: 1
offset = 4476, key = 1, value = Kafka: 1
offset = 4477, key = 2, value = Hello: 2
offset = 4478, key = 2, value = Kafka: 2
offset = 4479, key = 3, value = Hello: 3
offset = 4480, key = 3, value = Kafka: 3
offset = 4481, key = 4, value = Hello: 4
offset = 4482, key = 4, value = Kafka: 4

 

转载于:https://www.cnblogs.com/zhangchao0515/p/9519151.html

weixin_30673611
关注
【大数据】【kafka】kafka生产者和消费者测试
weixin_42340596的博客
05-21 658
参考：http://dblab.xmu.edu.cn/blog/1096-2/ 前提条件:启动zookeeper,kafka. 1.启动zookeeper；bin/zkServer.sh start 2.启动Kafka；bin/kafka-server-start.sh config/server.properties 总结：kafka的topic测试过程需要三步， 1.创建topic ；bin/kafka-topics.sh --create --zookeeper localhost:2181 --re
Kafka 生产者和消费者学习笔记
Leo的博客
07-04 896
最近搭建 kafka 集群环境以便于收集应用程序日志并进行个性化的处理，因此学习了 kafka 生产者和消费者 python 程序的实现。这篇文章当是个 kafka 的学习笔记。 一、搭建 kafka 集群 为方便测试，我们在 MacOS 单机上搭建具有三个 kafka 节点的集群。如果在生产上部署 kafka ，请在不同的物理机上部署 kafka 集群。 1. 下载 kafka 镜像 我们使用 wurstmeister/kafka 镜像来部署 kafka，由于 kafka 依赖于 zookeeper ，因
kafka生产者--消费者数据测试
corpse2010的专栏
01-27 550
1、必须安装zk，配置zk，启动zk K8S-T01是主机名。 bin/zkServer.sh start ./conf/zoo.cfg bin/zkServer.sh status ./conf/zoo.cfg 2、安装kafka，配置kafka，启动kafka 先创建一个topic: bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partiti...
3.kafka生产者消费者测试
flying roc
06-30 1074
kafka调试 1.eclipse新建maven项目 eclipse新建maven项目，pom.xml文件添加kafka-clients依赖 kafka-clients下载地址 2.修改配置 idea 之前已经启动了kafka的core模块，修改server.properties 添加localhost listeners=PLAINTEXT://localhost:9092 3.生产者代码 import java.util.Properties; import java.util.concurren
Kafka生产者与消费者练习测试题
qq_31412425的博客
04-08 308
一、通过Producer API发送到kafka中的【topicHW】注：topic自行创建二、创建一个Consumer API程序，对kafka集群中的【topicHW】进行消费。注意，如果没有启动consumer就直接开始生产数据，则无法读取到刚刚生产到的数据，如果出现了这种情况，需要重新运行一下生产者的代码即可。topicDEAL 这个topic中的数据消费在moba中处理。
Kafka集群搭建与测试详细教程 | 附带详详细截图
大数据小禅的博客
05-30 1901
详细讲解Kafka的集群搭建过程
Kafka入门到精通
shuai_h的博客
07-10 3665
Kafka是由Apache软件基金会开发的一个开源流平台，由Scala和Java编写。Kafka的Apache官网是这样介绍Kakfa的。Apache Kafka是一个分布式流平台。发布和订阅流数据流，类似于消息队列或者是企业消息传递系统以容错的持久化方式存储数据流处理数据流Publish and subscribe：发布与订阅Store：存储Process：处理特性。
任务8：08_Kafka入门_命令行控制台生产者消费者
有上进心的阿龙
01-08 279
刚才已经学习了主题的增删查学习了。 缺的就是生产者和消费者。 生产者和消费者有专门的命令。 控制台的生产者，控制台的消费者。 既然是生产者，就需要告诉我，你要往哪个主题生产。往这个first主题生产的时候，你需要告诉我连接哪个kafka的集群。因为kafka集群和cosumer这块，是需要往zk里面存数据的。 –broker-list hadoop102:9092 这里的9092的端口号主要是因为要连接kafka本地集群。 在102上开启生产者： 这里出现一个小箭头。 在这里就可以输入一些消息了。也就是
kafka快速入门11（集群部署，生产者，集群，消费者深入原理剖析）
自律
12-22 436
一、消息队列介绍 1.1 什么是消息队列 消息队列(mq message queue)的本质是缓冲数据。之所以称之为消息队列系统或者消息队列组件，是因为往消息队列提供了消息（数据）的管理功能，比如：记录上次读数据的偏移量、消息读取之后是否删除、消息的备份和安全等机制 主流消息队列组件有：ActiveMQ、RabbitMQ、RocketMQ、Kafka等，大数据领域主要使用Kafka。 1.2 消息队列的工作模式 1.3 为什么要用消息队列 1）解耦： 　　允许你独立的扩展或修改两边的处理过程，只要确保它
pykafka:适用于Python的Apache Kafka客户端； 高水平和低水平的消费者生产者，表现出色
04-05
它包括Kafka生产者和使用者的Python实现，可以选择由基于的C扩展支持。 它在Python 2.7 +，Python 3.4+和PyPy下运行，并支持Kafka 0.8.2和更高版本。 PyKafka的主要目标是使用Python程序员熟悉的习语为提供类似...
kafka-consumer:简单的 Scala Kafka 消费者
06-13
kafka-消费者 简单的 Scala Kafka 消费者 如何构建
kafka-集群-生产消费测试
小丁的博客
06-04 468
kafka-集群-生产消费测试。
Kafka：生产者压测和消费者压测
程序员无羡的博客
04-06 1701
Kafka：生产者压测和消费者压测
Kafka consumer 与 producer测试
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
06-29 850
本实验任务主要完成基于ubuntu环境掌握Kafka consumer 与 producer测试的工作。通过完成本实验任务，要求学生熟练掌握Kafka consumer 与 producer的使用，为后续实验的开展奠定Kafka平台基础，也为从事大数据平台运维工程师、大数据技术支持工程师等岗位工作奠定夯实的技能基础。1、掌握Kafka consumer 与 producer测试Ubuntu(三台节点:mater：192.168.0.3,slave1：192.168.0.2,slave2：192.168.0.
kafka-生产消费实验
xiao_bai111的博客
05-17 547
进行kafka的生产及消费实验测试样例 1，创建topic，分区数4，副本因子1 .\kafka-topics.bat --zookeeper localhost:2181 --create --topic my_topic_name --partitions 4 --replication-factor 1 2，创建一个消费者属于消费者组my-group .\kafka-console-consumer.bat --bootstrap-server localhost:9092 --group my-
Kafka的生产者消费者Java操作示例
翻过一座座山
08-02 7275
本文提供Java对Kafka生产者、消费者操作的简单示例： 1.首先看下pom依赖： &lt;dependency&gt; &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt; &lt;artifactId&gt;kafka-clients&lt;/artifactId&gt; &lt;version&gt;2.0.0&lt;/ve...
Kafka压力测试
最新发布
qq_54738879的博客
07-25 1042
官方自带kafka-producer-perf-test.shlinux网络带宽监控工具sar。结论：千兆网卡客户端网络流量达上限，Kafka集群生产吞吐,千兆网卡客户端网络流量达上限，Kafka集群消费吞吐为
kafka 消费者和生产者测试类
weixin_30426879的博客
08-16 241
pom.xml: <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.or...
详细讲解如何使用Java连接Kafka构建生产者和消费者（带测试样例）
天然玩家的博客
08-04 8813
详细讲解如何使用Java连接Kafka构建生产者和消费者。
Kafka深度解析：从入门到精通企业级消息队列
11. **幂等性与事务**：了解Kafka如何实现生产者幂等性，保证消息的正确性，以及如何使用事务确保消息的一致性。 12. **分区与副本机制**：研究Kafka的分区策略和副本复制，理解其在高可用性和容错性上的设计。 13...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值