linux下编译
- 源码下载
bash
git clone https://github.com/edenhill/librdkafka- 配置、编译和安装
bash
# 进入目录
cd librdkafka/
# 配置
./configure
# 编译
make
# 安装
make install- 头文件和库目录
bash
# 头文件
/usr/local/include/librdkafka
rdkafkacpp.h
rdkafka.h
rdkafka_mock.h
# 库
/usr/local/lib
librdkafka++.a
librdkafka.a
librdkafka++.so
librdkafka.so
librdkafka++.so.1
librdkafka.so.1
librdkafka-static.awindows下编译
编译环境
visual studio 2019
依赖库
依赖库直接下载源码编译即可。
- openssl（使用的是1.1.0版本）
- zlib（使用的静态库）
- libcurl（使用的动态库）
- zstd（使用的静态库）
配置
- 附加包含目录配置
- 附加库目录配置
- 附加依赖项配置
编译
生成c和c++动态库。
生产者
参数说明
| 参数 | 描述 |
|---|---|
| bootstrap.servers | 生产者连接集群所需的broker地址清单。 |
| key.serializer和value.serializer | 指定发送消息的key和value的序列化类型。 |
| buffer.memory | RecordAccumulator缓冲区总大小，默认32m。 |
| batch.size | 缓冲区一批数据最大值，默认16k。适当增加该值，可以提高吞吐量，但是如果该值设置太大，会导致数据传输延迟增加。 |
| linger.ms | 如果数据迟迟未达到batch.size，sender等待linger.time之后就会发送数据。单位ms，默认值是0ms，表示没有延迟。生产环境建议该值大小为5-100ms之间。 |
| acks | 0：生产者发送过来的数据，不需要等数据落盘应答。 1：生产者发送过来的数据，Leader收到数据后应答。 -1（all）：生产者发送过来的数据，Leader+和isr队列里面的所有节点收齐数据后应答。 默认值是-1，-1和all是等价的。 |
| max.in.flight.requests.per.connection | 允许最多没有返回ack的次数，默认为5，开启幂等性要保证该值是 1-5的数字。 |
| retries | 当消息发送出现错误的时候，系统会重发消息。retries表示重试次数。默认是int最大值，2147483647。 如果设置了重试，还想保证消息的有序性，需要设置 MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候，其他的消息可能发送成功了。 |
| retry.backoff.ms | 两次重试之间的时间间隔，默认是100ms。 |
| enable.idempotence | 是否开启幂等性，默认true，开启幂等性。 |
| compression.type | 生产者发送的所有数据的压缩方式。默认是none，也就是不压缩。 支持压缩类型：none、gzip、snappy、lz4和zstd。 |
示例
KafkaProducer.h
c++
#ifndef _KAFKA_PRODUCER_H_
#define _KAFKA_PRODUCER_H_
#include "rdkafkacpp.h"
#include <memory>
// 生产者投递报告回调
class ProducerDeliveryReportCb : public RdKafka::DeliveryReportCb
{
public:
void dr_cb(RdKafka::Message& message)
{
if (message.err()) // err
{
printf("Message delivery failed:%s\n",message.errstr().c_str());
}
else
{
printf("Message delivered to topic,topicName:%s,partition:%d\n",
message.topic_name().c_str(),
message.partition());
}
}
};
// 生产者事件回调函数
class ProducerEventCb : public RdKafka::EventCb
{
public:
void event_cb(RdKafka::Event &event)
{
switch (event.type())
{
case RdKafka::Event::EVENT_ERROR:
printf("RdKafka::Event::EVENT_ERROR: %s\n",
RdKafka::err2str(event.err()).c_str());
break;
case RdKafka::Event::EVENT_STATS:
printf("RdKafka::Event::EVENT_STATS, event:%s\n",
event.str().c_str());
break;
case RdKafka::Event::EVENT_LOG:
printf("RdKafka::Event::EVENT_LOG, fac:%s\n",
event.fac().c_str());
break;
case RdKafka::Event::EVENT_THROTTLE:
printf("RdKafka::Event::EVENT_THROTTLE, broker_name:%s\n",
event.broker_name().c_str());
break;
}
}
};
// 生产者自定义分区策略回调：partitioner_cb
class HashPartitionerCb : public RdKafka::PartitionerCb
{
public:
// @brief 返回 topic 中使用 key 的分区，msg_opaque 置 NULL
// @return 返回分区，(0, partition_cnt)
int32_t partitioner_cb(const RdKafka::Topic *topic, const std::string *key,
int32_t partition_cnt, void *msg_opaque)
{
char msg[128] = {0};
// 用于自定义分区策略：这里用 hash。例：轮询方式：p_id++ % partition_cnt
int32_t partition_id = generate_hash(key->c_str(), key->size()) % partition_cnt;
// 输出：[topic][key][partition_cnt][partition_id]，例 [test][6419][2][1]
sprintf(msg, "HashPartitionerCb:topic:[%s], key:[%s], partition_cnt:[%d], partition_id:[%d]",
topic->name().c_str(), key->c_str(), partition_cnt, partition_id);
printf("msg: %s\n", msg);
return partition_id;
}
private:
// 自定义哈希函数
static inline unsigned int generate_hash(const char *str, size_t len)
{
unsigned int hash = 5381;
for (size_t i = 0; i < len; i++)
hash = ((hash << 5) + hash) + str[i];
return hash;
}
};
class CKafkaProducer
{
public:
/**
* @brief CKafkaProducer
* @param brokers
* @param topic
* @param partition:默认分区数
*/
explicit CKafkaProducer(const std::string &brokers, const std::string &topic, int partition);
~CKafkaProducer();
int Create();
void Destroy();
/**
* @brief push Message to Kafka
* @param str, message data
*/
void PushMessage(const std::string &str, const std::string &key);
private:
std::string m_brokers; // Broker 列表，多个使用逗号分隔
std::string m_topicStr; // Topic 名称
int m_partition; // 分区
RdKafka::Conf* m_config; // Kafka Conf对象
RdKafka::Conf* m_topicConfig; // Topic Conf对象
RdKafka::Topic* m_topic; // Topic对象
RdKafka::Producer* m_producer; // Producer对象
RdKafka::DeliveryReportCb* m_dr_cb; // 设置传递回调
RdKafka::EventCb* m_event_cb; // 设置事件回调
RdKafka::PartitionerCb* m_partitioner_cb; // 设置自定义分区回调
};
#endif // _KAFKA_PRODUCER_H_KafkaProducer.cpp
c++
#include "KafkaProducer.h"
CKafkaProducer::CKafkaProducer(const std::string &brokers, const std::string &topic, int partition)
: m_brokers(brokers)
, m_topicStr(topic)
, m_partition(partition)
, m_config(nullptr)
, m_topicConfig(nullptr)
, m_topic(nullptr)
, m_producer(nullptr)
, m_dr_cb(nullptr)
, m_event_cb(nullptr)
, m_partitioner_cb(nullptr)
{
}
MyKafkaProducer::~MyKafkaProducer()
{
Destroy();
}
int MyKafkaProducer::Create()
{
RdKafka::Conf::ConfResult errCode; // 创建错误码
std::string errorStr = ""; // 返回错误信息
do
{
// 创建配置对象
// 1.1、创建 Kafka Conf 对象
m_config = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
if (NULL == m_config)
{
printf("Create RdKafka Conf failed.\n");
break;
}
// 设置 Broker 属性
// （必要参数）指定 broker 地址列表。格式：host1:port1,host2:port2,...
errCode = m_config->set("bootstrap.servers", m_brokers, errorStr);
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(bootstrap.servers) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置生产者投递报告回调
m_dr_cb = new ProducerDeliveryReportCb; // 创建投递报告回调
errCode = m_config->set("dr_cb", m_dr_cb, errorStr); // 异步方式发送数据
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(dr_cb) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置生产者事件回调
m_event_cb = new ProducerEventCb; // 创建生产者事件回调
errCode = m_config->set("event_cb", m_event_cb, errorStr);
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(event_cb) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置数据统计间隔
errCode = m_config->set("statistics.interval.ms", "10000", errorStr);
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(statistics.interval.ms) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置最大发送消息大小
errCode = m_config->set("message.max.bytes", "10240000", errorStr);
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(message.max.bytes) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 2、创建 Topic Conf 对象
m_topicConfig = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
if (NULL == m_topicConfig)
{
printf("Create RdKafka Topic Conf failed.\n");
break;
}
// 设置生产者自定义分区策略回调
m_partitioner_cb = new HashPartitionerCb; // 创建自定义分区投递回调
errCode = m_topicConfig->set("partitioner_cb", m_partitioner_cb, errorStr);
if (RdKafka::Conf::CONF_OK != errCode)
{
printf("Conf set(partitioner_cb) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 2、创建对象
// 2.1、创建 Producer 对象，可以发布不同的主题
m_producer = RdKafka::Producer::create(m_config, errorStr);
if (NULL == m_producer)
{
printf("Create Producer failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 2.2、创建 Topic 对象，可以创建多个不同的 topic 对象
m_topic = RdKafka::Topic::create(m_producer, m_topicStr, m_topicConfig, errorStr);
if (NULL == m_topic)
{
printf("Create Topic failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
printf("Created producer success.\n");
return 0;
}while(0);
Destroy();
return -1;
}
void MyKafkaProducer::Destroy()
{
while (nullptr !=m_producer && m_producer->outq_len() > 0)
{
m_producer->flush(5000);
}
if(nullptr != m_config)
{
delete m_config;
m_config = nullptr;
}
if(nullptr != m_topicConfig)
{
delete m_topicConfig;
m_topicConfig = nullptr;
}
if(nullptr != m_topic)
{
delete m_topic;
m_topic = nullptr;
}
if(nullptr != m_producer)
{
delete m_producer;
m_producer = nullptr;
}
if(nullptr != m_dr_cb)
{
delete m_dr_cb;
m_dr_cb = nullptr;
}
if(nullptr != m_event_cb)
{
delete m_event_cb;
m_event_cb = nullptr;
}
if(nullptr != m_partitioner_cb)
{
delete m_partitioner_cb;
m_partitioner_cb = nullptr;
}
}
void MyKafkaProducer::PushMessage(const std::string &str, const std::string &key)
{
int32_t len = (int32_t)str.length();
void *payload = const_cast<void *>(static_cast<const void *>(str.data()));
// produce 方法，生产和发送单条消息到 Broker
// 如果不加时间戳，内部会自动加上当前的时间戳
RdKafka::ErrorCode errorCode = m_producer->produce(
m_topic, // 指定发送到的主题
RdKafka::Topic::PARTITION_UA, // 指定分区，如果为PARTITION_UA则通过
// partitioner_cb的回调选择合适的分区
RdKafka::Producer::RK_MSG_COPY, // 消息拷贝
payload, // 消息本身
len, // 消息长度
&key, // 消息key
NULL
);
// 轮询处理
m_producer->poll(0);
if (RdKafka::ERR_NO_ERROR != errorCode)
{
printf("Produce failed,errorCode:%s\n",RdKafka::err2str(errorCode).c_str());
// kafka 队列满，等待 100 ms
if (RdKafka::ERR__QUEUE_FULL == errorCode)
{
m_producer->poll(100);
}
}
}test.cpp
c++
#include "KafkaProducer.h"
#include <memory>
int main()
{
std::string brokers = "127.0.0.1:9092";
std::string topic = "first-topic-test";
auto producer = std::make_shared<CKafkaProducer>(brokers, topic, 1000);
if(!producer.get())
return -1;
if(0 != producer->Create())
{
return -1;
}
std::string msg = "test kafka";
std::string key = "xxx"; // 可选,涉及kafka保序策略
producer->PushMessage(msg, key);
producer->Destroy();
delete producer;
system("pause");
return 0;
}消费者
参数说明
| 参数 | 描述 |
|---|---|
| bootstrap.servers | 向Kafka集群建立初始连接用到的host/port列表。 |
| key.deserializer和value.deserializer | 指定接收消息的key和value的反序列化类型。 |
| group.id | 标记消费者所属的消费者组。 |
| enable.auto.commit | 默认值为true，消费者会自动周期性地向服务器提交偏移量。 |
| auto.commit.interval.ms | 如果设置了 enable.auto.commit 的值为true， 则该值定义了消费者偏移量向Kafka提交的频率，默认5s。 |
| auto.offset.reset | 当Kafka中没有初始偏移量或当前偏移量在服务器中不存在（如，数据被删除了），该如何处理？ earliest：自动重置偏移量到最早的偏移量。 latest：默认，自动重置偏移量为最新的偏移量。 none：如果消费组原来的（previous）偏移量不存在，则向消费者抛异常。 anything：向消费者抛异常。 |
| offsets.topic.num.partitions | __consumer_offsets的分区数，默认是50个分区。 |
| heartbeat.interval.ms | Kafka消费者和coordinator之间的心跳时间，默认3s。 该条目的值必须小于 session.timeout.ms ，也不应该高于 session.timeout.ms 的1/3。 |
| session.timeout.ms | Kafka消费者和coordinator之间连接超时时间，默认45s。超过该值，该消费者被移除，消费者组执行再平衡。 |
| max.poll.interval.ms | 消费者处理消息的最大时长，默认是5分钟。超过该值，该消费者被移除，消费者组执行再平衡。 |
| fetch.min.bytes | 默认1个字节。消费者获取服务器端一批消息最小的字节数。 |
| fetch.max.wait.ms | 默认500ms。如果没有从服务器端获取到一批数据的最小字节数。该时间到，仍然会返回数据。 |
| fetch.max.bytes | 默认Default: 52428800（50 m）。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值（50m）仍然可以拉取回来这批数据，因此，这不是一个绝对最大值。一批次的大小受message.max.bytes （broker config）or max.message.bytes （topic config）影响。 |
| max.poll.records | 一次poll拉取数据返回消息的最大条数，默认是500条。 |
示例
KafkaConsumer.h
c++
#ifndef _KAFKA_CONSUMER_H_
#define _KAFKA_CONSUMER_H_
#include "rdkafkacpp.h"
#include <thread>
#include <mutex>
// 设置事件回调
class ConsumerEventCb : public RdKafka::EventCb
{
public:
void event_cb(RdKafka::Event &event)
{
switch (event.type())
{
case RdKafka::Event::EVENT_ERROR:
break;
case RdKafka::Event::EVENT_STATS:
break;
case RdKafka::Event::EVENT_LOG:
break;
case RdKafka::Event::EVENT_THROTTLE:
break;
default:
break;
}
}
};
// 设置消费者组再平衡回调
// 注册该函数会关闭 rdkafka 的自动分区赋值和再分配
class ConsumerRebalanceCb : public RdKafka::RebalanceCb
{
private:
// 打印当前获取的分区
static void printTopicPartition(const std::vector<RdKafka::TopicPartition *>& partitions)
{
for (unsigned int i = 0; i < partitions.size(); i++)
{
printf("count:%d, topic:%s,partition:%d\n",
i,
partitions[i]->topic().c_str(),
partitions[i]->partition());
}
}
public:
// 消费者组再平衡回调
void rebalance_cb(RdKafka::KafkaConsumer *consumer, RdKafka::ErrorCode err,
std::vector<RdKafka::TopicPartition *> &partitions)
{
printf("RebalanceCb: %s\n",RdKafka::err2str(err).c_str());
printTopicPartition(partitions);
// 分区分配成功
if (RdKafka::ERR__ASSIGN_PARTITIONS == err)
{
// 消费者订阅这些分区
consumer->assign(partitions);
// 获取消费者组本次订阅的分区数量，可以属于不同的topic
m_partitionCount = (int)partitions.size();
}
else // 分区分配失败
{
// 消费者取消订阅所有的分区
consumer->unassign();
// 消费者订阅分区的数量为0
m_partitionCount = 0;
}
}
private:
int m_partitionCount; // 消费者组本次订阅的分区数量
};
class CKafkaConsumer
{
public:
/**
* @brief CKafkaConsumer
* @param brokers
* @param groupID:消费者组名称
* @param topics
* @param partition:默认分区数
*/
explicit CKafkaConsumer(const std::string &brokers,
const std::string &groupID,
const std::vector<std::string> &topics,
int partition);
~CKafkaConsumer();
int Create();
void Destroy();
void PullMessage();
public:
void OnRecv();
private:
void ConsumeMsg_(RdKafka::Message *msg, void *opaque);
private:
std::string m_brokers;
std::string m_groupID;
std::vector<std::string> m_topicVector;
int m_partition;
RdKafka::Conf* m_config;
RdKafka::Conf* m_topicConfig;
RdKafka::KafkaConsumer* m_consumer;
RdKafka::EventCb* m_event_cb;
RdKafka::RebalanceCb* m_rebalance_cb;
std::thread m_thread;
bool m_running;
typedef std::lock_guard<std::recursive_mutex> RecursiveGuard;
std::recursive_mutex mutex_;
};
#endif // _KAFKA_CONSUMER_H_KafkaConsumer.cpp
c++
#include "MyKafkaConsumer.h"
static int ConsumerWorker(void* param)
{
CKafkaConsumer* consumer = (CKafkaConsumer*)param;
if (consumer)
{
consumer->OnRecv();
return 0;
}
return -1;
}
CKafkaConsumer::CKafkaConsumer(const std::string &brokers, const std::string &groupID, const std::vector<std::string> &topics, int partition)
: m_brokers(brokers)
, m_groupID(groupID)
, m_topicVector(topics)
, m_partition(partition)
, m_running(true)
{
}
CKafkaConsumer::~CKafkaConsumer()
{
Destroy();
}
int CKafkaConsumer::Create()
{
std::string errorStr;
RdKafka::Conf::ConfResult errorCode;
do
{
// 1、创建配置对象
// 1.1、构造 consumer conf 对象
m_config = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
if(nullptr == m_config)
{
printf("Create RdKafka Conf failed.\n");
break;
}
// 必要参数1：指定 broker 地址列表
errorCode = m_config->set("bootstrap.servers", m_brokers, errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(bootstrap.servers) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 必要参数2：设置消费者组 id
errorCode = m_config->set("group.id", m_groupID, errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(group.id) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置事件回调
m_event_cb = new ConsumerEventCb;
errorCode = m_config->set("event_cb", m_event_cb, errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(event_cb) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置消费者组再平衡回调
m_rebalance_cb = new ConsumerRebalanceCb;
errorCode = m_config->set("rebalance_cb", m_rebalance_cb, errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(rebalance_cb) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 当消费者到达分区结尾，发送 RD_KAFKA_RESP_ERR__PARTITION_EOF 事件
errorCode = m_config->set("enable.partition.eof", "false", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(enable.partition.eof) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 每次最大拉取的数据大小
errorCode = m_config->set("max.partition.fetch.bytes", "1024000", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(max.partition.fetch.bytes) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 设置分区分配策略：range、roundrobin、cooperative-sticky
errorCode = m_config->set("partition.assignment.strategy", "range", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(partition.assignment.strategy) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 心跳探活超时时间---1s
errorCode = m_config->set("session.timeout.ms", "6000", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(session.timeout.ms) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 心跳保活间隔
errorCode = m_config->set("heartbeat.interval.ms", "2000", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(heartbeat.interval.ms) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 1.2、创建 topic conf 对象
m_topicConfig = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
if (nullptr == m_topicConfig)
{
printf("Create RdKafka Topic Conf failed.\n");
break;
}
// 必要参数3：设置新到来消费者的消费起始位置，latest 消费最新的数据，earliest 从头开始消费
errorCode = m_topicConfig->set("auto.offset.reset", "latest", errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Topic Conf set(auto.offset.reset) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 默认 topic 配置，用于自动订阅 topics
errorCode = m_config->set("default_topic_conf", m_topicConfig, errorStr);
if (RdKafka::Conf::CONF_OK != errorCode)
{
printf("Conf set(default_topic_conf) failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
// 2、创建 Consumer 对象
m_consumer = RdKafka::KafkaConsumer::create(m_config, errorStr);
if (nullptr == m_consumer)
{
printf("Create KafkaConsumer failed, errorStr:%s.\n",
errorStr.c_str());
break;
}
printf("Created consumer success, consumerName:%s.\n",
m_consumer->name().c_str());
return 0;
} while (0);
Destroy();
return -1;
}
void CKafkaConsumer::Destroy()
{
m_running = false;
if (m_thread.joinable())
m_thread.join();
if(nullptr != m_consumer)
m_consumer->close();
if(nullptr != m_config)
{
delete m_config;
m_config = nullptr;
}
if(nullptr != m_topicConfig)
{
delete m_topicConfig;
m_topicConfig = nullptr;
}
if(nullptr != m_consumer)
{
delete m_consumer;
m_consumer = nullptr;
}
if(nullptr != m_event_cb)
{
delete m_event_cb;
m_event_cb = nullptr;
}
if(nullptr != m_rebalance_cb)
{
delete m_rebalance_cb;
m_rebalance_cb = nullptr;
}
}
void CKafkaConsumer::PullMessage()
{
m_thread = std::thread(ConsumerWorker, this);
}
void CKafkaConsumer::ConsumeMsg_(RdKafka::Message *msg, void *opaque)
{
switch (msg->err())
{
case RdKafka::ERR__TIMED_OUT: // 超时
break;
case RdKafka::ERR_NO_ERROR: // 有消息进来
printf("Recv Message. topic:%s, partition:[%d], key:%s, payload:%s\n",
msg->topic_name().c_str(),
msg->partition(),
msg->key()->c_str(),
(char *)msg->payload());
break;
default:
break;
}
}
void CKafkaConsumer::OnRecv()
{
if(nullptr == m_consumer)
return;
// 后续可扩展
std::vector<std::string> topicVector;
{
RecursiveGuard mtx(mutex_);
topicVector = m_topicVector;
}
// 1、订阅主题
RdKafka::ErrorCode errorCode = m_consumer->subscribe(topicVector);
if (RdKafka::ERR_NO_ERROR != errorCode)
{
printf("Subscribe failed, errorStr:%s\n", RdKafka::err2str(errorCode).c_str());
return;
}
// 2、拉取并消费消息
while (m_running)
{
RdKafka::Message *msg = m_consumer->consume(1000); // 1000ms超时
if(nullptr != msg)
{
// 消费消息
ConsumeMsg_(msg, nullptr);
delete msg;
msg = nullptr;
}
}
// 同步提交，Consumer 关闭前调用，等待 broker 返回读取消息
if(nullptr != m_consumer)
m_consumer->commitSync();
}test.cpp
c++
#include "KafkaConsumer.h"
#include <memory>
int main()
{
std::string brokers = "127.0.0.1:9092";
std::string groupID = "test";
std::vector<std::string> topics;
topics.push_back("first-topic-test");
auto comsumer = std::make_shared<CKafkaConsumer>(brokers, groupID, topics, 1000);
if(!comsumer.get())
return -1;
if(0 != comsumer->Create())
return -1;
comsumer->PullMessage();
system("pause");
return 0;
}