使用librdkafka 封装的 C++类

最新推荐文章于 2025-04-17 21:46:30 发布
最新推荐文章于 2025-04-17 21:46:30 发布
阅读量7.8k 收藏 19
点赞数 4
分类专栏： C/C++ kafka librdkafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xpg4321/article/details/77676582
版权

 kafka就不介绍了， 可以参考kafka的c/c++高性能客户端librdkafka简介，下面说下librdkafka的编译：

下载地址：https://github.com/edenhill/librdkafka，下载zip包解压。

解压后找到目录下的win32目录， 里面是vs工程。

这里还不能编译，因为缺少openssl，需要编译openssl。

下载ActivePerl：http://www.activestate.com/activeperl/注意64位和32位， 如果你要编译64位的选择64。

下载后直接安装即可，新版程序自动加上了环境变量，无需添加。

 

下载openssl

网址 http://www.openssl.org/

我用的是openssl-1.0.2l版本,解压到F盘kafka目录。

 

安装步骤：

(可以参照openssl目录下的INSTALL.W64)

1.打开命令行(是vs的命令行工具)

进入openssl源码目录。
cd f:/kafka/openssl-1.0.2l
依次执行：

> perl Configure VC-WIN64A
 > ms\do_win64a
 > nmake -f ms\ntdll.mak
 > cd out32dll
 > ..\ms\test

在out32dll目录下：包括可执行文件、两个out32dll和两个inc32夹,里面包含: libeay32.dll, libeay32.lib, ssleay32.dll,ssleay32.lib和头文件。

将上面的文件拷贝到librdkafka的解压目录，dll放在librdkafka的输出目录，其他放在任意位置，配置工程的时候配置进去就行了。

 

回到librdkafka工程(vs2013 打开)：

在additionalinclude directories加上

"F:\kafka\openssl-1.0.2l\inc32"

在additionallibrary directories加上

"F:\kafka\openssl-1.0.2l\out32dll"

开始编译：

1.这里会出现ibeay32MT.lib等找不到，这是因为我们编译的openssl并未使用这个名称，这里只需在连接器的输入里面想连接的lib后面的MT干掉即可。

2.会出现U32 size_t不识别的问题， 只需要修改为对应的类型即可，如u32 定义为typedef unsigned u32,  改为直接使用unsigned即可

3.修改C++->运行库为多线程，debug为MTD ，release为MT，

然后全部生成，会出现一个工程跳过，不用管，实际使用不需要。

 

然后就可以开始封装了：

生产者Producer:

#pragma once

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <csignal>
#include <cstring>
#include <list>
#include "rdkafkacpp.h"
#include <vector>
#include<fstream>
using std::string;
using std::list;
using std::cout;
using std::endl;
using std::vector;
using std::fstream;
class KafkaProducerCallBack : public RdKafka::DeliveryReportCb {
public:
	void dr_cb(RdKafka::Message &message) {
		std::cout << "Message delivery for (" << message.len() << " bytes): " <<
			message.errstr() << std::endl;
		if (message.key())
			std::cout << "Key: " << *(message.key()) << ";" << std::endl;
	}
};
class KafkaProducerEventCallBack : public RdKafka::EventCb {
public:
	void event_cb(RdKafka::Event &event) {
		switch (event.type())
		{
		case RdKafka::Event::EVENT_ERROR:
			std::cerr << "ERROR (" << RdKafka::err2str(event.err()) << "): " <<
				event.str() << std::endl;
			if (event.err() == RdKafka::ERR__ALL_BROKERS_DOWN)
			break;
		case RdKafka::Event::EVENT_STATS:
			std::cerr << "\"STATS\": " << event.str() << std::endl;
			break;
		case RdKafka::Event::EVENT_LOG:
			fprintf(stderr, "LOG-%i-%s: %s\n",
				event.severity(), event.fac().c_str(), event.str().c_str());
			break;
		default:
			std::cerr << "EVENT " << event.type() <<
				" (" << RdKafka::err2str(event.err()) << "): " <<
				event.str() << std::endl;
			break;
		}
	}
};
class KafkaProducerClient
{
public:
	KafkaProducerClient(const string &brokers, const string &topics, int nPpartition = 0);
	virtual ~KafkaProducerClient();
	bool Init();
	void Send(const string &msg);
	void Stop();
private:
	RdKafka::Producer *m_pProducer = NULL;
	RdKafka::Topic *m_pTopic = NULL;
	KafkaProducerCallBack m_producerCallBack;
	KafkaProducerEventCallBack m_producerEventCallBack;
	std::string m_strTopics;
	std::string m_strBroker;
	bool m_bRun = false;
	int m_nPpartition = 0;
};

 

 

#include "KafkaProducerClient.h" 

 
KafkaProducerClient::KafkaProducerClient(const string &brokers, const string &topics, int nPpartition /*= 1*/) 
: m_bRun(true), m_strTopics(topics), m_strBroker(brokers), m_nPpartition(nPpartition)
{
 
}
 
KafkaProducerClient::~KafkaProducerClient()
{
	Stop();
}
 
bool KafkaProducerClient::Init()
{
	string errstr = "";
	RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
	RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
	/*设置broker list*/
	if (conf->set("metadata.broker.list", m_strBroker, errstr) != RdKafka::Conf::CONF_OK){
		std::cerr << "RdKafka conf set brokerlist failed :" << errstr.c_str() << endl;
	}
	conf->set("dr_cb", &m_producerCallBack, errstr);
	conf->set("event_cb", &m_producerEventCallBack, errstr);
	m_pProducer = RdKafka::Producer::create(conf, errstr);
	if (!m_pProducer) {
		std::cerr << "Failed to create producer: " << errstr << std::endl;
		return false;
	}
 
	m_pTopic = RdKafka::Topic::create(m_pProducer, m_strTopics,
		tconf, errstr);
	if (!m_pTopic) {
		std::cerr << "Failed to create topic: " << errstr << std::endl;
		return false;
	}
	return true;
}
 
void KafkaProducerClient::Send(const string &msg)
{
	if (!m_bRun)
		return;
	RdKafka::ErrorCode resp = m_pProducer->produce(m_pTopic, m_nPpartition,
												   RdKafka::Producer::RK_MSG_COPY /* Copy payload */,
												   const_cast<char *>(msg.c_str()), msg.size(),
												   NULL, NULL);
	if (resp != RdKafka::ERR_NO_ERROR)
		std::cerr << "Produce failed: " << RdKafka::err2str(resp) << std::endl;
	else
		std::cerr << "Produced message (" << msg.size() << " bytes)" << std::endl;
 
	m_pProducer->poll(0);
}
 
void KafkaProducerClient::Stop()
{
 
	delete m_pTopic;
	delete m_pProducer;
}
 

 

使用方法：

KafkaProducerClient* KafkaprClient_ = new KafkaProducerClient("localhost:9092", "test", 0);

    KafkaprClient_->Init();
    KafkaprClient_->Send("小刚dddddddd");

 

 

 

 

消费者（Consumer）：

 

#ifndef KAFKACONSUMER_H

#define KAFKACONSUMER_H
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <csignal>
#include <cstring>
#include <list>
#include "rdkafkacpp.h"
#include <vector>
#include<fstream>
using std::string;
using std::list;
using std::cout;
using std::endl;
using std::vector;
using std::fstream;
class KafkaConsumerClient{
public:
    KafkaConsumerClient(const std::string& brokers, const std::string& topics, std::string groupid, int32_t nPartition = 0, int64_t offset = 0);
    virtual ~KafkaConsumerClient();
	//初始化
    bool Init();
	//开始获取消息
    void Start(int timeout_ms);
	//停止
	void Stop();
private:
    void Msg(RdKafka::Message *msg, void *opt);
private:
    std::string m_strBrokers;
    std::string m_strTopics;
    std::string m_strGroupid;
    int64_t m_nLastOffset = 0;
    RdKafka::Consumer *m_pKafkaConsumer = nullptr;
    RdKafka::Topic    *m_pTopic         = nullptr;
    int64_t           m_nCurrentOffset  = RdKafka::Topic::OFFSET_BEGINNING;
    int32_t           m_nPartition      = 0;
	bool m_bRun = false;
};
#endif // KAFKACONSUMMER_H

 

 

#include "KafkaConsumerClient.h"

KafkaConsumerClient::KafkaConsumerClient(const std::string& brokers, const std::string& topics, std::string groupid, int32_t nPartition /*= 0*/, int64_t offset /*= 0*/)
:m_strBrokers(brokers),
m_strTopics(topics),
m_strGroupid(groupid),
m_nPartition(nPartition),
m_nCurrentOffset(offset)
{
}
KafkaConsumerClient::~KafkaConsumerClient()
{
	Stop();
}
bool KafkaConsumerClient::Init(){
	RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    if(!conf){
		std::cerr << "RdKafka create global conf failed" <<endl;
        return false;
    }
    std::string errstr;
    /*设置broker list*/
	if (conf->set("metadata.broker.list", m_strBrokers, errstr) != RdKafka::Conf::CONF_OK){
		std::cerr << "RdKafka conf set brokerlist failed ::" << errstr.c_str() << endl;
    }
    /*设置consumer group*/
    if (conf->set("group.id", m_strGroupid, errstr) != RdKafka::Conf::CONF_OK){
		std::cerr << "RdKafka conf set group.id failed :" << errstr.c_str() << endl;
    }
    std::string strfetch_num = "10240000";
    /*每次从单个分区中拉取消息的最大尺寸*/
    if(conf->set("max.partition.fetch.bytes", strfetch_num, errstr) != RdKafka::Conf::CONF_OK){
		std::cerr << "RdKafka conf set max.partition failed :"<<errstr.c_str()<<endl;
    }
    /*创建kafka consumer实例*/
    m_pKafkaConsumer = RdKafka::Consumer::create(conf, errstr);
    if(!m_pKafkaConsumer){
        std::cerr<<"failed to ceate consumer"<<endl;
    }
    delete conf;
    RdKafka::Conf *tconf = nullptr;
    /*创建kafka topic的配置*/
    tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
    if(!tconf){
		std::cerr << "RdKafka create topic conf failed"<<endl;
        return false;
    }
    if(tconf->set("auto.offset.reset", "smallest", errstr) != RdKafka::Conf::CONF_OK){;
		std::cerr << "RdKafka conf set auto.offset.reset failed:" << errstr.c_str() << endl;
    }
    m_pTopic = RdKafka::Topic::create(m_pKafkaConsumer, m_strTopics, tconf, errstr);
    if(!m_pTopic){
		std::cerr << "RdKafka create topic failed :" << errstr.c_str() << endl;
    }
    delete tconf;
    RdKafka::ErrorCode resp = m_pKafkaConsumer->start(m_pTopic, m_nPartition, m_nLastOffset);
    if (resp != RdKafka::ERR_NO_ERROR){
		std::cerr << "failed to start consumer : " << errstr.c_str() << endl;
    }
    return true;
}
void KafkaConsumerClient::Msg(RdKafka::Message *message, void *opt){
    switch(message->err()){
        case RdKafka::ERR__TIMED_OUT:
            break;
        case RdKafka::ERR_NO_ERROR:
            cout<<("*s\n",
                static_cast<int>(message->len()),
				static_cast<const char *>(message->payload())) << endl;
            m_nLastOffset = message->offset();
            break;
        case RdKafka::ERR__PARTITION_EOF:
			cout << "Reached the end of the queue, offset: " << m_nLastOffset << endl;
            break;
        case RdKafka::ERR__UNKNOWN_TOPIC:
        case RdKafka::ERR__UNKNOWN_PARTITION:
			cout << "Consume failed: " << message->errstr()<<endl;
			Stop();
            break;
        default:
			Stop();
            break;
    }
}
void KafkaConsumerClient::Start(int timeout_ms){
    RdKafka::Message *msg = nullptr;
	m_bRun = true;
	while (m_bRun){
        msg = m_pKafkaConsumer->consume(m_pTopic, m_nPartition, timeout_ms);
        Msg(msg, nullptr);
        m_pKafkaConsumer->poll(0);
        delete msg;
    }
    m_pKafkaConsumer->stop(m_pTopic, m_nPartition);
    if(m_pTopic){
        delete m_pTopic;
        m_pTopic = nullptr;
    }
    if(m_pKafkaConsumer){
        delete m_pKafkaConsumer;
        m_pKafkaConsumer = nullptr;
    }
    /*销毁kafka实例*/
    RdKafka::wait_destroyed(5000);
}
void KafkaConsumerClient::Stop()
{
	m_bRun = false;
}

 

 

使用方法:

KafkaConsumerClient *KafkaConsumerClient_ = new KafkaConsumerClient("localhost:9092", "test", "1", 0);

    if (!KafkaConsumerClient_->Init()){
        fprintf(stderr, "kafka server initialize error\n");
    }
    else{
        KafkaConsumerClient_->Start(1000);
    }

 

 

当前你首先的建立一个kafka 的服务,创建好集群和topic

详情可参考博客：http://www.cnblogs.com/alvingofast/p/kafka_deployment_on_windows.html  写的很详细。

 

最后本博客的所有内容（包括kafka服务搭建需要的jre zookeeper， 其中librdkafka和openssl 64位已编译好）可从本人百度云盘下载：

地址：http://pan.baidu.com/s/1nviKgS5

密码：6tu5

 

 

 

 

 

 

封装C++风格的rdkafka库
忘世麒麟的专栏
12-27 1044
项目中用到了kafka,系统是C++开发的,没有现成的可集成API,查阅github,发现有rdkafka,这个C库,挺好用的,但是,他依然不够简洁,因此,对他做了一下封装. #ifndef _KAFKAMQ_H_ #define _KAFKAMQ_H_ #include <vector> #include <string> #include <librdkaf...
win10 Kafka环境搭建 + 编译C++(librdkafka) 封装库
jieshaoxiansen的博客
12-04 1万+
前言： 历时两天终于将kafka环境搭建好，并将librdkafka的库编译好，踩过很多坑，特在此记录以下。 一. Kafka环境搭建： 搭建Kafka环境主要包含三步： 1、安装JDK（已安装则忽略） 安装完记得配置环境，可参考博文：https://blog.youkuaiyun.com/houwanle/article/details/81773832 2、安装zooKeeper Kafka...
Linux qtcreator下kafka之librdkafka库的C++语言封装，实现生产和消费，配套源码
02-02
Linux qtcreator下kafka之librdkafka库的C++语言封装，实现生产和消费
4.3.3 kafka C++实践
最新发布
gyzhu20的博客
04-17 782
代码参考：cplus_kafka/p目录的代码。
Kafka C++客户端库librdkafka笔记
weixin_40581617的博客
05-07 1158
目录 目录 1 1. 前言 2 2. 缩略语 2 3. 配置和主题 3 3.1. 配置和主题结构 3 3.1.1. Conf 3 3.1.2. ConfImpl 3 3.1.3. Topic 3 3.1.4. TopicImpl 3 4. 线程 4 5. 消费者 5 5.1. 消费者结构 5
librdkafka c++ API 中文版
08-26
自己看了libkafka的源码后翻译的，有些地方翻译不到位还请多多包涵。
kafka（librdkafka） windows c++ 编程
eigen基本使用方法
08-30 3775
前言：网上看到很多关于kafka在windows下的编译及使用cmd运行例子，也有c++在集群上和windows的kafka编程例子，之前自己编译好了librdkafka，然后也生成了lib和dll文件，例子程序库文件都配好了，但是运行不了。自己摸索了两天终于可以编程成功并且能够发送信息了。之前以为编译好librdkafka就可以运行了，然而并非如此，简单的说明一下他们的关系。如下所示，也就是说我...
librdkafka-1.9.0.zip kafka C++
11-09
《深入理解librdkafka-1.9.0与Kafka C++源码》 librdkafka是一款高效且强大的Kafka客户端库，专为C和C++编程语言设计。在1.9.0版本中，它提供了丰富的功能，包括生产者、消费者以及管理API，使得开发者能够轻松地在...
Kafka开发示例：封装C++类简化生产者与消费者代码
5. Kafka的C++封装：文件信息中提到的kafka_producer和kafka_consumer两个工程代码是将librdkafka中的示例代码rdkafka_example.c封装成了C++类，这表明开发者希望提供一种更符合C++编程习惯的方式来使用Kafka。...
win32 C++ kafka 库
01-22
C++ 使用kafka客户端.这个资源是生成的dll和头文件。里面有Debug和Release版本的dll和lib.
win32下的kafkac++ api
08-10
包含.dll和.lib和zlibd.dll和rdkafka.h
librdkafka_x86-windows.rar
10-20
librdkafka 是 Apache Kafka 的 C/C++ 开发包，提供生产者、消费者和管理客户端。设计理念是可靠以及高性能的消息传输，当前可支持每秒超过 100 万的消息生产和 300 万每秒的消息消费。编译文件包含c和c++文件，编译工具vcpkg
kafka,zookeeper,librdkafka(用于c++客户端的库)以及生产者消费者等的示例代码
10-26
kafka,zookeeper,librdkafka(用于c++客户端的库)以及生产者消费者等的示例代码。以上安装包均是目前为止最新的安装包，如果需要别的版本安装包，文件中赋有各安装包下载地址，以供下载，希望能够帮助到你
使用librdkafka的C++接口实现简单的生产者和消费者
热门推荐
草上爬的博客
04-02 2万+
一.编译librdkafka 环境：Fedora 20，32位 依赖：pthreads（必选），zlib（可选），libssl-dev（可选），libsasl2-dev（可选） 先查看自己的linux上是否安装了pthreads，指令如下： # locate libpthread 因为我之前安过了，所以可以直接编译librdkafka，没有安的下个pthreads的源码——con
RdKafka高级用法及例子
CarryMee的博客
05-17 1690
本文介绍了 RdKafka 的高级用法，包括消费者组管理、消息回溯、消息分区和消息筛选，并给出了一个完整的生产者和消费者实现。希望能够对大家学习和使用 RdKafka 带来一些帮助。
librdkafka介绍文档
12-23 1万+
Introduction to librdkafka - the Apache Kafka C/C++ client library
kafka的c/c++高性能客户端librdkafka简介/使用librdkafka的C++接口实现简单的生产者和消费者
咸鱼一号的博客
07-30 1万+
Librdkafka是c语言实现的apachekafka的高性能客户端，为生产和使用kafka提供高效可靠的客户端，并且提供了c++接口 性能： Librdkafka 是一款专为现代硬件使用而设计的高性能库，它尝试将内存复制保持在最小，可以让用户决定是需要高吞吐量还是低延迟的服务，性能调优的两个最重要的配置是： *batch.num.messages：在发送消息之前累积在本地队列中等待的消息的最小数量。 *queue.buffering.max.ms：等待batch.num.messages多.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值